Merge pull request #77 from github/kpaulisse-override-rename

Change FactOverride -> Override

Author: kpaulisse

doc/dev/api/v1.md

@@ -34,8 +34,8 @@ The `OctocatalogDiff::API::V1::Diff` object represents a difference between two
 
 [Read more about the `OctocatalogDiff::API::V1::Diff` object](/doc/dev/api/v1/objects/diff.md)
 
-#### OctocatalogDiff::API::V1::FactOverride
+#### OctocatalogDiff::API::V1::Override
 
-The `OctocatalogDiff::API::V1::FactOverride` object represents a user-supplied fact that will be used when compiling a catalog.
+The `OctocatalogDiff::API::V1::Override` object represents a user-supplied fact or ENC parameter that will be used when compiling a catalog.
 
-[Read more about the `OctocatalogDiff::API::V1::FactOverride` object](/doc/dev/api/v1/objects/fact_override.md)
+[Read more about the `OctocatalogDiff::API::V1::Override` object](/doc/dev/api/v1/objects/override.md)

doc/dev/api/v1/objects/override.md

@@ -0,0 +1,30 @@
+# octocatalog-diff v1 API documentation: OctocatalogDiff::API::V1::Override
+
+## Overview
+
+`OctocatalogDiff::API::V1::Override` is an object that represents a user-supplied fact or ENC parameter that will be used when compiling a catalog.
+
+## Constructor
+
+#### `#new(<Hash> { key: <String>, value: <Object> })`
+
+The hash must contain the following keys:
+
+- `:key` (String) - The name of the fact or ENC parameter (e.g. `operatingsystem` or `parameters::fooclass::fooparam`)
+- `:value` (?) - The value of the fact or ENC parameter
+
+See also: `#create_from_input`
+
+## Methods
+
+#### `#create_from_input(<String> key=value)` (OctocatalogDiff::API::V1::Override)
+
+Parses the string (see [Overriding facts](/doc/advanced-override-facts.md) for the format to use). Returns a `OctocatalogDiff::API::V1::Override` object with key and value parsed from the string.
+
+#### `#key` (String)
+
+Returns the key as supplied in the constructor.
+
+#### `#value` (?)
+
+Returns the value as supplied in the constructor.

lib/octocatalog-diff/api/v1.rb

@@ -5,7 +5,7 @@
 require_relative 'v1/catalog-diff'
 require_relative 'v1/config'
 require_relative 'v1/diff'
-require_relative 'v1/fact_override'
+require_relative 'v1/override'
 
 module OctocatalogDiff
   module API

