field_mapper 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3c5deabe6cc8ef7c58243cb797ebea59ad4affcb
+  data.tar.gz: 536688f17cc3afd08428f772cd49ecbdabd06dab
+SHA512:
+  metadata.gz: 9e1599b63efea5c5e21366ddcb9797f00eee43118305e6bddb44cf93720abec31bf805780c0ce76a3ddd34f64f5a04a1f0148d9a462b7c17e19ad56409bfe210
+  data.tar.gz: 7ee6d66aa959a5e5e084820b0e64e2e28c23b8c30198e053f4b10b926c93aa7a45dfdfa627ee0d7c357b67ca3ffae20b1aad3d6cd61d75c8e59f0f93e352d8a9

data/lib/field_mapper.rb

@@ -0,0 +1,18 @@
+require "active_support/all"
+require "american_date"
+require "money"
+require "monetize"
+require_relative "field_mapper/version"
+require_relative "field_mapper/types/boolean"
+require_relative "field_mapper/types/plat"
+require_relative "field_mapper/types/list"
+require_relative "field_mapper/standard/plat"
+require_relative "field_mapper/custom/plat"
+require_relative "field_mapper/standard/converter"
+require_relative "field_mapper/custom/converter"
+
+module FieldMapper
+  class << self
+    attr_accessor :logger
+  end
+end

data/lib/field_mapper/custom/converter.rb

@@ -0,0 +1,118 @@
+module FieldMapper
+  module Custom
+    class Converter
+
+      attr_reader(
+        :custom_plat,
+        :standard_plat,
+        :custom_instance
+      )
+
+      def initialize(custom_instance)
+        @custom_plat = custom_instance.class
+        @custom_instance = custom_instance
+        @standard_plat = custom_plat.standard_plat
+      end
+
+      def convert_to_standard
+        standard_instance = standard_plat.new
+
+        custom_plat.fields.each do |custom_field_name, custom_field|
+          if custom_field.standard_field.present?
+            raw_standard_value = get_raw_standard_value(
+              custom_field,
+              custom_instance[custom_field_name],
+              standard_instance
+            )
+            raw_standard_value = custom_field.standard_field.cast(raw_standard_value)
+            standard_instance[custom_field.standard_field.name] = raw_standard_value
+          end
+        end
+
+        [custom_instance, standard_instance].each do |instance|
+          instance.send(:after_convert, from: custom_instance, to: standard_instance)
+        end
+
+        standard_instance
+      end
+
+      def convert_to(custom_plat)
+        converter = FieldMapper::Standard::Converter.new(convert_to_standard)
+        converter.convert_to(custom_plat)
+      end
+
+      protected
+
+      def get_raw_standard_value(custom_field, raw_custom_value, standard_instance)
+        return nil if raw_custom_value.nil?
+
+        strategy = custom_field.flip_strategy(:custom_to_standard)
+        custom_flipper = custom_field.custom_flipper?(:custom_to_standard)
+
+        if !custom_flipper
+          if custom_field.plat?
+            return compute_raw_standard_value_for_plat(custom_field, raw_custom_value)
+          end
+
+          if custom_field.plat_list?
+            if custom_field.plat_list?
+              return compute_raw_standard_value_for_plat_list(custom_field, raw_custom_value)
+            end
+          end
+        end
+
+        if strategy == :find
+          if custom_field.type.is_a?(FieldMapper::Types::List)
+            return raw_custom_value.map do |single_raw_custom_value|
+              find_raw_standard_value(custom_field, single_raw_custom_value)
+            end
+          else
+            return find_raw_standard_value(custom_field, raw_custom_value)
+          end
+        end
+
+        compute_raw_standard_value(custom_field, raw_custom_value, standard_instance)
+      end
+
+      def find_raw_standard_value(custom_field, raw_custom_value)
+        return raw_custom_value unless custom_field.standard_field.has_values?
+
+        if custom_field.has_values?
+          custom_value = custom_field.find_value(raw_custom_value)
+          if custom_value.present?
+            custom_value.standard_value.value if custom_value.standard_value.present?
+          end
+        else
+          standard_value = custom_field.standard_field.find_value(raw_custom_value)
+          standard_value.value if standard_value.present?
+        end
+      end
+
+      def compute_raw_standard_value(custom_field, raw_custom_value, standard_instance)
+        raw_standard_value = custom_instance.instance_exec(
+          raw_custom_value,
+          standard_instance: standard_instance,
+          &custom_field.custom_to_standard
+        )
+
+        if !raw_standard_value.nil?
+          raw_standard_value = custom_field.standard_field.cast(raw_standard_value)
+        end
+
+        raw_standard_value
+      end
+
+      def compute_raw_standard_value_for_plat_list(custom_field, raw_custom_values)
+        raw_custom_values.map do |raw_custom_value|
+          compute_raw_standard_value_for_plat(custom_field, raw_custom_value)
+        end
+      end
+
+      def compute_raw_standard_value_for_plat(custom_field, raw_custom_value)
+        converter = FieldMapper::Custom::Converter.new(raw_custom_value)
+        converter.convert_to_standard
+      end
+
+    end
+  end
+end

