field_mapper 0.1.0

data/lib/field_mapper/standard/field.rb

@@ -0,0 +1,157 @@
+require "csv"
+require "oj"
+require_relative "value"
+
+module FieldMapper
+  module Standard
+    class Field
+      include FieldMapper::Marshaller
+
+      attr_reader(
+        :name,
+        :type,
+        :desc,
+        :default,
+        :values
+      )
+
+      def initialize(
+        name,
+        type: nil,
+        desc: nil,
+        default: nil
+      )
+        raise TypeNotSpecified.new("type not specified for: #{name}") if type.nil?
+        @name = name.to_sym
+        @type = type
+        @desc= desc
+        @default = default
+      end
+
+      def list?
+        type.name == "FieldMapper::Types::List"
+      end
+
+      def plat?
+        type.name == "FieldMapper::Types::Plat"
+      end
+
+      def plat_field?
+        plat? || plat_list?
+      end
+
+      def plat_list?
+        list? && type.plat_list?
+      end
+
+      def raw_values
+        return nil unless has_values?
+        values.map { |v| v.value }
+      end
+
+      # Adds a value to a Field instance.
+      # Intended use is from within a Plat class declaration.
+      #
+      # @example
+      #   class ExamplePlat < FieldMapper::Standard::Plat
+      #     field :example do
+      #       value 1
+      #     end
+      #   end
+      def value(val)
+        @values ||= []
+        @values << FieldMapper::Standard::Value.new(val, field: self)
+        @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 single column with a header row.
+      # @example
+      #   Name of Field
+      #   1
+      #   2
+      #
+      def load_values(path_to_csv)
+        CSV.foreach(path_to_csv, :headers => true) do |row|
+          value row["standard_value"].to_s.strip
+        end
+      end
+
+      def has_values?
+        !values.nil?
+      end
+
+      def find_value(value)
+        return nil unless has_values?
+        values.find { |val| val == value || val.value == value }
+      end
+
+      def cast(value, as_single_value: false)
+        value = cast_value(type, value, as_single_value: as_single_value)
+        return nil if value.nil? || value.to_s.blank?
+        value = clean_value(value) unless as_single_value
+        value
+      end
+
+      alias_method :to_s, :name
+
+      private
+
+      def cast_value(type, value, as_single_value: false)
+        return nil if value.nil?
+        case type.name
+        when "String"                       then return value.to_s.strip
+        when "FieldMapper::Types::Boolean"  then return FieldMapper::Types::Boolean.parse(value)
+        when "Time"                         then return Time.parse(value.to_s) rescue nil # TODO: log error?
+        when "Integer"                      then return value.to_i
+        when "Float"                        then return value.to_f
+        when "Money"                        then return Monetize.parse(value) rescue nil # TODO: log error?
+        when "FieldMapper::Types::Plat"     then return plat_instance(type, value)
+        when "FieldMapper::Types::List"     then
+          return value if value.is_a?(Array) && value.empty?
+          return plat_instance_list(type, value) if type.plat_list?
+          return cast_value(type.type, value) if as_single_value
+          get_list value
+        else
+          nil
+        end
+      end
+
+      def get_list(value)
+        value = unmarshal(value) if value.is_a?(String)
+        value.map { |val| cast_value(type.type, val) }
+      end
+
+      def clean_value(value)
+        return value unless has_values?
+        return value unless type.name == "FieldMapper::Types::List"
+        value & raw_values
+      end
+
+      def plat_instance(type, value)
+        return value if value.is_a?(FieldMapper::Standard::Plat)
+        return value if value.is_a?(Numeric)
+        return value.to_i if value.is_a?(String) && value =~ /\A\d+\z/
+        return type.type.new(value) if value.is_a?(Hash)
+        return type.type.new(unmarshal(value)) if value.is_a?(String)
+        nil
+      end
+
+      def plat_instance_list(type, value)
+        return value if value.empty?
+        value = unmarshal(value) if value.is_a?(String)
+        return value.map { |val| plat_instance(type, val) }
+      end
+
+    end
+  end
+end

data/lib/field_mapper/standard/plat.rb

