field_mapper 0.1.0

data/lib/field_mapper/types/boolean.rb

@@ -0,0 +1,15 @@
+module FieldMapper
+  module Types
+
+    class Boolean
+
+      def self.parse(value)
+        return false if value.nil?
+        return false if value.blank? || value.to_s =~ /\A(0|f(alse)?|no?)\z/i
+        true
+      end
+
+    end
+
+  end
+end

data/lib/field_mapper/types/list.rb

@@ -0,0 +1,58 @@
+require_relative "../standard/plat"
+require_relative "../marshaller"
+
+module FieldMapper
+  module Types
+
+    class List
+      extend Forwardable
+
+      ALLOWED_TYPES = [
+        String,
+        Integer,
+        Float,
+        FieldMapper::Standard::Plat
+      ]
+
+      attr_reader :type
+
+      class << self
+
+        def [](type)
+          List.new(type)
+        end
+
+      end
+
+      def initialize(type, values=[])
+        raise InvalidListType unless valid_type?(type)
+        @type = type
+      end
+
+      def name
+        self.class.name
+      end
+
+      def plat_list?
+        type.ancestors.include?(FieldMapper::Standard::Plat)
+      end
+
+      def valid?(list)
+        return true if list.empty?
+        types = list.map{ |v| v.class }.uniq
+        return false if types.length > 1
+        types.first.ancestors.include? type
+      end
+
+      private
+
+      def valid_type?(type)
+        return false if type.class != Class
+        !(type.ancestors & ALLOWED_TYPES).empty?
+      end
+
+    end
+
+  end
+end
+

data/lib/field_mapper/types/plat.rb

@@ -0,0 +1,35 @@
+require_relative "../standard/plat"
+
+module FieldMapper
+  module Types
+
+    class Plat
+      extend Forwardable
+
+      attr_reader :type
+
+      class << self
+
+        def [](type)
+          Plat.new(type)
+        end
+
+      end
+
+      def initialize(type, values=[])
+        if type.class != Class || !type.ancestors.include?(FieldMapper::Standard::Plat)
+          raise InvalidPlatType
+        end
+
+        @type = type
+      end
+
+      def name
+        self.class.name
+      end
+
+    end
+
+  end
+end
+

data/lib/field_mapper/version.rb

@@ -0,0 +1,3 @@
+module FieldMapper
+  VERSION = "0.1.0"
+end

data/test/custom/converter_test.rb

