representable 2.4.0.rc3 → 2.4.0.rc4

data/test-with-deprecations/examples/object.rb

@@ -0,0 +1,31 @@
+require "test_helper"
+
+require "ostruct"
+require "pp"
+
+
+source = OpenStruct.new(name: "30 Years Live", songs: [
+  OpenStruct.new(id: 1, title: "Dear Beloved"), OpenStruct.new(id: 2, title: "Fuck Armageddon")])
+
+pp source
+
+require "representable/object"
+
+class AlbumRepresenter < Representable::Decorator
+  include Representable::Object
+
+  property :name
+  collection :songs, instance: ->(fragment, *) { Song.new } do
+    property :title
+  end
+end
+
+
+Album = Struct.new(:name, :songs)
+Song = Struct.new(:title)
+
+target = Album.new
+
+AlbumRepresenter.new(target).from_object(source)
+
+pp target

data/test-with-deprecations/exec_context_test.rb

@@ -0,0 +1,93 @@
+require 'test_helper'
+
+class ExecContextTest < MiniTest::Spec
+  for_formats(
+    :hash => [Representable::Hash, {Song => "Rebel Fate"}, {Song=>"Timing"}],
+    # :xml  => [Representable::XML, "<open_struct>\n  <song>\n    <name>Alive</name>\n  </song>\n</open_struct>", "<open_struct><song><name>You've Taken Everything</name></song>/open_struct>"],
+    # :yaml => [Representable::YAML, "---\nsong:\n  name: Alive\n", "---\nsong:\n  name: You've Taken Everything\n"],
+  ) do |format, mod, input, output|
+
+    let (:song) { representer.prepare(Song.new("Timing")) }
+    let (:format) { format }
+
+
+    describe "exec_context: nil" do
+      representer!(:module => mod) do
+        property :name, :as => lambda { |*| self.class }
+      end
+
+      it { render(song).must_equal_document output }
+      it { parse(song, input).name.must_equal "Rebel Fate" }
+    end
+
+
+    describe "exec_context: :decorator" do
+      representer!(:module => mod) do
+        property :name, :as => lambda { |*| self.class }, :exec_context => :decorator
+      end
+
+      it { render(song).must_equal_document output }
+      it { parse(song, input).name.must_equal "Rebel Fate" }
+    end
+
+
+    describe "exec_context: :binding" do
+      representer!(:module => mod) do
+        property :name,
+          :as           => lambda { |*| self.class }, # to actually test
+          :exec_context => :binding,
+          :setter        => lambda { |v, *args| represented.name = v # to make parsing work.
+        }
+      end
+
+      it { render(song).must_equal_document({Representable::Hash::Binding => "name"}) }
+      it { parse(song, {Representable::Hash::Binding => "Rebel Fate"}).name.must_equal "Rebel Fate" }
+    end
+
+
+    describe "Decorator" do
+      # DISCUSS: do we need this test?
+      describe "exec_context: nil" do
+        representer!(:module => mod, :decorator => true) do
+          property :name, :as => lambda { |*| self.class }
+        end
+
+        it { render(song).must_equal_document output }
+        it { parse(song, input).name.must_equal "Rebel Fate" }
+      end
+
+
+      describe "exec_context: :decorator" do # this tests if lambdas are run in the right context, if methods are called in the right context and if we can access the represented object.
+        representer!(:module => mod, :decorator => true) do
+          property :name, :as => lambda { |*| self.class.superclass }, :exec_context => :decorator
+
+          define_method :name do # def in Decorator class.
+            "Timebomb"
+          end
+
+          define_method :"name=" do |v| # def in Decorator class.
+            represented.name = v
+          end
+        end
+
+        it { render(song).must_equal_document({Representable::Decorator=>"Timebomb"}) }
+        it { parse(song, {Representable::Decorator=>"Listless"}).name.must_equal "Listless" }
+      end
+
+
+      # DISCUSS: do we need this test?
+      describe "exec_context: :binding" do
+        representer!(:module => mod, :decorator => true) do
+          property :name,
+            :as           => lambda { |*| self.class }, # to actually test
+            :exec_context => :binding,
+            :setter        => lambda { |v, *args| represented.name = v # to make parsing work.
+          }
+        end
+
+        it { render(song).must_equal_document({Representable::Hash::Binding => "name"}) }
+        it("xxx") { parse(song, {Representable::Hash::Binding => "Rebel Fate"}).name.must_equal "Rebel Fate" }
+      end
+    end
+  end
+end

data/test-with-deprecations/features_test.rb

@@ -0,0 +1,70 @@
+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
+
+class FeatureInclusionOrderTest < MiniTest::Spec
+  module Title
+    def title
+      "I was first!"
+    end
+  end
+
+  module OverridingTitle
+    def title
+      "I am number two, " + super
+    end
+  end
+
+  representer!(decorator: true) do
+    feature Title
+    feature OverridingTitle
+
+    property :title, exec_context: :decorator
+
+    property :song do
+      property :title, exec_context: :decorator
+    end
+  end
+
+  it do
+    representer.new(OpenStruct.new(song: Object)).to_hash.must_equal({"title"=>"I am number two, I was first!", "song"=>{"title"=>"I am number two, I was first!"}})
+  end
+end