data/lib/field_mapper/custom/field.rb

@@ -0,0 +1,110 @@
+require_relative "../standard/field"
+require_relative "value"
+
+module FieldMapper
+  module Custom
+    class Field < FieldMapper::Standard::Field
+
+      DefaultFlipper = -> (value, standard_instance: nil) { value }
+
+      attr_reader(
+        :name,
+        :type,
+        :desc,
+        :default,
+        :values,
+        :standard_field,
+        :custom_to_standard,
+        :standard_to_custom
+      )
+
+      def initialize(
+        name,
+        type: nil,
+        desc: nil,
+        default: nil,
+        standard_field: nil,
+        custom_to_standard: DefaultFlipper,
+        standard_to_custom: DefaultFlipper,
+        &block
+      )
+        type ||= standard_field.type unless standard_field.nil?
+        super name, type: type, desc: desc, default: default
+
+        @standard_field = standard_field
+        @custom_to_standard = custom_to_standard
+        @standard_to_custom = standard_to_custom
+
+        eigen = class << self; self; end
+        eigen.instance_eval do
+          define_method :custom_to_standard1, &custom_to_standard
+          define_method :standard_to_custom2, &standard_to_custom
+        end
+      end
+
+      def value(value, standard: nil, priority: nil)
+        @values ||= []
+        @values << FieldMapper::Custom::Value.new(
+          value,
+          field: self,
+          standard_value: standard,
+          priority: priority
+        )
+        @values.last
+      end
+
+      # Adds values to a Field instance that are defined in a CSV file.
+      #
+      # Intended use is from within a Plat class declaration.
+      # @example
+      #   class ExamplePlat < FieldMapper::Standard::Plat
+      #     field :example do
+      #       load_values "/path/to/file.csv"
+      #     end
+      #   end
+      #
+      # The format of the CSV file should contain a two columns with a header row.
+      # NOTE: An optional priority column can also be included.
+      # @example
+      #   custom_value,standard_value,priority
+      #   "A",1,
+      #   "B",2,true
+      #   "C",2,
+      #
+      def load_values(path_to_csv)
+        CSV.foreach(path_to_csv, :headers => true) do |row|
+          value(
+            row["custom_value"],
+            standard: row["standard_value"],
+            priority: FieldMapper::Types::Boolean.parse(row["priority"])
+          )
+        end
+      end
+
+      def find_values_mapped_to_standard(standard_value)
+        values.select do |val|
+          val.standard_value == standard_value ||
+            val.standard_value.value == standard_value
+        end
+      end
+
+      def find_priority_value_mapped_to_standard(standard_value)
+        matches = find_values_mapped_to_standard(standard_value)
+        match = matches.find { |val| val.priority }
+        match ||= matches.first
+      end
+
+      def flip_strategy(direction)
+        return :compute if custom_flipper?(direction)
+        return :find if has_values?
+        return :find if standard_field.present? && standard_field.has_values?
+        :compute
+      end
+
+      def custom_flipper?(direction)
+        instance_variable_get("@#{direction}") != DefaultFlipper
+      end
+
+    end
+  end
+end

