representable 1.8.5 → 2.0.0.rc1

data/test/definition_test.rb

@@ -3,8 +3,45 @@ require 'test_helper'
 class DefinitionTest < MiniTest::Spec
   Definition = Representable::Definition
 
-  describe "#merge!" do
+  # TODO: test that we DON'T clone options, that must happen in
+  describe "#initialize" do
+    it do
+      opts = nil
+
+      # new yields the defaultized options HASH.
+      definition = Definition.new(:song, :extend => Module) do |options|
+        options[:awesome] = true
+        options[:parse_filter] << 1
+
+        # default variables
+        options[:as].must_equal "song"
+        options[:extend].must_equal Module
+      end
+
+      #
+      definition[:awesome].must_equal true
+      definition[:parse_filter].instance_variable_get(:@value).must_equal Representable::Pipeline[1]
+      definition[:render_filter].instance_variable_get(:@value).must_equal Representable::Pipeline[]
+    end
+  end
+
+  describe "#[]" do
     let (:definition) { Definition.new(:song) }
+    # default is nil.
+    it { definition[:bla].must_equal nil }
+  end
+
+  # merge!
+  describe "#merge!" do
+    let (:definition) { Definition.new(:song, :whatever => true) }
+
+    # merges new options.
+    it { definition.merge!(:something => true)[:something].must_equal true }
+    # doesn't override original options.
+    it { definition.merge!({:something => true})[:whatever].must_equal true }
+    # override original when passed in #merge!.
+    it { definition.merge!({:whatever => false})[:whatever].must_equal false }
+
 
     it "runs macros" do
       definition[:setter].must_equal nil
@@ -12,12 +49,46 @@ class DefinitionTest < MiniTest::Spec
       definition[:setter].must_respond_to :evaluate
     end
 
-    # it "what" do
-    #   definition.merge!(:parse_strategy => :sync, :collection => true)
-    #   definition[:bullshit].must_equal true
-    # end
+    # with block
+    it do
+      definition = Definition.new(:song, :extend => Module).merge!({:something => true}) do |options|
+        options[:awesome] = true
+        options[:render_filter] << 1
+
+        # default variables
+        # options[:as].must_equal "song"
+        # options[:extend].must_equal Module
+      end
+
+      definition[:awesome].must_equal true
+      definition[:something].must_equal true
+      definition[:render_filter].instance_variable_get(:@value).must_equal Representable::Pipeline[1]
+      definition[:parse_filter].instance_variable_get(:@value).must_equal Representable::Pipeline[]
+    end
+
+    describe "with :parse_filter" do
+      let (:definition) { Definition.new(:title, :parse_filter => 1) }
+
+      # merges :parse_filter and :render_filter.
+      it do
+        merged = definition.merge!(:parse_filter => 2)[:parse_filter]
+
+        merged.instance_variable_get(:@value).must_be_kind_of Representable::Pipeline
+        merged.instance_variable_get(:@value).size.must_equal 2
+      end
+
+      # :parse_filter can also be array.
+      it { definition.merge!(:parse_filter => [2, 3])[:parse_filter].instance_variable_get(:@value).size.must_equal 3 }
+    end
+
+    # does not change arguments
+    it do
+      Definition.new(:title).merge!(options = {:whatever => 1})
+      options.must_equal(:whatever => 1)
+    end
   end
 
+
   describe "generic API" do
     before do
       @def = Representable::Definition.new(:songs)
@@ -25,7 +96,7 @@ class DefinitionTest < MiniTest::Spec
 
     it "responds to #representer_module" do
       assert_equal nil, Representable::Definition.new(:song).representer_module
-      assert_equal Hash, Representable::Definition.new(:song, :extend => Hash).representer_module.evaluate(nil)
+      assert_equal Hash, Representable::Definition.new(:song, :extend => Hash).representer_module
     end
 
     describe "#typed?" do
@@ -68,15 +139,39 @@ class DefinitionTest < MiniTest::Spec
       assert_equal :"songs=", @def.setter
     end
 
+
     describe "#clone" do
