field_mapper 0.1.0

data/test/custom/plat_test.rb

@@ -0,0 +1,102 @@
+require_relative "../test_helper"
+require_relative "plat_example"
+
+module Custom
+  class PlatTest < MicroTest::Test
+
+    before do
+      @class = Custom::PlatExample
+      @instance = Custom::PlatExample.new
+    end
+
+    test "set_standard" do
+      assert @class.standard_plat == Standard::PlatExample
+    end
+
+    test "field mapping" do
+      assert @class.find_field(:name).standard_field == @class.standard_plat.find_field(:name)
+    end
+
+    test "field mapping with value mappings" do
+      custom_field = @class.find_field(:color)
+      standard_field = @class.standard_plat.find_field(:color)
+      assert custom_field.standard_field == standard_field
+      assert custom_field.find_value("blue").standard_value == standard_field.find_value("aliceblue")
+      assert custom_field.find_value("green").standard_value == standard_field.find_value("lawngreen")
+      assert custom_field.find_value("red").standard_value == standard_field.find_value("orangered")
+    end
+
+    test "field mapping with value mappings (diff names)" do
+      custom_field = @class.find_field(:painter)
+      standard_field = @class.standard_plat.find_field(:artist)
+      assert custom_field.standard_field == standard_field
+      assert custom_field.find_value("Leonardo").standard_value == standard_field.find_value("Leonardo Da Vinci")
+    end
+
+    test "field mapping with value mappings (diff types)" do
+      custom_field = @class.find_field(:rating)
+      standard_field = @class.standard_plat.find_field(:score)
+      assert custom_field.standard_field == standard_field
+      assert custom_field.find_value("A").standard_value == standard_field.find_value(1)
+      assert custom_field.find_value("B").standard_value == standard_field.find_value(2)
+      assert custom_field.find_value("C").standard_value == standard_field.find_value(3)
+    end
+
+    test "find_mapped_fields" do
+      standard_field = @class.standard_plat.find_field(:artist)
+      custom_field = @class.find_field(:painter)
+      assert @class.find_mapped_fields(standard_field).include?(custom_field)
+    end
+
+    test "to_hash" do
+      @instance.parent_plat = Custom::PlatExample.new
+      @instance.child_plats << Custom::PlatExampleAlt.new
+      @instance.child_plats << Custom::PlatExampleAlt.new
+      assert @instance.to_hash == {
+        "_node_id"  => @instance.object_id,
+        "_flat"       => false,
+        "name"        => nil,
+        "desc"        => nil,
+        "rating"      => nil,
+        "color"       => nil,
+        "painter"     => nil,
+        "characters"  => nil,
+        "parent_plat" => {
+          "_node_id"  => @instance.parent_plat.object_id,
+          "_flat"       => false,
+          "name"        => nil,
+          "desc"        => nil,
+          "rating"      => nil,
+          "color"       => nil,
+          "painter"     => nil,
+          "characters"  => nil,
+          "parent_plat" => nil,
+          "child_plats" => []
+        },
+        "child_plats" => [
+          {
+            "_node_id" => @instance.child_plats.first.object_id,
+            "_flat"       => false,
+            "name"       => nil,
+            "gender"     => nil,
+            "day"        => nil,
+            "fonzie"     => nil,
+            "rbg"        => nil,
+            "colour"     => nil
+          },
+         {
+            "_node_id" => @instance.child_plats.last.object_id,
+            "_flat"       => false,
+            "name"       => nil,
+            "gender"     => nil,
+            "day"        => nil,
+            "fonzie"     => nil,
+            "rbg"        => nil,
+            "colour"     => nil
+          }
+        ]
+      }
+    end
+
+  end
+end

data/test/custom/value_test.rb

@@ -0,0 +1,43 @@
+require_relative "../test_helper"
+
+module Custom
+  class ValueTest < MicroTest::Test
+
+    before do
+      standard_field = FieldMapper::Standard::Field.new(:foo, type: String)
+      @custom_field = FieldMapper::Custom::Field.new(:bar, standard_field: standard_field)
+    end
+
+    test "constructor requires standar_field when standard_value is set" do
+      begin
+        custom_field = FieldMapper::Custom::Field.new(:bar, type: Integer)
+        FieldMapper::Custom::Value.new(1, field: custom_field, standard_value: 1)
+      rescue StandardFieldNotFound => e
+        error = e
+      end
+      assert error.present?
+    end
+
+    test "constructor ensures standard_value exists" do
+      begin
+        FieldMapper::Custom::Value.new("a", field: @custom_field, standard_value: "a")
+      rescue StandardValueNotFound => e
+        error = e
+      end
+      assert error.present?
+    end
+
+    test "constructor maps values" do
+      @custom_field.standard_field.value("a")
+      value = FieldMapper::Custom::Value.new("a", field: @custom_field, standard_value: "a")
+      assert value.value == value.standard_value.value
+    end
+
+    test "constructor sets priority" do
+      @custom_field.standard_field.value("a")
+      value = FieldMapper::Custom::Value.new("a", field: @custom_field, standard_value: "a", priority: true)
+      assert value.priority
+    end
+
+  end
+end