data/lib/field_mapper/custom/plat.rb

@@ -0,0 +1,60 @@
+require_relative "../standard/plat"
+require_relative "../errors"
+require_relative "../name_helper"
+require_relative "field"
+
+module FieldMapper
+  module Custom
+    class Plat < FieldMapper::Standard::Plat
+
+      class << self
+        attr_reader :standard_plat
+
+        def set_standard(standard_plat)
+          @standard_plat = standard_plat
+        end
+
+        def field(
+          name,
+          type: nil,
+          desc: nil,
+          default: nil,
+          standard: nil,
+          custom_to_standard: FieldMapper::Custom::Field::DefaultFlipper,
+          standard_to_custom: FieldMapper::Custom::Field::DefaultFlipper,
+          &block
+        )
+          field_names[attr_name(name)] = name
+
+          field = fields[name] = FieldMapper::Custom::Field.new(
+            name,
+            type: type,
+            desc: desc,
+            default: default,
+            standard_field: standard_plat.fields[standard],
+            custom_to_standard: custom_to_standard,
+            standard_to_custom: standard_to_custom
+          )
+
+          field.instance_exec(&block) if block_given?
+
+          define_method(attr_name name) do
+            self[name]
+          end
+
+          define_method("#{attr_name name}=") do |value|
+            self[name] = value
+          end
+
+          define_method("custom_to_standard_#{name}", &custom_to_standard)
+          define_method("standard_to_custom_#{name}", &standard_to_custom)
+        end
+
+        def find_mapped_fields(standard_field)
+          fields.values.select { |field| field.standard_field == standard_field }
+        end
+      end
+
+    end
+  end
+end

data/lib/field_mapper/custom/value.rb

@@ -0,0 +1,41 @@
+require_relative "../errors"
+
+module FieldMapper
+  module Custom
+    class Value < FieldMapper::Standard::Value
+      attr_reader(
+        :value,
+        :field,
+        :priority,
+        :standard_value
+      )
+
+      def initialize(
+        value,
+        field: nil,
+        priority: nil,
+        standard_value: nil
+      )
+        super value, field: field
+
+        if !standard_value.nil?
+          if field.standard_field.nil?
+            message = "[#{field.name}] [#{value}] is mapped to a standard but [#{field.name}] is not"
+            raise StandardFieldNotFound.new(message)
+          end
+
+          raw_standard_value = standard_value
+          standard_value = field.standard_field.find_value(standard_value)
+
+          if standard_value.nil?
+            message = "[#{field.name}] [#{value}] is mapped, but the standard [#{field.standard_field.name}] doesn't define the value [#{raw_standard_value}]"
+            raise StandardValueNotFound.new(message)
+          end
+        end
+
+        @priority = priority
+        @standard_value = standard_value
+      end
+    end
+  end
+end

data/lib/field_mapper/errors.rb

@@ -0,0 +1,11 @@
+class StandardNotSet        < StandardError; end
+class StandardFieldNotFound < StandardError; end
+class StandardValueNotFound < StandardError; end
+class StandardMismatch      < StandardError; end
+class TypeNotSpecified      < StandardError; end
+class TypeNotSupported      < StandardError; end
+class FieldNotDefined       < StandardError; end
+class InvalidPlatType       < StandardError; end
+class InvalidListType       < StandardError; end
+class InvalidListValue      < StandardError; end
+class InvalidMarshal        < StandardError; end

data/lib/field_mapper/marshaller.rb

@@ -0,0 +1,24 @@
+require "oj"
+
+module FieldMapper
+  module Marshaller
+
+    OPTIONS = {
+      indent: 0,
+      circular: false,
+      class_cache: true,
+      escape: :json,
+      time: :unix,
+      create_id: "natefoo"
+    }
+
+    def marshal(value)
+      Oj.dump value, OPTIONS
+    end
+
+    def unmarshal(value)
+      Oj.load value, OPTIONS
+    end
+
+  end
+end

data/lib/field_mapper/name_helper.rb