+      subject { Representable::Definition.new(:title, :volume => 9, :clonable => Uber::Options::Value.new(1)) }
+
+      it { subject.clone.must_be_kind_of Representable::Definition }
+      it { subject.clone[:clonable].evaluate(nil).must_equal 1 }
+
       it "clones @options" do
         @def.merge!(:volume => 9)
+
         cloned = @def.clone
         cloned.merge!(:volume => 8)
 
         assert_equal @def[:volume], 9
         assert_equal cloned[:volume], 8
       end
+
+      # pipeline gets cloned properly
+      describe "pipeline cloning" do
+        subject { Definition.new(:title, :render_filter => 1) }
+
+        it ("yy")do
+          cloned = subject.clone
+
+          cloned.merge!(:render_filter => 2)
+
+          subject.instance_variable_get(:@options)[:render_filter].must_equal [1]
+          cloned.instance_variable_get(:@options)[:render_filter].must_equal [1,2]
+
+          subject[:render_filter].instance_variable_get(:@value).must_equal [1]
+          cloned[:render_filter].instance_variable_get(:@value).must_equal [1,2]
+        end
+      end
     end
   end
 
@@ -91,26 +186,26 @@ class DefinitionTest < MiniTest::Spec
   end
 
 
-  describe "#skipable_nil_value?" do
-    # default if skipable_nil_value?
+  describe "#skipable_empty_value?" do
+    # default if skipable_empty_value?
     before do
       @def = Representable::Definition.new(:song, :render_nil => true)
     end
 
     it "returns false when not nil" do
-      assert_equal false, @def.skipable_nil_value?("Disconnect, Disconnect")
+      assert_equal false, @def.skipable_empty_value?("Disconnect, Disconnect")
     end
 
     it "returns false when nil and :render_nil => true" do
-      assert_equal false, @def.skipable_nil_value?(nil)
+      assert_equal false, @def.skipable_empty_value?(nil)
     end
 
     it "returns true when nil and :render_nil => false" do
-      assert_equal true, Representable::Definition.new(:song).skipable_nil_value?(nil)
+      assert_equal true, Representable::Definition.new(:song).skipable_empty_value?(nil)
     end
 
     it "returns false when not nil and :render_nil => false" do
-      assert_equal false, Representable::Definition.new(:song).skipable_nil_value?("Fatal Flu")
+      assert_equal false, Representable::Definition.new(:song).skipable_empty_value?("Fatal Flu")
     end
   end
 
@@ -149,54 +244,6 @@ class DefinitionTest < MiniTest::Spec
   end
 
 
-  describe "#writeable?" do
-
-    it "returns true when :writeable is not given" do
-      @def = Representable::Definition.new(:song)
-      assert_equal true, @def.writeable?
-    end
-
-    it "returns true when :writeable => true" do
-      @def = Representable::Definition.new(:song, :writeable => true)
-      assert_equal true, @def.writeable?
-    end
-
-    it "returns false when :writeable => false" do
-      @def = Representable::Definition.new(:song, :writeable => false)
-      assert_equal false, @def.writeable?
-    end
-
-    it "returns nil when :writeable is nil" do
-      @def = Representable::Definition.new(:song, :writeable => nil)
-      assert_equal nil, @def.writeable?
-    end
-
-  end
-
-  describe "#readable?" do
-
-    it "returns true when :readable is not given" do
-      @def = Representable::Definition.new(:song)
-      assert_equal true, @def.readable?
-    end
-
-    it "returns true when :readable => true" do
-      @def = Representable::Definition.new(:song, :readable => true)
-      assert_equal true, @def.readable?
-    end
-
-    it "returns false when :readable => false" do
-      @def = Representable::Definition.new(:song, :readable => false)
-      assert_equal false, @def.readable?
-    end
-
-    it "returns nil when :readable is nil" do
-      @def = Representable::Definition.new(:song, :readable => nil)
-      assert_equal nil, @def.readable?
-    end
-
-  end
-
   describe "#binding" do
     it "returns true when :binding is set" do
       assert Representable::Definition.new(:songs, :binding => Object)[:binding]
@@ -223,10 +270,6 @@ class DefinitionTest < MiniTest::Spec
     it "responds to #array?" do
       assert @def.array?
     end