lib/octocatalog-diff/api/v1/fact_override.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module OctocatalogDiff
+  module API
+    module V1
+      # Sets up the override of a fact or ENC parameter during catalog compilation.
+      class Override
+        # Accessors
+        attr_reader :key, :value
+
+        # Constructor: Accepts a key and value.
+        # @param input [Hash] Must contain :key and :value
+        def initialize(input)
+          @key = input.fetch(:key)
+          @value = parsed_value(input.fetch(:value))
+        end
+
+        # Initialize from a parsed command line
+        # @param input [String] Command line parameter
+        # @return [OctocatalogDiff::API::V1::Override] Initialized object
+        def self.create_from_input(input, key = nil)
+          # Normally the input will be a string in the format key=(data type)value where the data
+          # type is optional and the parentheses are literal. Example:
+          #   foo=1            (auto-determine data type - in this case it would be a fixnum)
+          #   foo=(fixnum)1    (will be a fixnum)
+          #   foo=(string)1    (will be '1' the string)
+          # If input is not a string, we can still construct the object if the key is given.
+          # That input would come directly from code and not from the command line, since inputs
+          # from the command line are always strings.
+          if key.nil? && input.is_a?(String)
+            unless input.include?('=')
+              raise ArgumentError, "Fact override '#{input}' is not in 'key=(data type)value' format"
+            end
+            k, v = input.strip.split('=', 2).map(&:strip)
+            new(key: k, value: v)
+          elsif key.nil?
+            message = "Define a key when the input is not a string (#{input.class} => #{input.inspect})"
+            raise ArgumentError, message
+          else
+            new(key: key, value: input)
+          end
+        end
+
+        private
+
+        # Guess the datatype from a particular input
+        # @param input [String] Input in string format
+        # @return [?] Output in appropriate format
+        def parsed_value(input)
+          # If data type is explicitly given
+          if input =~ /^\((\w+)\)(.*)$/m
+            datatype = Regexp.last_match(1)
+            value = Regexp.last_match(2)
+            return convert_to_data_type(datatype.downcase, value)
+          end
+
+          # Guess data type
+          return input.to_i if input =~ /^-?\d+$/
+          return input.to_f if input =~ /^-?\d*\.\d+$/
+          return true if input.casecmp('true').zero?
+          return false if input.casecmp('false').zero?
+          input
+        end
+
+        # Handle data type that's explicitly given
+        # @param datatype [String] Data type (as a string)
+        # @param value [String] Value given
+        # @return [?] Value converted to specified data type
+        def convert_to_data_type(datatype, value)
+          return value if datatype == 'string'
+          return parse_json(value) if datatype == 'json'
+          return nil if datatype == 'nil'
+          if datatype == 'fixnum'
+            return Regexp.last_match(1).to_i if value =~ /^(-?\d+)$/
+            raise ArgumentError, "Illegal fixnum '#{value}'"
+          end
+          if datatype == 'float'
+            return Regexp.last_match(1).to_f if value =~ /^(-?\d*\.\d+)$/
+            return Regexp.last_match(1).to_f if value =~ /^(-?\d+)$/
+            raise ArgumentError, "Illegal float '#{value}'"
+          end
+          if datatype == 'boolean'
+            return true if value.casecmp('true').zero?
+            return false if value.casecmp('false').zero?
+            raise ArgumentError, "Illegal boolean '#{value}'"
+          end
+          raise ArgumentError, "Unknown data type '#{datatype}'"
+        end
+
+        # Parse JSON value
+        # @param input [String] Input, hopefully in JSON format
+        # @return [?] Output data structure
+        def parse_json(input)
+          JSON.parse(input)
+        rescue JSON::ParserError => exc
+          raise JSON::ParserError, "Failed to parse JSON: input=#{input} error=#{exc}"
+        end
+      end
+    end
+  end
+end

lib/octocatalog-diff/api/v1/override.rb

@@ -3,7 +3,6 @@
 require_relative 'api/v1'
 require_relative 'catalog-util/cached_master_directory'
 require_relative 'cli/diffs'
-require_relative 'cli/fact_override'
 require_relative 'cli/options'
 require_relative 'cli/printer'
 require_relative 'errors'
@@ -82,7 +81,6 @@ def self.cli(argv = ARGV, logger = Logger.new(STDERR), opts = {})
       veto_with_none_options = %w(hiera_path hiera_path_strip)
       veto_with_none_options.each { |x| options.delete(x.to_sym) if options[x.to_sym] == :none }
 
-      # Fact overrides come in here - 'options' is modified
       setup_fact_overrides(options)
 
       # Configure the logger and logger.debug initial information
@@ -129,15 +127,19 @@ def self.parse_opts(argv)
       Options.parse_options(argv, options)
     end
 
+    # Generic overrides
+    def self.setup_overrides(key, options)
+      o = options["#{key}_in".to_sym]
+      return unless o.is_a?(Array)
+      return unless o.any?
+      options[key] ||= []
+      options[key].concat o.map { |x| OctocatalogDiff::API::V1::Override.create_from_input(x) }
+    end
+
     # Fact overrides come in here
     def self.setup_fact_overrides(options)
-      [:from_fact_override, :to_fact_override].each do |key|
-        o = options["#{key}_in".to_sym]
-        next unless o.is_a?(Array)
-        next unless o.any?
-        options[key] ||= []
-        options[key].concat o.map { |x| OctocatalogDiff::Cli::FactOverride.fact_override(x) }
-      end
+      setup_overrides(:from_fact_override, options)
+      setup_overrides(:to_fact_override, options)
     end
 
     # Helper method: Configure and setup logger