data/test/readme_test.rb

@@ -0,0 +1,119 @@
+require_relative "test_helper"
+
+class ReadmeTest < MicroTest::Test
+
+  test "readme examples" do
+
+    class StandardUser < FieldMapper::Standard::Plat
+      field :name,        type: String
+      field :screen_name, type: String
+      field :info,        type: String
+      field :website,     type: String
+
+      # field with allowed values
+      field :gender,      type: String do
+        value "F"
+        value "M"
+      end
+
+      field :age,         type: Integer
+
+      # field with a default value
+      field :net_worth,   type: Money, default: 0
+
+      # field that holds a list of plats
+      field :friends,     type: FieldMapper::Types::List[StandardUser], default: []
+    end
+
+    class FacebookUser < FieldMapper::Custom::Plat
+      # note that we set the standard
+      set_standard StandardUser
+
+      # fields are mapped to the standard
+      field :name,      standard: :name
+
+      # field with complex transformation rules
+      field :username,  standard: :screen_name,
+        custom_to_standard: -> (value, standard_instance: nil) {
+          # value passed is the custom value
+          # value returned is the standard value
+          "Facebook:#{value.to_s.strip}"
+        },
+        standard_to_custom: -> (value, standard_instance: nil) {
+          # value passed is the standard value
+          # value returned is the custom value
+          value.to_s.split(/:/).last
+        }
+
+      field :bio,       standard: :info
+      field :website,   standard: :website
+
+      # field with mapped values
+      field :gender,    standard: :gender do
+        value "female", standard: "F"
+        value "male",   standard: "M"
+      end
+
+      field :net_worth, standard: :net_worth
+      field :friends,   standard: :friends, type: FieldMapper::Types::List[FacebookUser], default: []
+
+      # not all custom fields are required to map to a standard
+      field :birthday,  type: Time
+    end
+
+    class TwitterUser < FieldMapper::Custom::Plat
+      set_standard StandardUser
+
+      field :name,            standard: :name
+      field :screen_name,     standard: :screen_name,
+        custom_to_standard: -> (value, standard_instance: nil) {
+          "Twitter:#{value.to_s.strip}"
+        },
+        standard_to_custom: -> (value, standard_instance: nil) {
+          value.to_s.split(/:/).last
+        }
+      field :description,     standard: :info
+      field :url,             standard: :website
+      field :followers_count, type: Integer
+
+      # callback method that runs after tranformation
+      def after_convert(from: nil, to: nil)
+        if from.respond_to? :friends
+          self.followers_count = from.friends.length
+        end
+      end
+    end
+
+    zuck = FacebookUser.new(
+      name: "Mark Zuckerberg",
+      username: "zuck",
+      bio: "Creator of Facebook",
+      website: "http://www.facebook.com/zuck",
+      gender: "male",
+      age: 29,
+      net_worth: "$29,000,000,000 USD", # value will be cast to a Money
+      birthday: "1984-05-14" # value will be cast to a Time
+    )
+
+    zuck.friends << FacebookUser.new(name: "Priscilla Chan")
+
+    converter = FieldMapper::Custom::Converter.new(zuck)
+    standard_zuck = converter.convert_to_standard
+
+    converter = FieldMapper::Custom::Converter.new(zuck)
+    twitter_zuck = converter.convert_to(TwitterUser)
+
+    converter = FieldMapper::Standard::Converter.new(standard_zuck)
+    zuck2 = converter.convert_to(FacebookUser)
+    twitter_zuck2 = converter.convert_to(TwitterUser)
+
+    zuck_hash = zuck.to_hash
+    zuck_flat_hash = zuck.to_hash(flatten: true)
+    zuck_from_hash = FacebookUser.new(zuck_hash)
+    zuck_from_flat_hash = FacebookUser.new(zuck_flat_hash)
+
+    # TODO: break tests up & add some asserts
+    #assert false
+  end
+
+end

data/test/standard/converter_test.rb