@@ -0,0 +1,279 @@
+require "digest/md5"
+require_relative "../errors"
+require_relative "../name_helper"
+require_relative "../marshaller"
+require_relative "field"
+
+module FieldMapper
+  module Standard
+    class Plat
+      include FieldMapper::NameHelper
+      include FieldMapper::Marshaller
+
+      class << self
+        include FieldMapper::NameHelper
+
+        def fields
+          @fields ||= HashWithIndifferentAccess.new
+        end
+
+        def field_names
+          @field_names ||= {}
+        end
+
+        def field(
+          name,
+          type: nil,
+          desc: nil,
+          default: nil,
+          &block
+        )
+          field_names[attr_name(name)] = name
+
+          field = fields[name] = FieldMapper::Standard::Field.new(
+            name,
+            type: type,
+            desc: desc,
+            default: default
+          )
+
+          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
+        end
+
+        def find_field(field_name)
+          fields[field_names[attr_name(field_name)]]
+        end
+
+        def has_plat_fields?
+          !plat_fields.empty?
+        end
+
+        def plat_fields
+          fields.reduce({}) do |memo, keypair|
+            if keypair.last.plat_field?
+              memo[keypair.first] = keypair.last
+            end
+            memo
+          end
+        end
+
+      end
+
+      attr_reader :node_id
+
+      def initialize(params={})
+        @node_id = params["_node_id"]
+        assign_defaults
+        assign_params params
+      end
+
+      def scope
+        @scope ||= begin
+          scope_name = self.class.name.split("::")[0..-2].join("::")
+          if scope_name.empty?
+            ::Object
+          else
+            ::Object.const_get(scope_name)
+          end
+        end
+      end
+
+      def after_convert(from: nil, to: nil)
+        # abstract method to be implemented by subclasses
+      end
+
+      def [](field_name)
+        raise FieldNotDefined unless field_exists?(field_name)
+        instance_variable_get "@#{attr_name(field_name)}"
+      end
+
+      def []=(field_name, value)
+        field = self.class.find_field(field_name)
+        raise FieldNotDefined if field.nil?
+        instance_variable_set "@#{attr_name(field_name)}", field.cast(value)
+      end
+
+      def to_hash(flatten: false, history: {}, include_meta: true)
+        history[object_id] = true
+        hash = self.class.fields.values.reduce(HashWithIndifferentAccess.new) do |memo, field|
+          name = field.name
+          value = instance_variable_get("@#{attr_name(name)}")
+
+          if value.present?
+            case field.type.name
+            when "FieldMapper::Types::Plat" then
+              if value.is_a? FieldMapper::Standard::Plat
+                oid = value.object_id
+                if history[oid].nil?
+                  history[oid] = true
+                  value = value.to_hash(flatten: flatten, history: history, include_meta: include_meta)
+                  value = marshal(value) if flatten
+                else
+                  value = oid
+                end
+              else
+                value
+              end
+            when "FieldMapper::Types::List" then
+              if field.plat_list?
+                value = value.map do |val|
+                  if val.is_a? FieldMapper::Standard::Plat
+                    oid = val.object_id
+                    if history[oid].nil?
+                      history[oid] = true
+                      val.to_hash(flatten: flatten, history: history, include_meta: include_meta)
+                    else
+                      oid
+                    end
+                  else
+                    val
+                  end
+                end
+              end
+              value = marshal(value) if flatten
+            when "Money" then
+              value = value.format(with_currency: true)
+            when "Time" then
+              value = value.utc.iso8601
+            end
+          end
+
+          memo[name] = value
+          memo
+        end
+
+        if include_meta
+          hash = {
+            _node_id: object_id,
+            _flat: flatten
+          }.merge(hash)
+        end
+
+        HashWithIndifferentAccess.new(hash)
+      end
+
+      def cache_key
+        self.class.name + "-" + Digest::MD5.hexdigest(to_hash.to_s)
+      end
+
+      protected
+
+      def plat_values
+        self.class.plat_fields.values.reduce([]) do |memo, field|
+          value = send(attr_name(field.name))
+          memo << value if field.plat?
+          memo.concat value if field.plat_list? && !value.nil?
+          memo
+        end
+      end
+
+      def descendant_plats(history: {})
+        return {} if history[object_id]
+        history[object_id] = true
+        plats = {}
+        plats[self.node_id || self.object_id] = self
+
+        plat_values.each do |plat|
+          if plat.is_a? FieldMapper::Standard::Plat
+            plats[plat.node_id || plat.object_id] = plat
+            plats.merge! plat.descendant_plats(history: history)
+          end
+        end
+
+        plats
+      end
+
+      def pending_assignments
+        @pending_assignments ||= []
+      end
+
+      def all_pending_assignments
+        descendant_plats.values.reduce([]) do |memo, plat|
+          memo.concat plat.pending_assignments
+        end
+      end
+
+      def field_exists?(field_name)
+        !!self.class.field_names[attr_name(field_name)]
+      end
+
+      def assign_defaults
+        self.class.fields.each do |name, field|
+          if !field.default.nil?
+            value = field.default
+            value = value.clone rescue value
+            instance_variable_set "@#{attr_name(field.name)}", field.cast(value)
+          end
+        end
+      end
+
+      def assign_params(params)
+        pending_assignments.clear
+        params.each do |name, value|
+          field = self.class.fields[name]
+          next if field.nil?
+          value = field.cast(value)
+          next if value.nil?
+          next if field.list? && value.compact.empty?
+          assign_param name, value
+          add_pending_assignment field, value
+        end
+
+        apply_pending_assignments descendant_plats
+      end
+
+      def assign_param(name, value)
+        instance_variable_set "@#{attr_name(name)}", value
+      end
+
+      def add_pending_assignment(field, value)
+        if field.plat? && value.is_a?(Numeric)
+          add_pending_assignment_for_plat field, value
+        end
+
+        if field.plat_list? && !value.nil?
+          add_pending_assignment_for_plat_list field, value
+        end
+      end
+
+      def add_pending_assignment_for_plat(field, value)
+        pending_assignments << lambda do |descendant_plats|
+          if value.is_a?(Numeric)
+            plat = descendant_plats[value]
+            assign_param field.name, plat unless plat.nil?
+          end
+        end
+      end
+
+      def add_pending_assignment_for_plat_list(field, value)
+        pending_assignments << lambda do |descendant_plats|
+          list = value.reduce([]) do |memo, val|
+            if val.is_a?(Numeric)
+              plat = descendant_plats[val]
+              memo << (plat ? plat : val)
+            else
+              memo << val
+            end
+            memo
+          end
+          assign_param field.name, list
+        end
+      end
+
+      def apply_pending_assignments(descendant_plats)
+        all_pending_assignments.each do |assignment|
+          assignment.call descendant_plats
+        end
+      end
+
+    end
+  end
+end

data/lib/field_mapper/standard/value.rb

@@ -0,0 +1,24 @@
+require_relative "../errors"
+
+module FieldMapper
+  module Standard
+    class Value
+      attr_reader(
+        :value,
+        :field
+      )
+
+      def initialize(
+        value,
+        field: nil
+      )
+        raise ArgumentError.new("field is required") if
+          field.nil?
+
+        @field = field
+        @value = field.cast(value, as_single_value: true)
+      end
+    end
+
+  end
+end