Wrap fact override calls in API object

Author: Kevin Paulisse

lib/octocatalog-diff/cli/fact_override.rb

@@ -13,80 +13,7 @@ class FactOverride
       # @param input [String] Input in the format: key=(data type)value
       # @return [OctocatalogDiff::API::V1::FactOverride] Constructed override object
       def self.fact_override(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
-          key, raw_value = input.strip.split('=', 2)
-          value = parsed_value(raw_value)
-          OctocatalogDiff::API::V1::FactOverride.new(fact_name: key, value: value)
-        elsif key.nil?
-          message = "Define a key when the input is not a string (#{input.class} => #{input.inspect})"
-          raise ArgumentError, message
-        else
-          OctocatalogDiff::API::V1::FactOverride.new(fact_name: key, value: input)
-        end
-      end
-
-      # Guess the datatype from a particular input
-      # @param input [String] Input in string format
-      # @return [?] Output in appropriate format
-      def self.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 self.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 self.parse_json(input)
-        JSON.parse(input)
-      rescue JSON::ParserError => exc
-        raise JSON::ParserError, "Failed to parse JSON: input=#{input} error=#{exc}"
+        OctocatalogDiff::API::V1::Override.create_from_input(input, key)
       end
     end
   end

spec/octocatalog-diff/tests/cli/fact_override_spec.rb

@@ -259,39 +259,4 @@
       end
     end
   end
-
-  context 'with non-string input' do
-    describe '#new' do
-      it 'should pass through a fixnum without manipulation' do
-        testobj = OctocatalogDiff::Cli::FactOverride.fact_override(42, 'foo')
-        expect(testobj.key).to eq('foo')
-        expect(testobj.value).to eq(42)
-      end
-
-      it 'should pass through a float without manipulation' do
-        testobj = OctocatalogDiff::Cli::FactOverride.fact_override(42.15, 'foo')
-        expect(testobj.key).to eq('foo')
-        expect(testobj.value).to eq(42.15)
-      end
-
-      it 'should pass through a boolean without manipulation' do
-        testobj = OctocatalogDiff::Cli::FactOverride.fact_override(false, 'foo')
-        expect(testobj.key).to eq('foo')
-        expect(testobj.value).to eq(false)
-      end
-
-      it 'should pass through a nil without manipulation' do
-        testobj = OctocatalogDiff::Cli::FactOverride.fact_override(nil, 'foo')
-        expect(testobj.key).to eq('foo')
-        expect(testobj.value).to eq(nil)
-      end
-
-      it 'should pass through a hash without manipulation' do
-        arg = { 'foo' => 'bar', 'baz' => [1, 2, 3, 4, 5] }
-        testobj = OctocatalogDiff::Cli::FactOverride.fact_override(arg, 'foo')
-        expect(testobj.key).to eq('foo')
-        expect(testobj.value).to eq(arg)
-      end
-    end
-  end
 end

spec/octocatalog-diff/tests/cli_spec.rb

@@ -183,7 +183,7 @@
       expect(options[:from_fact_override]).to be_a_kind_of(Array)
       expect(options[:from_fact_override].size).to eq(1)
       ffo = options[:from_fact_override].first
-      expect(ffo).to be_a_kind_of(OctocatalogDiff::API::V1::FactOverride)
+      expect(ffo).to be_a_kind_of(OctocatalogDiff::API::V1::Override)
       expect(ffo.key).to eq('foo')
       expect(ffo.value).to eq('bar')
     end
@@ -195,10 +195,10 @@
       expect(options[:to_fact_override].size).to eq(2)
 
       tfo = options[:to_fact_override]
-      expect(tfo[0]).to be_a_kind_of(OctocatalogDiff::API::V1::FactOverride)
+      expect(tfo[0]).to be_a_kind_of(OctocatalogDiff::API::V1::Override)
       expect(tfo[0].key).to eq('foo')
       expect(tfo[0].value).to eq('bar')
-      expect(tfo[1]).to be_a_kind_of(OctocatalogDiff::API::V1::FactOverride)
+      expect(tfo[1]).to be_a_kind_of(OctocatalogDiff::API::V1::Override)
       expect(tfo[1].key).to eq('baz')
       expect(tfo[1].value).to eq('buzz')
     end