@@ -0,0 +1,123 @@
+require_relative "../test_helper"
+require_relative "plat_example"
+require_relative "plat_example_alt"
+
+module Custom
+  class ConverterTest < MicroTest::Test
+
+    before do
+      @custom = Custom::PlatExample.new
+      @converter = FieldMapper::Custom::Converter.new(@custom)
+    end
+
+    test "convert_to_standard (basic)" do
+      @custom.name = "foobar"
+      standard = @converter.convert_to_standard
+      assert standard.name == "foobar"
+    end
+
+    test "convert_to_standard (find strategy)" do
+      @custom.rating = "C"
+      standard = @converter.convert_to_standard
+      assert standard.score == 3
+    end
+
+    test "convert_to_standard (compute strategy)" do
+      @custom.name = "Nathan"
+      @custom.desc = "This is a test."
+      standard = @converter.convert_to_standard
+      assert standard.desc == "Nathan says, 'This is a test.'"
+    end
+
+    test "convert_to_standard (compute strategy with values)" do
+      @custom.name = "Nathan"
+      @custom.color = "red"
+      standard = @converter.convert_to_standard
+      assert standard.color == "blue"
+    end
+
+    test "convert_to_standard (compute strategy with values alt)" do
+      @custom.color = "red"
+      standard = @converter.convert_to_standard
+      assert standard.color == "orangered"
+    end
+
+    test "convert_to_standard (custom has values but standard does not)" do
+      custom = Custom::PlatExampleAlt.new
+      converter = FieldMapper::Custom::Converter.new(custom)
+      custom.gender = "Male"
+      standard = converter.convert_to_standard
+      assert standard.desc == "Male"
+    end
+
+    test "convert_to_standard (standard has values but custom does not MATCH)" do
+      custom = Custom::PlatExampleAlt.new
+      converter = FieldMapper::Custom::Converter.new(custom)
+      custom.day = "Tuesday"
+      standard = converter.convert_to_standard
+      assert standard.day == "Tuesday"
+    end
+
+    test "convert_to_standard (standard has values but custom does not NO MATCH)" do
+      custom = Custom::PlatExampleAlt.new
+      converter = FieldMapper::Custom::Converter.new(custom)
+      custom.day = "Bunk"
+      standard = converter.convert_to_standard
+      assert standard.day.nil?
+    end
+
+    test "convert_to" do
+      @custom.name = "foo"
+      @custom.rating = "C"
+      @custom.color = "green"
+      custom = @converter.convert_to(Custom::PlatExampleAlt)
+      assert custom.name == "foo"
+      assert custom.fonzie == "AAA"
+      assert custom.rbg == "G"
+    end
+
+    test "convert_to (loaded values)" do
+      @custom.color = "realblue"
+      custom = @converter.convert_to(Custom::PlatExampleAlt)
+      assert custom.colour == "blue"
+    end
+
+    test "convert_to_standard (with PlatList values)" do
+      a = Custom::PlatExample.new(name: "a", rating: "A")
+      b = Custom::PlatExample.new(name: "b", rating: "B")
+      @custom.child_plats = [a, b]
+      converter = FieldMapper::Custom::Converter.new(@custom)
+      standard = converter.convert_to_standard
+
+      assert standard.children.first.name == "a"
+      assert standard.children.first.score == 1
+      standard_a = FieldMapper::Custom::Converter.new(a).convert_to_standard
+      assert standard.children.first.to_hash.merge(_node_id: nil) == standard_a.to_hash.merge(_node_id: nil)
+
+      assert standard.children.last.name == "b"
+      assert standard.children.last.score == 2
+      standard_b = FieldMapper::Custom::Converter.new(b).convert_to_standard
+      assert standard.children.last.to_hash.merge(_node_id: nil) == standard_b.to_hash.merge(_node_id: nil)
+    end
+
+    test "convert_to_standard (with PlatList value)" do
+      parent = Custom::PlatExample.new(name: "parent", rating: "A")
+      @custom.parent_plat = parent
+      converter = FieldMapper::Custom::Converter.new(@custom)
+      standard = converter.convert_to_standard
+
+      assert standard.parent.name == "parent"
+      assert standard.parent.score == 1
+      standard_parent = FieldMapper::Custom::Converter.new(parent).convert_to_standard
+      assert standard.parent.to_hash.merge(_node_id: nil) == standard_parent.to_hash.merge(_node_id: nil)
+    end
+
+    test "convert_to (multiple selected list values)" do
+      @custom.characters = ["X", "Z"]
+      converter = FieldMapper::Custom::Converter.new(@custom)
+      standard = converter.convert_to_standard
+      assert standard.letters = ["a", "c"]
+    end
+
+  end
+end

data/test/custom/field_test.rb

