data_maps 0.1.0

data/lib/data_maps/converter/string.rb

@@ -0,0 +1,15 @@
+module DataMaps
+  module Converter
+    # Converts numeric values
+    #
+    # @since 0.0.1
+    class String < Base
+      # The execute method to convert the given data into string
+      #
+      # @param [mixed] data
+      def execute(data)
+        data.to_s
+      end
+    end
+  end
+end

data/lib/data_maps/errors/invalid_data.rb

@@ -0,0 +1,6 @@
+module DataMaps
+  module Errors
+    class InvalidDataError < StandardError
+    end
+  end
+end

data/lib/data_maps/executable.rb

@@ -0,0 +1,33 @@
+module DataMaps
+  # Base class for executables (converter, when, then)
+  #
+  # @since 0.0.1
+  # @abstract
+  # @attr_reader @option the given option
+  class Executable
+    attr_reader :option
+
+    # Initializer
+    #
+    # @param [mixed] option The given options
+    def initialize(option)
+      @option = option
+
+      self.after_initialize if self.respond_to? :after_initialize
+    end
+
+    # The execute method to apply checks or mutations on the given data
+    #
+    # @param [mixed] data
+    def execute(data)
+      raise NotImplementedError.new("Please implement the execute method for your #{self.class.name}")
+    end
+
+    # Helper method to check if all the executable in a collection are valid objects of self
+    #
+    # @param [Array] collection
+    def self.valid_collection?(collection)
+      collection.is_a?(Array) && collection.all?{ |w| w.is_a?(self) }
+    end
+  end
+end

data/lib/data_maps/filtered_value.rb

@@ -0,0 +1,16 @@
+module DataMaps
+  # A filtered value
+  #
+  # @since 0.0.1
+  # @attr_reader [mixed] value
+  class FilteredValue
+    attr_reader :value
+
+    # Initializer for FilteredValue
+    #
+    # @param [mixed] value The original value
+    def initialize(value)
+      @value = value
+    end
+  end
+end

data/lib/data_maps/mapper.rb

@@ -0,0 +1,25 @@
+module DataMaps
+  # The base mapper class which handles all mapping logic
+  #
+  # @since 0.0.1
+  # @attr [Mapping] mapping
+  class Mapper
+    # Attribute Accessors
+    attr_accessor :mapping
+
+    # Initializer for the Mapper class
+    #
+    # @param [Mapping] mapping the mapping which will used to map data
+    # @raise [ArgumentError] when mapping is not a correct mapping object
+    def initialize(mapping)
+      raise ArgumentError.new('The mapping should be a DataMaps::Mapping::Base') unless mapping.is_a? DataMaps::Mapping
+
+      @mapping = mapping
+    end
+
+    # Execute
+    def convert(data)
+      mapping.execute(data.stringify_keys)
+    end
+  end
+end

data/lib/data_maps/mapping.rb