@@ -0,0 +1,88 @@
+require_relative "../test_helper"
+require_relative "plat_example"
+require_relative "../custom/plat_example"
+require_relative "../custom/plat_example_alt"
+
+module Standard
+  class ConverterTest < MicroTest::Test
+
+    before do
+      @standard = Standard::PlatExample.new
+      @converter = FieldMapper::Standard::Converter.new(@standard)
+    end
+
+    test "convert_to (basic)" do
+      @standard.name = "foobar"
+      custom = @converter.convert_to(Custom::PlatExample)
+      assert custom.name == "foobar"
+    end
+
+    test "convert_to (find strategy)" do
+      @standard.score = 3
+      custom = @converter.convert_to(Custom::PlatExample)
+      assert custom.rating == "C"
+    end
+
+    test "convert_to (compute strategy)" do
+      @standard.name = "Nathan"
+      @standard.desc = "This is a test."
+      custom = @converter.convert_to(Custom::PlatExample)
+      assert custom.desc == "'This is a test.' --Nathan"
+    end
+
+    test "convert_to (custom has values but standard does not MATCH)" do
+      @standard.desc = "Male"
+      custom = @converter.convert_to(Custom::PlatExampleAlt)
+      assert custom.gender == "Male"
+    end
+
+    test "convert_to (custom has values but standard does not NO MATCH)" do
+      @standard.desc = "Bunk"
+      custom = @converter.convert_to(Custom::PlatExampleAlt)
+      assert custom.gender.nil?
+    end
+
+    test "convert_to (standard has values but custom does not)" do
+      @standard.day = "Tuesday"
+      custom = @converter.convert_to(Custom::PlatExampleAlt)
+      assert custom.day == "Tuesday"
+    end
+
+    test "convert_to (multiple selected list values)" do
+      @standard.letters = ["a", "c"]
+      custom = @converter.convert_to(Custom::PlatExample)
+      assert custom.characters = ["X", "Z"]
+    end
+
+    test "convert_to (with PlatList values)" do
+      a = Standard::PlatExample.new(name: "a", score: 1)
+      b = Standard::PlatExample.new(name: "b", score: 2)
+      @standard.children = [a, b]
+      converter = FieldMapper::Standard::Converter.new(@standard)
+      custom = converter.convert_to(Custom::PlatExample)
+
+      assert custom.child_plats.first.name == "a"
+      assert custom.child_plats.first.rating == "A"
+      custom_a = FieldMapper::Standard::Converter.new(a).convert_to(Custom::PlatExample)
+      assert custom.child_plats.first.to_hash.merge(_node_id: nil) == custom_a.to_hash.merge(_node_id: nil)
+
+      assert custom.child_plats.last.name == "b"
+      assert custom.child_plats.last.rating == "B"
+      custom_b = FieldMapper::Standard::Converter.new(b).convert_to(Custom::PlatExample)
+      assert custom.child_plats.last.to_hash.merge(_node_id: nil) == custom_b.to_hash.merge(_node_id: nil)
+    end
+
+    test "convert_to (with PlatList value)" do
+      parent = Standard::PlatExample.new(name: "parent", score: 1)
+      @standard.parent = parent
+      converter = FieldMapper::Standard::Converter.new(@standard)
+      custom = converter.convert_to(Custom::PlatExample)
+
+      assert custom.parent_plat.name == "parent"
+      assert custom.parent_plat.rating == "A"
+      custom_parent = FieldMapper::Standard::Converter.new(parent).convert_to(Custom::PlatExample)
+      assert custom.parent_plat.to_hash.merge(_node_id: nil) == custom_parent.to_hash.merge(_node_id: nil)
+    end
+
+  end
+end

data/test/standard/field_test.rb