@@ -0,0 +1,17 @@
+module FieldMapper
+  module NameHelper
+
+    def attr_name(value)
+      value = value.to_s
+      @attr_names ||= {}
+      @attr_names[value] ||= begin
+        value.
+          gsub(/\W/, "_").
+          gsub(/[A-Z][A-Z]+/) { |match| "_#{match.downcase}_" }.
+          gsub(/[A-Z]/) { |match| "_#{match.downcase}" }.
+          gsub(/\A_|_\z/, "")
+      end
+    end
+
+  end
+end

data/lib/field_mapper/standard/converter.rb

@@ -0,0 +1,111 @@
+module FieldMapper
+  module Standard
+    class Converter
+
+      attr_reader :standard_plat, :standard_instance
+
+      def initialize(standard_instance)
+        @standard_plat = standard_instance.class
+        @standard_instance = standard_instance
+      end
+
+      def convert_to(custom_plat)
+        raise StandardMismatch if custom_plat.standard_plat != standard_plat
+
+        custom_instance = custom_plat.new
+
+        standard_plat.fields.each do |standard_field_name, standard_field|
+          custom_fields = custom_plat.find_mapped_fields(standard_field)
+          custom_fields.each do |custom_field|
+            raw_custom_value = get_raw_custom_value(
+              custom_field,
+              standard_instance[standard_field_name],
+              custom_instance
+            )
+            raw_custom_value = custom_field.cast(raw_custom_value)
+            custom_instance[custom_field.name] = raw_custom_value
+          end
+        end
+
+        [standard_instance, custom_instance].each do |instance|
+          instance.send(:after_convert, from: standard_instance, to: custom_instance)
+        end
+
+        custom_instance
+      end
+
+      protected
+
+      def get_raw_custom_value(custom_field, raw_standard_value, custom_instance)
+        return nil if raw_standard_value.nil?
+
+        strategy = custom_field.flip_strategy(:standard_to_custom)
+        custom_flipper = custom_field.custom_flipper?(:standard_to_custom)
+
+        if !custom_flipper
+          if custom_field.plat?
+            return compute_raw_custom_value_for_plat(custom_field, raw_standard_value)
+          end
+
+          if custom_field.plat_list?
+            if custom_field.plat_list?
+              return compute_raw_custom_value_for_plat_list(custom_field, raw_standard_value)
+            end
+          end
+        end
+
+        if strategy == :find
+          if custom_field.type.is_a?(FieldMapper::Types::List)
+            return raw_standard_value.map do |single_raw_standard_value|
+              find_raw_custom_value(custom_field, single_raw_standard_value)
+            end
+          else
+            return find_raw_custom_value(custom_field, raw_standard_value)
+          end
+        end
+
+        compute_raw_custom_value(custom_field, raw_standard_value, custom_instance)
+      end
+
+      def find_raw_custom_value(custom_field, raw_standard_value)
+        return raw_standard_value unless custom_field.has_values?
+
+        if !custom_field.standard_field.has_values?
+          custom_value = custom_field.find_value(raw_standard_value)
+          return nil if custom_value.nil?
+          return custom_value.value
+        end
+
+        custom_value = custom_field.find_priority_value_mapped_to_standard(raw_standard_value)
+        return nil if custom_value.nil?
+        custom_value.value
+      end
+
+      def compute_raw_custom_value(custom_field, raw_standard_value, custom_instance)
+        raw_custom_value = custom_instance.instance_exec(
+          raw_standard_value,
+          standard_instance: standard_instance,
+          &custom_field.standard_to_custom
+        )
+
+        if !raw_custom_value.nil?
+          raw_custom_value = custom_field.cast(raw_custom_value)
+        end
+        raw_custom_value
+      end
+
+      def compute_raw_custom_value_for_plat_list(custom_field, raw_standard_values)
+        raw_standard_values.map do |raw_standard_value|
+          compute_raw_custom_value_for_plat(custom_field, raw_standard_value)
+        end
+      end
+
+      def compute_raw_custom_value_for_plat(custom_field, raw_standard_value)
+        converter = FieldMapper::Standard::Converter.new(raw_standard_value)
+        converter.convert_to(custom_field.type.type)
+      end
+
+    end
+  end
+end
+