@@ -0,0 +1,102 @@
+module DataMaps
+  # The mapping class which defines a mapping
+  #
+  # @since 0.0.1
+  # attr_reader [Hash] mapping the compiled mapping
+  # attr_reader [Hash] mapping_hash the mapping description
+  class Mapping
+    attr_reader :mapping, :mapping_hash
+
+    # Initializer for the Mapping class
+    #
+    # @param [Hash] mapping_hash
+    #
+    # @raise [ArgumentError] when the given mapping_hash is not a Hash
+    def initialize(mapping_hash = {})
+      raise ArgumentError.new('The mapping_hash must be a Hash') unless mapping_hash.is_a? Hash
+
+      @mapping = {}
+      @mapping_hash = mapping_hash.with_indifferent_access
+    end
+
+    # Compile the mapping statements, this will lazily called on first use
+    #
+    def compile
+      unless @_compiled
+        # iterate over the mapping_hash and initialize mapping for each key
+        mapping_hash.each do |destination, map|
+          @mapping[destination] = _create_statement(destination, map)
+        end
+
+        @_compiled = true
+      end
+    end
+
+    # Validate the mapping statements, this is a compiling without save the compiled mapping
+    def valid?
+      true if validate rescue false
+    end
+
+    def validate
+      mapping_hash.each &method(:_create_statement)
+    end
+
+    # Getter to get the statement for a destination_field
+    #
+    # @param [String|Symbol] destination the field name to receive statement for
+    # @raise [KeyError] when the destination_field isn't present in map
+    def get_statement_for(destination)
+      compile
+
+      raise KeyError.new("The map has no statement for field: #{destination}") unless mapping.has_key?(destination)
+
+      mapping[destination]
+    end
+
+    # Allow iterations over all statements
+    #
+    # @param [Block] &block the block to execute for each map statement
+    # @return [Enumerator|self] return the enumerator if no block given or self
+    def each_statement
+      compile
+
+      return enum_for(:each_statement) unless block_given? # return Enumerator
+
+      mapping.each do |destination, statement|
+        yield destination, statement
+      end
+
+      self
+    end
+
+    # Execute mapping on the given data
+    #
+    # @param [Hash] data
+    # @return [Hash] the mapped data
+    def execute(data)
+      result = {}
+      each_statement do |destination, statement|
+        key, value = statement.execute(data)
+        result[key] = value unless value.is_a? DataMaps::FilteredValue
+      end
+
+      result
+    end
+
+    protected
+
+    # Create a mapping statement
+    #
+    # @protected
+    #
+    # @param [String] destination The destination field
+    # @param [String|Hash] mapping
+    #
+    # @return [Statement] executable statement
+    def _create_statement(destination, mapping)
+      mapping = { from: mapping } if mapping.is_a? String
+      mapping[:to] = destination
+      DataMaps::Statement.create_from_map(mapping)
+    end
+  end
+end

data/lib/data_maps/statement.rb

@@ -0,0 +1,80 @@
+module DataMaps
+  # A mapping statement
+  #
+  # @since 0.0.1
+  # @attr_reader [String] from the source data
+  # @attr_reader [String] to the destination data
+  # @attr_reader [Array] conditions a array of conditions
+  # @attr_reader [Array] converter a array of converter
+  class Statement
+    attr_reader :from, :to, :conditions, :converter
+
+    # Create statement from a mapping hash
+    #
+    # @param [Hash] mapping
+    #
+    # @return [Statement]
+    def self.create_from_map(mapping)
+      self.new(
+        mapping[:from],
+        mapping[:to],
+        DataMaps::Condition.create_from_map(mapping[:conditions] || []),
+        DataMaps::Converter.create_from_map(mapping[:converter] || {})
+      )
+    end
+
+    # The statement initializer
+    #
+    # @param [String] from
+    # @param [String] to
+    # @param [Array] conditions
+    # @param [Array] converter
+    def initialize(from, to, conditions, converter)
+      raise ArgumentError.new('Statement needs a source field') unless from.present?
+      raise ArgumentError.new('Conditions must be an array of DataMaps::Condition') unless conditions.is_a?(Array) && conditions.all?{ |c| c.is_a?(DataMaps::Condition) }
+      raise ArgumentError.new('Converter must be an array of DataMaps::Converter') unless DataMaps::Converter::Base.valid_collection?(converter)
+
+      @from = from
+      @to = to
+      @conditions = conditions
+      @converter = converter
+    end
+
+    # Execute the statement on the given data
+    #
+    # @param [mixed] data
+    # @return [Array] key and value of the result
+    def execute(data)
+      data = from.is_a?(Array) ? Hash[from.map{ |f| [f, data[f.to_s]] }] : data[from.to_s]
+
+      data = execute_conditions(data)
+      data = execute_converter(data)
+
+      [to, data]
+    end
+
+    # Execute conditions
+    #
+    # @param [mixed] data
+    # @return [mixed] mutated data
+    def execute_conditions(data)
+      conditions.each do |condition|
+        data = condition.execute(data)
+      end
+
+      data
+    end
+
+    # Execute converter
+    #
+    # @param [mixed] data
+    # @return [mixed] mutated data
+    def execute_converter(data)
+      converter.each do |converter|
+        data = converter.execute(data)
+      end
+
+      data
+    end
+  end
+end