@@ -0,0 +1,156 @@
+require_relative "../test_helper"
+require_relative "plat_example"
+
+module Standard
+  class FieldTest < MicroTest::Test
+
+    test "constructor requires type" do
+      begin
+        FieldMapper::Standard::Field.new(:foo)
+      rescue TypeNotSpecified => e
+        error = e
+      end
+      assert error.present?
+    end
+
+    test "constructor sets name" do
+      field = FieldMapper::Standard::Field.new(:foo, type: String)
+      assert field.name == :foo
+    end
+
+    test "constructor sets type" do
+      field = FieldMapper::Standard::Field.new(:foo, type: String)
+      assert field.type == String
+    end
+
+    test "constructor sets desc" do
+      field = FieldMapper::Standard::Field.new(:foo, type: String, desc: "A description")
+      assert field.desc == "A description"
+    end
+
+    test "constructor sets default" do
+      field = FieldMapper::Standard::Field.new(:foo, type: String, default: "bar")
+      assert field.default == "bar"
+    end
+
+    test "add value" do
+      field = FieldMapper::Standard::Field.new(:foo, type: String)
+      field.value("bar")
+      assert field.values.first.value == "bar"
+    end
+
+    test "load values" do
+      field = FieldMapper::Standard::Field.new(:color, type: String)
+      field.load_values(File.expand_path("../assets/colors.csv", __FILE__))
+      assert field.has_values?
+      assert field.values.first.value == "aliceblue"
+      assert field.values.last.value == "yellowgreen"
+    end
+
+    test "has_values? (false)" do
+      field = FieldMapper::Standard::Field.new(:foo, type: String)
+      assert !field.has_values?
+    end
+
+    test "has_values? (true)" do
+      field = FieldMapper::Standard::Field.new(:foo, type: String)
+      field.value("bar")
+      assert field.has_values?
+    end
+
+    test "values (nil)" do
+      field = FieldMapper::Standard::Field.new(:foo, type: Integer)
+      assert field.values.nil?
+    end
+
+    test "values (present)" do
+      field = FieldMapper::Standard::Field.new(:foo, type: Integer)
+      (1..3).each { |i| field.value(i) }
+      assert field.values.present?
+      assert field.values.length == 3
+    end
+
+    test "find_value (base value)" do
+      field = FieldMapper::Standard::Field.new(:foo, type: Integer)
+      (1..3).each { |i| field.value(i) }
+      assert field.find_value(2) == field.values[1]
+    end
+
+    test "find_value (value type)" do
+      field = FieldMapper::Standard::Field.new(:foo, type: Integer)
+      (1..3).each { |i| field.value(i) }
+      assert field.find_value(field.values[1]) == field.values[1]
+    end
+
+    test "add value performs type cast" do
+      field = FieldMapper::Standard::Field.new(:foo, type: String)
+      field.value(:bar)
+      assert field.values.first.value == "bar"
+    end
+
+    test "cast (String)" do
+      field = FieldMapper::Standard::Field.new(:foo, type: String)
+      assert field.cast(1) == "1"
+    end
+
+    test "cast (Integer)" do
+      field = FieldMapper::Standard::Field.new(:foo, type: Integer)
+      assert field.cast("1") == 1
+    end
+
+    test "cast (Float)" do
+      field = FieldMapper::Standard::Field.new(:foo, type: Float)
+      assert field.cast("0.1") == 0.1
+    end
+
+    test "cast (Time)" do
+      field = FieldMapper::Standard::Field.new(:foo, type: Time)
+      expected = Time.parse("2000-01-15")
+      assert field.cast("01/15/2000") == expected
+    end
+
+    test "cast (Boolean true)" do
+      field = FieldMapper::Standard::Field.new(:foo, type: FieldMapper::Types::Boolean)
+      assert field.cast(:true) == true
+      assert field.cast(:t) == true
+      assert field.cast(1) == true
+      assert field.cast(:foo) == true
+    end
+
+    test "cast (Boolean false)" do
+      field = FieldMapper::Standard::Field.new(:foo, type: FieldMapper::Types::Boolean)
+      assert field.cast(:false) == false
+      assert field.cast(:f) == false
+      assert field.cast(:n) == false
+      assert field.cast(0) == false
+    end
+
+    test "cast (Money USD)" do
+      field = FieldMapper::Standard::Field.new(:foo, type: Money)
+      assert field.cast("$100.00 USD") == Money.new(100_00, "USD")
+    end
+
+    test "cast (Money EUR)" do
+      field = FieldMapper::Standard::Field.new(:foo, type: Money)
+      assert field.cast("€100.00 EUR") == Money.new(100_00, "EUR")
+    end
+
+    test "cast (Money MXN)" do
+      field = FieldMapper::Standard::Field.new(:foo, type: Money)
+      assert field.cast("$100.00 MXN") == Money.new(100_00, "MXN")
+    end
+
+    test "cast (List)" do
+      field = FieldMapper::Standard::Field.new(:foo, type: FieldMapper::Types::List[Standard::PlatExample])
+      list = []
+      list << Standard::PlatExample.new(name: :foo)
+      list << Standard::PlatExample.new(name: :bar)
+      assert field.cast(list) == list
+    end
+
+    test "to_s" do
+      field = FieldMapper::Standard::Field.new(:foo, type: String)
+      assert field.to_s == field.name
+    end
+  end
+end