@@ -0,0 +1,137 @@
+require_relative "../test_helper"
+
+module Custom
+  class FieldTest < MicroTest::Test
+
+    test "constructor requires type" do
+      begin
+        FieldMapper::Custom::Field.new(:foo)
+      rescue TypeNotSpecified => e
+        error = e
+      end
+      assert error.present?
+    end
+
+    test "constructor sets standard field" do
+      standard_field = FieldMapper::Standard::Field.new(:foo, type: String)
+      custom_field = FieldMapper::Custom::Field.new(:bar, standard_field: standard_field)
+      assert custom_field.standard_field == standard_field
+    end
+
+    test "constructor sets default flippers" do
+      standard_field = FieldMapper::Standard::Field.new(:foo, type: String)
+      custom_field = FieldMapper::Custom::Field.new(:bar, standard_field: standard_field)
+      assert custom_field.respond_to?(:custom_to_standard)
+      assert custom_field.respond_to?(:standard_to_custom)
+    end
+
+    test "inherits standard_field's type" do
+      standard_field = FieldMapper::Standard::Field.new(:foo, type: FieldMapper::Types::Boolean)
+      custom_field = FieldMapper::Custom::Field.new(:bar, standard_field: standard_field)
+      assert custom_field.type == FieldMapper::Types::Boolean
+    end
+
+    test "custom_to_standard (default)" do
+      standard_field = FieldMapper::Standard::Field.new(:foo, type: String)
+      custom_field = FieldMapper::Custom::Field.new(:bar, standard_field: standard_field)
+      assert custom_field.custom_to_standard.call("foobar") == "foobar"
+    end
+
+    test "custom_to_standard (override)" do
+      standard_field = FieldMapper::Standard::Field.new(:foo, type: String)
+      custom_field = FieldMapper::Custom::Field.new(
+        :bar,
+        standard_field: standard_field,
+        custom_to_standard: -> (value, params: {}) { "override" }
+      )
+      assert custom_field.custom_to_standard.call("foobar") == "override"
+    end
+
+    test "standard_to_custom (default)" do
+      standard_field = FieldMapper::Standard::Field.new(:foo, type: String)
+      custom_field = FieldMapper::Custom::Field.new(:bar, standard_field: standard_field)
+      assert custom_field.standard_to_custom.call("foobar") == "foobar"
+    end
+
+    test "standard_to_custom (override)" do
+      standard_field = FieldMapper::Standard::Field.new(:foo, type: String)
+      custom_field = FieldMapper::Custom::Field.new(
+        :bar,
+        standard_field: standard_field,
+        standard_to_custom: -> (value, **) { "override" }
+      )
+      assert custom_field.standard_to_custom.call("foobar") == "override"
+    end
+
+    test "add value" do
+      standard_field = FieldMapper::Standard::Field.new(:foo, type: String)
+      standard_field.value("a")
+      custom_field = FieldMapper::Custom::Field.new(:bar, standard_field: standard_field)
+      custom_field.value("A", standard: "a")
+      assert custom_field.values.first.value == "A"
+      assert custom_field.values.first.standard_value.value == "a"
+    end
+
+    test "add value with priority" do
+      standard_field = FieldMapper::Standard::Field.new(:foo, type: String)
+      standard_field.value("a")
+      custom_field = FieldMapper::Custom::Field.new(:bar, standard_field: standard_field)
+      custom_field.value("A", standard: "a", priority: true)
+      assert custom_field.values.first.priority
+    end
+
+    test "find_values_mapped_to_standard" do
+      standard_field = FieldMapper::Standard::Field.new(:foo, type: String)
+      standard_field.value("a")
+      standard_field.value("b")
+      custom_field = FieldMapper::Custom::Field.new(:bar, standard_field: standard_field)
+      custom_field.value("A", standard: "a")
+      custom_field.value("B", standard: "b")
+      assert custom_field.find_values_mapped_to_standard(standard_field.values.first).include?(custom_field.values.first)
+      assert custom_field.find_values_mapped_to_standard("a").include?(custom_field.values.first)
+      assert custom_field.find_values_mapped_to_standard(standard_field.values.last).include?(custom_field.values.last)
+      assert custom_field.find_values_mapped_to_standard("b").include?(custom_field.values.last)
+    end
+
+    test "find_priority_value_mapped_to_standard" do
+      standard_field = FieldMapper::Standard::Field.new(:foo, type: String)
+      standard_field.value("a")
+      standard_field.value("b")
+      custom_field = FieldMapper::Custom::Field.new(:bar, standard_field: standard_field)
+      custom_field.value("A", standard: "a")
+      custom_field.value("AA", standard: "a", priority: true)
+      custom_field.value("B", standard: "b")
+      assert custom_field.find_priority_value_mapped_to_standard("a") == custom_field.values[1]
+    end
+
+    test "flip_strategy (default is :compute)" do
+      standard_field = FieldMapper::Standard::Field.new(:foo, type: String)
+      custom_field = FieldMapper::Custom::Field.new(:bar, standard_field: standard_field)
+      assert custom_field.flip_strategy(:custom_to_standard) == :compute
+      assert custom_field.flip_strategy(:standard_to_custom) == :compute
+    end
+
+    test "flip_strategy (default with allowed values is :find)" do
+      standard_field = FieldMapper::Standard::Field.new(:foo, type: String)
+      standard_field.value("a")
+      custom_field = FieldMapper::Custom::Field.new(:bar, standard_field: standard_field)
+      custom_field.value("A", standard: "a")
+      assert custom_field.flip_strategy(:custom_to_standard) == :find
+      assert custom_field.flip_strategy(:standard_to_custom) == :find
+    end
+
+    test "flip_strategy (with allowed values and flipper overrides is :compute)" do
+      standard_field = FieldMapper::Standard::Field.new(:foo, type: String)
+      standard_field.value("a")
+      custom_field = FieldMapper::Custom::Field.new(
+        :bar,
+        standard_field: standard_field,
+        custom_to_standard: -> (value, params: {}) { "override" },
+        standard_to_custom: -> (value, params: {}) { "override" },
+      )
+      custom_field.value("A", standard: "a")
+      assert custom_field.flip_strategy(:custom_to_standard) == :compute
+      assert custom_field.flip_strategy(:standard_to_custom) == :compute
+    end
+  end
+end