data/lib/data_maps/then/base.rb

@@ -0,0 +1,12 @@
+module DataMaps
+  module Then
+    extend DataMaps::Concerns::Factory
+
+    # Base class for then's
+    #
+    # @since 0.0.1
+    # @abstract
+    class Base < DataMaps::Executable
+    end
+  end
+end

data/lib/data_maps/then/convert.rb

@@ -0,0 +1,25 @@
+module DataMaps
+  module Then
+    # A then to convert values
+    #
+    # @since 0.0.1
+    class Convert < Base
+      attr_reader :converter
+
+      def after_initialize
+        @converter = DataMaps::Converter.create_from_map(@option)
+      end
+
+      # The execute method which returns the converted data
+      #
+      # @param [mixed] data
+      def execute(data)
+        converter.each do |converter|
+          data = converter.execute(data)
+        end
+
+        data
+      end
+    end
+  end
+end

data/lib/data_maps/then/filter.rb

@@ -0,0 +1,16 @@
+module DataMaps
+  module Then
+    # A then to filter values
+    #
+    # @since 0.0.1
+    class Filter < Base
+      # Return the original data
+      #
+      # @param [mixed] data
+      # @return [mixed] data
+      def execute(data)
+        data
+      end
+    end
+  end
+end

data/lib/data_maps/then/set.rb

@@ -0,0 +1,15 @@
+module DataMaps
+  module Then
+    # A then to set a value
+    #
+    # @since 0.0.1
+    class Set < Base
+      # The execute method which returns the converted data
+      #
+      # @param [mixed] data
+      def execute(data)
+        option
+      end
+    end
+  end
+end

data/lib/data_maps/version.rb

@@ -0,0 +1,3 @@
+module DataMaps
+  VERSION = '0.1.0'
+end

data/lib/data_maps/when/base.rb

@@ -0,0 +1,12 @@
+module DataMaps
+  module When
+    extend DataMaps::Concerns::Factory
+
+    # Base class for when's
+    #
+    # @since 0.0.1
+    # @abstract
+    class Base < DataMaps::Executable
+    end
+  end
+end

data/lib/data_maps/when/comparison.rb

@@ -0,0 +1,99 @@
+module DataMaps
+  module When
+    # Condition to check for greater than
+    #
+    # @since 0.0.1
+    class Gt < Base
+      # Check if data is greater than the option
+      #
+      # @param [mixed] data
+      def execute(data)
+        data > option
+      end
+    end
+
+    # Condition to check for greater or equal than
+    #
+    # @since 0.0.1
+    class Gte < Base
+      # Check if data is greater or equal than the option
+      #
+      # @param [mixed] data
+      def execute(data)
+        data >= option
+      end
+    end
+
+    # Condition to check for lower than
+    #
+    # @since 0.0.1
+    class Lt < Base
+      # Check if data is greater than the option
+      #
+      # @param [mixed] data
+      def execute(data)
+        data < option
+      end
+    end
+
+    # Condition to check for lower or equal than
+    #
+    # @since 0.0.1
+    class Lte < Base
+      # Check if data is greater than the option
+      #
+      # @param [mixed] data
+      def execute(data)
+        data <= option
+      end
+    end
+
+    # Condition to check equality
+    #
+    # @since 0.0.1
+    class Eq < Base
+      # Check if data equals option
+      #
+      # @param [mixed] data
+      def execute(data)
+        data == option
+      end
+    end
+
+    # Condition to check no equality
+    #
+    # @since 0.0.1
+    class Neq < Base
+      # Check if data not equals option
+      #
+      # @param [mixed] data
+      def execute(data)
+        data != option
+      end
+    end
+
+    # Condition to check is in
+    #
+    # @since 0.0.1
+    class In < Base
+      # Check if data is part of option
+      #
+      # @param [mixed] data
+      def execute(data)
+        option.include?(data)
+      end
+    end
+
+    # Condition to check is not in
+    #
+    # @since 0.0.1
+    class Nin < Base
+      # Check if data is not part of option
+      #
+      # @param [mixed] data
+      def execute(data)
+        !option.include?(data)
+      end
+    end
+  end
+end