-
-    it "responds to #default" do
-      assert_equal nil, @def.send(:default)
-    end
   end
 
 

data/test/features_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+class FeaturesTest < MiniTest::Spec
+  module Title
+    def title; "Is It A Lie"; end
+  end
+  module Length
+    def length; "2:31"; end
+  end
+
+  definition = lambda {
+    feature Title
+    feature Length
+
+    # exec_context: :decorator, so the readers are called on the Decorator instance (which gets readers from features!).
+    property :title, exec_context: :decorator
+    property :length, exec_context: :decorator
+    property :details do
+      property :title, exec_context: :decorator
+    end
+  }
+
+  let (:song) { OpenStruct.new(:details => Object.new) }
+
+  describe "Module" do
+    representer! do
+      instance_exec &definition
+    end
+
+    it { song.extend(representer).to_hash.must_equal({"title"=>"Is It A Lie", "length"=>"2:31", "details"=>{"title"=>"Is It A Lie"}}) }
+  end
+
+
+  describe "Decorator" do
+    representer!(:decorator => true) do
+      instance_exec &definition
+    end
+
+    it { representer.new(song).to_hash.must_equal({"title"=>"Is It A Lie", "length"=>"2:31", "details"=>{"title"=>"Is It A Lie"}}) }
+  end
+end

data/test/filter_test.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+class FilterPipelineTest < MiniTest::Spec
+  let (:block1) { lambda { |value, *| "1: #{value}" } }
+  let (:block2) { lambda { |value, *| "2: #{value}" } }
+
+  subject { Representable::Pipeline[block1, block2] }
+
+  it { subject.call(Object, "Horowitz").must_equal "2: 1: Horowitz" }
+end
+
+
+class FilterTest < MiniTest::Spec
+  representer! do
+    property :title
+    property :track,
+      :parse_filter  => lambda { |val, doc, options| "#{val.downcase},#{doc},#{options}" },
+      :render_filter => lambda { |val, doc, options| "#{val.upcase},#{doc},#{options}" }
+  end
+
+  # gets doc and options.
+  it {
+    song = OpenStruct.new.extend(representer).from_hash("title" => "VULCAN EARS", "track" => "Nine")
+    song.title.must_equal "VULCAN EARS"
+    song.track.must_equal "nine,{\"title\"=>\"VULCAN EARS\", \"track\"=>\"Nine\"},{}"
+  }
+
+  it { OpenStruct.new("title" => "vulcan ears", "track" => "Nine").extend(representer).to_hash.must_equal( {"title"=>"vulcan ears", "track"=>"NINE,{\"title\"=>\"vulcan ears\"},{}"}) }
+
+
+  describe "#parse_filter" do
+    representer! do
+      property :track,
+        :parse_filter => [
+          lambda { |val, doc, options| "#{val}-1" },
+          lambda { |val, doc, options| "#{val}-2" }],
+        :render_filter => [
+          lambda { |val, doc, options| "#{val}-1" },
+          lambda { |val, doc, options| "#{val}-2" }]
+
+      # definition[:parse_filter].instance_variable_get(:@value) << lambda { |val, doc, options| "#{val}-1" }
+      # property :track, :parse_filter => lambda { |val, doc, options| "#{val}-2" }, :inherit => true
+    end
+
+    # order matters.
+    it { OpenStruct.new.extend(representer).from_hash("track" => "Nine").track.must_equal "Nine-1-2" }
+    it { OpenStruct.new("track" => "Nine").extend(representer).to_hash.must_equal({"track"=>"Nine-1-2"}) }
+  end
+end
+
+
+class RenderFilterTest < MiniTest::Spec
+  representer! do
+    property :track, :render_filter => [lambda { |val, doc, options| "#{val}-1" } ]
+    property :track, :render_filter => [lambda { |val, doc, options| "#{val}-2" } ], :inherit => true
+  end
+
+  it { OpenStruct.new("track" => "Nine").extend(representer).to_hash.must_equal({"track"=>"Nine-1-2"}) }
+end

data/test/for_collection_test.rb