data/test/custom/plat_example.rb

@@ -0,0 +1,58 @@
+require_relative "../test_helper"
+require_relative "../standard/plat_example"
+
+module Custom
+  class PlatExample < FieldMapper::Custom::Plat
+    set_standard Standard::PlatExample
+
+    field :name, standard: :name
+    field :desc, standard: :desc,
+      custom_to_standard: -> (value, standard_instance: nil) {
+        "#{name} says, '#{value}'"
+      },
+      standard_to_custom: -> (value, standard_instance: nil) {
+        "'#{value}' --#{name}"
+      }
+
+    field :rating, type: String, standard: :score do
+      value "A", standard: 1
+      value "B", standard: 2
+      value "C", standard: 3
+    end
+
+    field :color, standard: :color,
+      # NOTE: as a best practice, do not define flippers on fields with allowed values
+      #       only doing it here for testing purposes
+      custom_to_standard: -> (value, standard_instance: nil) {
+        return "blue" if name == "Nathan"
+        case value
+        when "blue" then "aliceblue"
+        when "realblue" then "blue"
+        when "green" then "lawngreen"
+        when "red" then "orangered"
+        end
+      } do
+      value "blue", standard: "aliceblue"
+      value "realblue", standard: "blue"
+      value "green", standard: "lawngreen"
+      value "red", standard: "orangered"
+    end
+
+    field :painter, standard: :artist do
+      value "Leonardo",     standard: "Leonardo Da Vinci", priority: true
+      value "Leo",          standard: "Leonardo Da Vinci"
+      value "Michelangelo", standard: "Michelangelo Buonarroti"
+      value "Raphael",      standard: "Raphael Sanzio"
+    end
+
+    field :characters, standard: :letters do
+      value "X", standard: "a"
+      value "Y", standard: "b"
+      value "Z", standard: "c"
+    end
+
+    field :parent_plat, type: FieldMapper::Types::Plat[Custom::PlatExample], standard: :parent
+    field :child_plats, type: FieldMapper::Types::List[Custom::PlatExample], standard: :children, default: []
+
+  end
+end

data/test/custom/plat_example_alt.rb

@@ -0,0 +1,34 @@
+require_relative "../test_helper"
+require_relative "../standard/plat_example"
+
+module Custom
+  class PlatExampleAlt < FieldMapper::Custom::Plat
+    set_standard Standard::PlatExample
+
+    field :name, standard: :name
+
+    field :gender, standard: :desc do
+      value "Male"
+      value "Female"
+    end
+
+    field :day, standard: :day
+
+    field :fonzie, type: String, standard: :score do
+      value "A", standard: 1
+      value "AA", standard: 2
+      value "AAA", standard: 3
+    end
+
+    field :rbg, standard: :color do
+      value "R", standard: "orangered"
+      value "G", standard: "lawngreen"
+      value "B", standard: "aliceblue"
+    end
+
+    field :colour, standard: :color do
+      load_values File.expand_path("../assets/colors.csv", __FILE__)
+    end
+
+  end
+end