data/lib/data_maps/when/empty.rb

@@ -0,0 +1,15 @@
+module DataMaps
+  module When
+    # Condition to check for empty data
+    #
+    # @since 0.0.1
+    class Empty < Base
+      # Check if data is empty? and return true if this equals the option
+      #
+      # @param [mixed] data
+      def execute(data)
+        data.empty? == option
+      end
+    end
+  end
+end

data/lib/data_maps/when/regex.rb

@@ -0,0 +1,23 @@
+module DataMaps
+  module When
+    # Condition to check for an regular expression
+    #
+    # @since 0.0.1
+    # @attr_reader @regex the given regex
+    class Regex < Base
+      attr_reader :regex
+
+      # After initialize callback
+      def after_initialize
+        @regex = Regexp.new(option)
+      end
+
+      # The check method to evaluate condition on given data
+      #
+      # @param [mixed] data
+      def execute(data)
+        !!@regex.match(data)
+      end
+    end
+  end
+end

data/lib/data_maps.rb

@@ -0,0 +1,13 @@
+# Require gem stuff
+require 'active_support/all'
+
+# Require all project files
+Dir.glob(File.join(__dir__, 'data_maps', 'executable.rb'), &method(:require))
+Dir.glob(File.join(__dir__, 'data_maps', '{concerns,errors}', '*.rb'), &method(:require))
+Dir.glob(File.join(__dir__, 'data_maps', '{converter,then,when}', 'base.rb'), &method(:require))
+Dir.glob(File.join(__dir__, 'data_maps', '{converter,then,when}', '*.rb'), &method(:require))
+Dir.glob(File.join(__dir__, 'data_maps', '*.rb'), &method(:require))
+
+module DataMaps
+  # Nothing to do here :)
+end

data/spec/data_maps/concerns/factory_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe DataMaps::Concerns::Factory do
+
+  module MyModule
+    extend DataMaps::Concerns::Factory
+
+    class A
+      def initialize(option); end
+    end
+
+    class B
+      def initialize(option); end
+    end
+  end
+
+  it 'module respond_to factory class method' do
+    expect(MyModule).to respond_to :factory
+  end
+
+  describe '#factory' do
+    it 'raise error if constant doesn\'t exists in the module' do
+      expect{ MyModule.factory('c', nil) }.to raise_error ArgumentError
+    end
+
+    it 'returns instance of the given class' do
+      expect(MyModule.factory('a', nil)).to be_a MyModule::A
+    end
+
+    it 'works with symbols too' do
+      expect(MyModule.factory(:a, nil)).to be_a MyModule::A
+    end
+
+    it 'pass option to the new class' do
+      option = 1
+      expect(MyModule::A).to receive(:new).with(option)
+
+      MyModule.factory('A', option)
+    end
+  end
+
+  describe '#create_from_map' do
+    it 'raises an error if mapping isn\'t a hash' do
+      expect{ MyModule.create_from_map([]) }.to raise_error ArgumentError
+      expect{ MyModule.create_from_map('something') }.to raise_error ArgumentError
+    end
+
+    it 'calls the factory method' do
+      mapping = { a: :b }
+      expect(MyModule).to receive(:factory).with(:a, :b).and_call_original
+      MyModule.create_from_map(mapping)
+    end
+  end
+end