data/test-with-deprecations/filter_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+class FilterPipelineTest < MiniTest::Spec
+  let (:block1) { lambda { |input, options| "1: #{input}" } }
+  let (:block2) { lambda { |input, options| "2: #{input}" } }
+
+  subject { Representable::Pipeline[block1, block2] }
+
+  it { subject.call("Horowitz", {}).must_equal "2: 1: Horowitz" }
+end
+
+
+class FilterTest < MiniTest::Spec
+  representer! do
+    property :title
+
+    property :track,
+      :parse_filter  => lambda { |input, options| "#{input.downcase},#{options[:doc]}" },
+      :render_filter => lambda { |val, options| "#{val.upcase},#{options[:doc]},#{options[:options][:user_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 { |input, options| "#{input}-1" },
+          lambda { |input, options| "#{input}-2" }],
+        :render_filter => [
+          lambda { |val, options| "#{val}-1" },
+          lambda { |val, options| "#{val}-2" }]
+    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, options| "#{val}-1" } ]
+#     property :track, :render_filter => [lambda { |val, options| "#{val}-2" } ], :inherit => true
+#   end
+
+#   it { OpenStruct.new("track" => "Nine").extend(representer).to_hash.must_equal({"track"=>"Nine-1-2"}) }
+# end

data/test-with-deprecations/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-with-deprecations/generic_test.rb

@@ -0,0 +1,116 @@
+require 'test_helper'
+
+class GenericTest < MiniTest::Spec # TODO: rename/restructure to CollectionTest.
+  let (:new_album)  { OpenStruct.new.extend(representer) }
+  let (:album)      { OpenStruct.new(:songs => ["Fuck Armageddon"]).extend(representer) }
+  let (:song) { OpenStruct.new(:title => "Resist Stance") }
+  let (:song_representer) { Module.new do include Representable::Hash; property :title end  }
+
+
+  describe "::collection" do
+    representer! do
+      collection :songs
+    end
+
+    it "doesn't initialize property" do
+      new_album.from_hash({})
+      new_album.songs.must_equal nil
+    end
+
+    it "leaves properties untouched" do
+      album.from_hash({})
+      # TODO: test property.
+      album.songs.must_equal ["Fuck Armageddon"] # when the collection is not present in the incoming hash, this propery stays untouched.
+    end
+
+
+    # when collection is nil, it doesn't get rendered:
+    for_formats(
+      :hash => [Representable::Hash, {}],
+      :xml  => [Representable::XML, "<open_struct></open_struct>"],
+      :yaml => [Representable::YAML, "--- {}\n"], # FIXME: this doesn't look right.
+    ) do |format, mod, output, input|
+
+      describe "nil collections" do
+        let (:format) { format }
+
+        representer!(:module => mod) do
+          collection :songs
+          self.representation_wrap = :album if format == :xml
+        end
+
+        let (:album) { Album.new.extend(representer) }
+
+        it "doesn't render collection in #{format}" do
+          render(album).must_equal_document output
+        end
+      end
+    end
+
+    # when collection is set but empty, render the empty collection.
+    for_formats(
+      :hash => [Representable::Hash, {"songs" => []}],
+      #:xml  => [Representable::XML, "<open_struct><songs/></open_struct>"],
+      :yaml => [Representable::YAML, "---\nsongs: []\n"],
+    ) do |format, mod, output, input|
+
+      describe "empty collections" do
+        let (:format) { format }
+
+        representer!(:module => mod) do
+          collection :songs
+          self.representation_wrap = :album if format == :xml
+        end
+
+        let (:album) { OpenStruct.new(:songs => []).extend(representer) }
+
+        it "renders empty collection in #{format}" do
+          render(album).must_equal_document output
+        end
+      end
+    end
+
+
+    # when collection is [], suppress rendering when render_empty: false.
+    for_formats(
+      :hash => [Representable::Hash, {}],
+      #:xml  => [Representable::XML, "<open_struct><songs/></open_struct>"],
+      :yaml => [Representable::YAML, "--- {}\n"],
+    ) do |format, mod, output, input|
+
+      describe "render_empty [#{format}]" do
+        let (:format) { format }
+
+        representer!(:module => mod) do
+          collection :songs, :render_empty => false
+          self.representation_wrap = :album if format == :xml
+        end
+
+        let (:album) { OpenStruct.new(:songs => []).extend(representer) }
+
+        it { render(album).must_equal_document output }
+      end
+    end
+  end
+
+
+  # wrap_test
+  for_formats(
+    :hash => [Representable::Hash, {}],
+    # :xml  => [Representable::XML, "<open_struct>\n  <song>\n    <name>Alive</name>\n  </song>\n</open_struct>", "<open_struct><song><name>You've Taken Everything</name></song>/open_struct>"],
+    # :yaml => [Representable::YAML, "---\nsong:\n  name: Alive\n", "---\nsong:\n  name: You've Taken Everything\n"],
+  ) do |format, mod, input|
+
+    describe "parsing [#{format}] with wrap where wrap is missing" do
+      representer!(:module => mod) do
+        self.representation_wrap = :song
+
+        property :title
+      end
+
+      it "doesn't change represented object" do
+        song.extend(representer).send("from_#{format}", input).title.must_equal "Resist Stance"
+      end
+    end
+  end
+end