@@ -0,0 +1,74 @@
+require 'test_helper'
+
+class ForCollectionTest < MiniTest::Spec
+  module SongRepresenter
+    include Representable::JSON
+
+    property :name
+  end
+
+  let (:songs) { [Song.new("Days Go By"), Song.new("Can't Take Them All")] }
+  let (:json)  { "[{\"name\":\"Days Go By\"},{\"name\":\"Can't Take Them All\"}]" }
+
+
+  # Module.for_collection
+  # Decorator.for_collection
+  for_formats(
+    :hash => [Representable::Hash, out=[{"name" => "Days Go By"}, {"name"=>"Can't Take Them All"}], out],
+    :json => [Representable::JSON, out="[{\"name\":\"Days Go By\"},{\"name\":\"Can't Take Them All\"}]", out],
+    # :xml  => [Representable::XML,  out="<a><song></song><song></song></a>", out]
+  ) do |format, mod, output, input|
+
+    describe "Module::for_collection [#{format}]" do
+      let (:format) { format }
+
+      let (:representer) {
+        Module.new do
+          include mod
+          property :name#, :as => :title
+
+          collection_representer :class => Song
+
+          # self.representation_wrap = :songs if format == :xml
+        end
+      }
+
+      it { render(songs.extend(representer.for_collection)).must_equal_document output }
+      it { render(representer.for_collection.prepare(songs)).must_equal_document output }
+      # parsing needs the class set, at least
+      it { parse([].extend(representer.for_collection), input).must_equal songs }
+    end
+
+    describe "Module::for_collection without configuration [#{format}]" do
+      let (:format) { format }
+
+      let (:representer) {
+        Module.new do
+          include mod
+          property :name
+        end
+      }
+
+      # rendering works out of the box, no config necessary
+      it { render(songs.extend(representer.for_collection)).must_equal_document output }
+    end
+
+
+    describe "Decorator::for_collection [#{format}]" do
+      let (:format) { format }
+      let (:representer) {
+        Class.new(Representable::Decorator) do
+          include mod
+          property :name
+
+          collection_representer :class => Song
+        end
+      }
+
+      it { render(representer.for_collection.new(songs)).must_equal_document output }
+      it { parse(representer.for_collection.new([]), input).must_equal songs }
+    end
+  end
+
+  # with module including module
+end

data/test/inherit_test.rb

@@ -40,6 +40,7 @@ class InheritTest < MiniTest::Spec
     representer! do
       include SongRepresenter
 
+      puts "passing block"
       property :name, :inherit => true do # inherit as: title
         property :string, :as => :s
         property :length
@@ -86,11 +87,51 @@ class InheritTest < MiniTest::Spec
     it "replaces inherited property" do
       representer.representable_attrs.size.must_equal 2
 
-      definition = representer.representable_attrs[:track] # TODO: find a better way to assert Definition identity.
-      definition.keys.size.must_equal 2
+      definition = representer.representable_attrs.get(:track) # TODO: find a better way to assert Definition identity.
+      # definition.keys.size.must_equal 2
       definition[:representable].   must_equal true
       definition[:as].evaluate(nil).must_equal "track" # was "no".
     end
   end
 
-end
+
+  # decorator
+  describe ":inherit with decorator" do
+    representer!(:decorator => true) do
+      property :hit do
+        property :title
+      end
+    end
+
+    let (:inheriting) {
+      class InheritingDecorator < representer
+        property :hit, :inherit => true do
+          property :length
+        end
+        self
+      end
+    }
+
+    it { inheriting.new(OpenStruct.new(:hit => OpenStruct.new(:title => "Hole In Your Soul", :length => "2:59"))).to_hash.must_equal(
+      {"hit"=>{"title"=>"Hole In Your Soul", "length"=>"2:59"}}) }
+  end
+end
+
+
+# class InheritancingTest < MiniTest::Spec
+#   class SongDecorator < Representable::Decorator
+#     include Representable::Hash
+#     property :album do
+#       # does have Hash.
+#       property :title
+#     end
+#   end
+
+#   class JsonSongDecorator < SongDecorator
+#     include Representable::XML
+#   end
+
+#   it do
+#     puts JsonSongDecorator.new(OpenStruct.new(:album => OpenStruct.new(:title => "Erotic Cakes", :tracks => nil))).to_xml
+#   end
+# end