data/spec/data_maps/condition_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe DataMaps::Condition do
+  describe '::create_from_map' do
+    it 'creates a new Condition' do
+      mapping = [
+        { when: { empty: true }, then: { filter: true } }
+      ]
+
+      expect(DataMaps::When).to receive(:create_from_map).with(mapping.first[:when]).and_call_original
+      expect(DataMaps::Then).to receive(:create_from_map).with(mapping.first[:then]).and_call_original
+
+      expect(DataMaps::Condition).to receive(:new).with([DataMaps::When::Empty], [DataMaps::Then::Filter])
+
+      DataMaps::Condition.create_from_map(mapping)
+    end
+  end
+
+  describe 'arguments' do
+    it 'can\'t be initialized without whens' do
+      expect{ DataMaps::Condition.new(nil, []) }.to raise_error ArgumentError
+    end
+
+    it 'can\'t be initialized with wrong whens' do
+      expect{ DataMaps::Condition.new(['a', 5], []) }.to raise_error ArgumentError
+    end
+
+    it 'can\'t be initialized without thens' do
+      expect{ DataMaps::Condition.new([], nil) }.to raise_error ArgumentError
+    end
+
+    it 'can\'t be initialized with wrong thens' do
+      expect{ DataMaps::Condition.new([], ['b', 6]) }.to raise_error ArgumentError
+    end
+  end
+
+  describe '#can_break?' do
+    it 'returns false' do
+      condition = DataMaps::Condition.new([], [])
+      expect(condition.can_break?).to be_falsey
+    end
+
+    it 'returns true if there is a Then::Filter present' do
+      condition = DataMaps::Condition.new([], [DataMaps::Then::Filter.new(true)])
+      expect(condition.can_break?).to be_truthy
+    end
+  end
+
+  describe '#execute' do
+    let(:condition) { DataMaps::Condition.new([DataMaps::When::Base.new(nil)], [DataMaps::Then::Base.new(nil)]) }
+    let(:data) { double(Object) }
+
+    it 'returns original data when check is false' do
+      expect(condition).to receive(:check).with(data).and_return(false)
+      expect(condition.execute(data)).to be data
+    end
+
+    it 'returns modified data when check is true and can_break? is false' do
+      expect(condition).to receive(:check).with(data).and_return(true)
+      expect(condition).to receive(:can_break?).and_return(false)
+      expect(condition).to receive(:result).with(data).and_return('modified value')
+      expect(condition.execute(data)).to eq 'modified value'
+    end
+
+    it 'returns a FilteredValue when check is true and can_break? is true' do
+      expect(condition).to receive(:check).with(data).and_return(true)
+      expect(condition).to receive(:can_break?).and_return(true)
+      expect(condition.execute(data)).to be_a DataMaps::FilteredValue
+    end
+  end
+
+  describe '#check' do
+    let(:condition) { DataMaps::Condition.new([DataMaps::When::Base.new(nil), DataMaps::When::Base.new(nil)], []) }
+    let(:data) { double(Object) }
+
+    it 'returns true if all whens are true' do
+      expect(condition.whens[0]).to receive(:execute).with(data).and_return(true)
+      expect(condition.whens[1]).to receive(:execute).with(data).and_return(true)
+
+      expect(condition.check(data)).to be_truthy
+    end
+
+    it 'returns false if a when is false' do
+      expect(condition.whens[0]).to receive(:execute).with(data).and_return(true)
+      expect(condition.whens[1]).to receive(:execute).with(data).and_return(false)
+
+      expect(condition.check(data)).to be_falsey
+    end
+  end
+
+  describe '#result' do
+    let(:condition) { DataMaps::Condition.new([], [DataMaps::Then::Base.new(nil), DataMaps::Then::Base.new(nil)]) }
+    let(:data) { double(Object) }
+    let(:data2) { double(Object) }
+    let(:data3) { double(Object) }
+
+    it 'calls execute for each then with the mutated data' do
+      expect(condition.thens[0]).to receive(:execute).ordered.with(data).and_return(data2)
+      expect(condition.thens[1]).to receive(:execute).ordered.with(data2).and_return(data3)
+
+      expect(condition.result(data)).to be data3
+    end
+  end
+end