representable 2.4.1 → 3.0.0

data/test-with-deprecations/populator_test.rb

@@ -1,105 +0,0 @@
-require "test_helper"
-
-class PopulatorTest < Minitest::Spec
-  Song   = Struct.new(:id)
-  Artist = Struct.new(:name)
-  Album  = Struct.new(:songs, :artist)
-
-  describe "populator: ->{}" do
-    representer! do
-      collection :songs, populator: ->(input, options) { options[:represented].songs << song = Song.new; song } do
-        property :id
-      end
-
-      property :artist, populator: ->(input, options) { options[:represented].artist = Artist.new } do
-        property :name
-      end
-    end
-
-    let (:album) { Album.new([]) }
-
-    it do
-      album.extend(representer).from_hash("songs"=>[{"id"=>1}, {"id"=>2}], "artist"=>{"name"=>"Waste"})
-      album.inspect.must_equal "#<struct PopulatorTest::Album songs=[#<struct PopulatorTest::Song id=1>, #<struct PopulatorTest::Song id=2>], artist=#<struct PopulatorTest::Artist name=\"Waste\">>"
-    end
-  end
-
-  describe "populator: ->{}, " do
-
-  end
-end
-
-class PopulatorFindOrInstantiateTest < Minitest::Spec
-  Song = Struct.new(:id, :title, :uid) do
-    def self.find_by(attributes={})
-      return new(1, "Resist Stan", "abcd") if attributes[:id]==1# we should return the same object here
-      new
-    end
-  end
-
-  Composer = Struct.new(:song)
-  Composer.class_eval do
-    def song=(v)
-      @song = v
-      "Absolute nonsense" # this tests that the populator always returns the correct object.
-    end
-
-    attr_reader :song
-  end
-
-  describe "FindOrInstantiate with property" do
-    representer! do
-      property :song, populator: Representable::FindOrInstantiate, class: Song do
-        property :id
-        property :title
-      end
-    end
-
-    let (:album) { Composer.new.extend(representer).extend(Representable::Debug) }
-
-    it "finds by :id and creates new without :id" do
-      album.from_hash({"song"=>{"id" => 1, "title"=>"Resist Stance"}})
-
-      album.song.title.must_equal "Resist Stance" # note how title is updated from "Resist Stan"
-      album.song.id.must_equal 1
-      album.song.uid.must_equal "abcd" # not changed via populator, indicating this is a formerly "persisted" object.
-    end
-
-    it "creates new without :id" do
-      album.from_hash({"song"=>{"title"=>"Lower"}})
-
-      album.song.title.must_equal "Lower"
-      album.song.id.must_equal nil
-      album.song.uid.must_equal nil
-    end
-  end
-
-  describe "FindOrInstantiate with collection" do
-    representer! do
-      collection :songs, populator: Representable::FindOrInstantiate, class: Song do
-        property :id
-        property :title
-      end
-    end
-
-    let (:album) { Struct.new(:songs).new([]).extend(representer) }
-
-    it "finds by :id and creates new without :id" do
-      album.from_hash({"songs"=>[
-        {"id" => 1, "title"=>"Resist Stance"},
-        {"title"=>"Suffer"}
-      ]})
-
-      album.songs[0].title.must_equal "Resist Stance" # note how title is updated from "Resist Stan"
-      album.songs[0].id.must_equal 1
-      album.songs[0].uid.must_equal "abcd" # not changed via populator, indicating this is a formerly "persisted" object.
-
-      album.songs[1].title.must_equal "Suffer"
-      album.songs[1].id.must_equal nil
-      album.songs[1].uid.must_equal nil
-    end
-
-    # TODO: test with existing collection
-  end
-
-end

data/test-with-deprecations/prepare_test.rb

@@ -1,67 +0,0 @@
-require 'test_helper'
-
-class PrepareTest < BaseTest
-  class PreparerClass
-    def initialize(object)
-      @object = object
-    end
-
-    def ==(b)
-      return unless b.instance_of?(PreparerClass)
-
-      object == b.object
-    end
-
-    attr_reader :object
-  end
-
-  describe "#to_hash" do # TODO: introduce :representable option?
-    representer! do
-      property :song,
-        :prepare       => lambda { |obj, args| args.binding[:arbitrary].new(obj) },
-        :arbitrary     => PreparerClass,
-        :extend => true,
-        :pass_options  => true,
-        :representable => false # don't call #to_hash.
-    end
-
-    let (:hit) { Struct.new(:song).new(song).extend(representer) }
-
-    it "calls prepare:, nothing else" do
-      # render(hit).must_equal_document(output)
-      hit.to_hash.must_equal({"song" => PreparerClass.new(song)})
-    end
-
-
-    # it "calls #from_hash on the existing song instance, nothing else" do
-    #   song_id = hit.song.object_id
-
-    #   parse(hit, input)
-
-    #   hit.song.title.must_equal "Suffer"
-    #   hit.song.object_id.must_equal song_id
-    # end
-  end
-
-
-  describe "#from_hash" do
-    representer! do
-      property :song,
-        :prepare       => lambda { |obj, args| args.binding[:arbitrary].new(obj) },
-        :arbitrary     => PreparerClass,
-        #:extend => true, # TODO: typed: true would be better.
-        :instance => String.new, # pass_fragment
-        :pass_options  => true,
-        :representable => false # don't call #to_hash.
-    end
-
-    let (:hit) { Struct.new(:song).new.extend(representer) }
-
-    it "calls prepare:, nothing else" do
-      # render(hit).must_equal_document(output)
-      hit.from_hash("song" => {})
-
-      hit.song.must_equal(PreparerClass.new(String.new))
-    end
-  end
-end

data/test-with-deprecations/private_options_test.rb

@@ -1,18 +0,0 @@
-require "test_helper"
-
-class PrivateOptionsTest < MiniTest::Spec # TODO: move me to separate file.
-  representer!(decorator: true) do
-  end
-
-  options = {exclude: "name"}
-
-  it "render: doesn't modify options" do
-    representer.new(nil).to_hash(options)
-    options.must_equal({exclude: "name"})
-  end
-
-  it "parse: doesn't modify options" do
-    representer.new(nil).from_hash(options)
-    options.must_equal({exclude: "name"})
-  end
-end

data/test-with-deprecations/reader_writer_test.rb

@@ -1,19 +0,0 @@
-require 'test_helper'
-
-class ReaderWriterTest < BaseTest
-  representer! do
-    property :name,
-      :writer => lambda { |doc, args| doc["title"] = "#{args[:nr]}) #{name}" },
-      :reader => lambda { |doc, args| self.name = doc["title"].split(") ").last }
-  end
-
-  subject { OpenStruct.new(:name => "Disorder And Disarray").extend(representer) }
-
-  it "uses :writer when rendering" do
-    subject.to_hash(:nr => 14).must_equal({"title" => "14) Disorder And Disarray"})
-  end
-
-  it "uses :reader when parsing" do
-    subject.from_hash({"title" => "15) The Wars End"}).name.must_equal "The Wars End"
-  end
-end

data/test-with-deprecations/realistic_benchmark.rb

@@ -1,115 +0,0 @@
-require 'test_helper'
-require 'benchmark'
-
-Kernel.class_eval do
-  # def respond_to_missing?
-  #   raise
-  # end
-#   alias_method :orig_hash, :hash
-#   def hash
-#     puts "hash in #{self.class}"
-#     raise self.inspect if self.class == Symbol
-#     orig_hash
-#   end
-end
-Representable.deprecations = false
-
-SONG_PROPERTIES = 50.times.collect do |i|
-  "song_property_#{i}"
-end
-
-
-module SongRepresenter
-  include Representable::JSON
-
-  SONG_PROPERTIES.each { |p| property p }
-end
-
-class NestedProperty < Representable::Decorator
-  include Representable::JSON
-
-  SONG_PROPERTIES.each { |p| property p }
-end
-
-
-class SongDecorator < Representable::Decorator
-  include Representable::JSON
-
-  SONG_PROPERTIES.each { |p| property p, extend: NestedProperty }
-end
-
-class AlbumRepresenter < Representable::Decorator
-  include Representable::JSON
-
-  # collection :songs, extend: SongRepresenter
-  collection :songs, extend: SongDecorator
-end
-
-Song  = Struct.new(*SONG_PROPERTIES.map(&:to_sym))
-Album = Struct.new(:songs)
-
-def random_song
-  Song.new(*SONG_PROPERTIES.collect { |p| Song.new(*SONG_PROPERTIES) })
-end
-
-times = []
-
-3.times.each do
-  album = Album.new(100.times.collect { random_song })
-
-  times << Benchmark.measure do
-    puts "================ next!"
-    AlbumRepresenter.new(album).to_json
-  end
-end
-
-puts times.join("")
-
-album = Album.new(100.times.collect { random_song })
-require 'ruby-prof'
-RubyProf.start
-AlbumRepresenter.new(album).to_hash
-res = RubyProf.stop
-printer = RubyProf::FlatPrinter.new(res)
-printer.print(array = [])
-
-array[0..60].each { |a| puts a }
-
-# 100 songs, 100 attrs
-#  0.050000   0.000000   0.050000 (  0.093157)
-
-## 100 songs, 1000 attrs
-#  0.470000   0.010000   0.480000 (  0.483708)
-
-
-### without binding cache:
-  # 2.790000   0.030000   2.820000 (  2.820190)
-
-
-
-### with extend: on Song, with binding cache>
-  # 2.490000   0.030000   2.520000 (  2.517433) 2.4-3.0
-  ### without skip?
-  # 2.030000   0.020000   2.050000 (  2.050796) 2.1-2.3
-
-    ### without :writer
-    # 2.270000   0.010000   2.280000 (  2.284530 1.9-2.2
-      ### without :render_filter
-      #   2.020000   0.000000   2.020000 (  2.030234) 1.5-2.0
-        ###without default_for and skipable?
-        #   1.730000   0.010000   1.740000 (  1.735597 1.4-1.7
-          ### without :serialize
-          #   1.780000   0.010000   1.790000 (  1.786791) 1.4-1.7
-          ### using decorator
-          # 1.400000   0.030000   1.430000 (  1.434206) 1.4-1.6
-            ### with prepare AFTER  representable?
-            # 1.330000   0.010000   1.340000 (  1.335900) 1.1-1.3
-
-
-# representable 2.0
-# 3.000000   0.020000   3.020000 (  3.013031) 2.7-3.0
-
-# no method missing
-# 2.280000   0.030000   2.310000 (  2.313522) 2.2-2.5
-# no def_delegator in Definition
-# 2.130000   0.010000   2.140000 (  2.136115) 1.7-2.1

data/test-with-deprecations/render_nil_test.rb

@@ -1,21 +0,0 @@
-require "test_helper"
-
-class RenderNilTest < MiniTest::Spec
-  Song = Struct.new(:title)
-
-  describe "render_nil: true" do
-    representer! do
-      property :title, render_nil: true
-    end
-
-    it { Song.new.extend(representer).to_hash.must_equal({"title"=>nil}) }
-  end
-
-  describe "with :extend it shouldn't extend nil" do
-    representer! do
-      property :title, render_nil: true, extend: Class
-    end
-
-    it { Song.new.extend(representer).to_hash.must_equal({"title"=>nil}) }
-  end
-end

data/test-with-deprecations/represent_test.rb

@@ -1,88 +0,0 @@
-require 'test_helper'
-
-class RepresentTest < MiniTest::Spec
-  let (:songs) { [song, Song.new("Can't Take Them All")] }
-  let (:song) { Song.new("Days Go By") }
-
-  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|
-
-    # Representer.represents detects collection.
-    describe "Module#to_/from_#{format}" do
-      let (:format) { format }
-
-      let (:representer) {
-        Module.new do
-          include mod
-          property :name
-
-          collection_representer :class => Song # TODOOOOOOOOOOOO: test without Song and fix THIS FUCKINGNoMethodError: undefined method `name=' for {"name"=>"Days Go By"}:Hash ERROR!!!!!!!!!!!!!!!
-        end
-      }
-
-      it { render(representer.represent(songs)).must_equal_document output }
-      it { parse(representer.represent([]), input).must_equal songs }
-    end
-
-    # Decorator.represents detects collection.
-    describe "Decorator#to_/from_#{format}" do
-      let (:format) { format }
-      let (:representer) {
-        Class.new(Representable::Decorator) do
-          include mod
-          property :name
-
-          collection_representer :class => Song
-        end
-      }
-
-      it { render(representer.represent(songs)).must_equal_document output }
-      it("ficken") { parse(representer.represent([]), input).must_equal songs }
-    end
-  end
-
-
-  for_formats(
-    :hash => [Representable::Hash, out={"name" => "Days Go By"}, out],
-    :json => [Representable::JSON, out="{\"name\":\"Days Go By\"}", out],
-    # :xml  => [Representable::XML,  out="<a><song></song><song></song></a>", out]
-  ) do |format, mod, output, input|
-
-    # Representer.represents detects singular.
-    describe "Module#to_/from_#{format}" do
-      let (:format) { format }
-
-      let (:representer) {
-        Module.new do
-          include mod
-          property :name
-
-          collection_representer :class => Song
-        end
-      }
-
-      it { render(representer.represent(song)).must_equal_document output }
-      it { parse(representer.represent(Song.new), input).must_equal song }
-    end
-
-
-    # Decorator.represents detects singular.
-    describe "Decorator#to_/from_#{format}" do
-      let (:format) { format }
-      let (:representer) {
-        Class.new(Representable::Decorator) do
-          include mod
-          property :name
-
-          collection_representer :class => Song
-        end
-      }
-
-      it { render(representer.represent(song)).must_equal_document output }
-      it { parse(representer.represent(Song.new), input).must_equal song }
-    end
-  end
-end

data/test-with-deprecations/representable_test.rb

@@ -1,511 +0,0 @@
-require 'test_helper'
-
-class RepresentableTest < MiniTest::Spec
-  class Band
-    include Representable::Hash
-    property :name
-    attr_accessor :name
-  end
-
-  class PunkBand < Band
-    property :street_cred
-    attr_accessor :street_cred
-  end
-
-  module BandRepresentation
-    include Representable
-
-    property :name
-  end
-
-  module PunkBandRepresentation
-    include Representable
-    include BandRepresentation
-
-    property :street_cred
-  end
-
-
-  describe "#representable_attrs" do
-    describe "in module" do
-      it "allows including the concrete representer module later" do
-        vd = class VD
-          attr_accessor :name, :street_cred
-          include Representable::JSON
-          include PunkBandRepresentation
-        end.new
-        vd.name        = "Vention Dention"
-        vd.street_cred = 1
-        assert_json "{\"name\":\"Vention Dention\",\"street_cred\":1}", vd.to_json
-      end
-
-      #it "allows including the concrete representer module only" do
-      #  require 'representable/json'
-      #  module RockBandRepresentation
-      #    include Representable::JSON
-      #    property :name
-      #  end
-      #  vd = class VH
-      #    include RockBandRepresentation
-      #  end.new
-      #  vd.name        = "Van Halen"
-      #  assert_equal "{\"name\":\"Van Halen\"}", vd.to_json
-      #end
-    end
-  end
-
-
-  describe "inheritance" do
-    class CoverSong < OpenStruct
-    end
-
-    module SongRepresenter
-      include Representable::Hash
-      property :name
-    end
-
-    module CoverSongRepresenter
-      include Representable::Hash
-      include SongRepresenter
-      property :by
-    end
-
-    it "merges properties from all ancestors" do
-      props = {"name"=>"The Brews", "by"=>"Nofx"}
-      assert_equal(props, CoverSong.new(props).extend(CoverSongRepresenter).to_hash)
-    end
-
-    it "allows mixing in multiple representers" do
-      require 'representable/json'
-      require 'representable/xml'
-      class Bodyjar
-        include Representable::XML
-        include Representable::JSON
-        include PunkBandRepresentation
-
-        self.representation_wrap = "band"
-        attr_accessor :name, :street_cred
-      end
-
-      band = Bodyjar.new
-      band.name = "Bodyjar"
-
-      assert_json "{\"band\":{\"name\":\"Bodyjar\"}}", band.to_json
-      assert_xml_equal "<band><name>Bodyjar</name></band>", band.to_xml
-    end
-
-    it "allows extending with different representers subsequentially" do
-      module SongXmlRepresenter
-        include Representable::XML
-        property :name, :as => "name", :attribute => true
-      end
-
-      module SongJsonRepresenter
-        include Representable::JSON
-        property :name
-      end
-
-      @song = Song.new("Days Go By")
-      assert_xml_equal "<song name=\"Days Go By\"/>", @song.extend(SongXmlRepresenter).to_xml
-      assert_json "{\"name\":\"Days Go By\"}", @song.extend(SongJsonRepresenter).to_json
-    end
-
-
-    # test if we call super in
-    #   ::inherited
-    #   ::included
-    #   ::extended
-    module Representer
-      include Representable # overrides ::inherited.
-    end
-
-    class BaseClass
-      def self.inherited(subclass)
-        super
-        subclass.instance_eval { def other; end }
-      end
-
-      include Representable # overrides ::inherited.
-      include Representer
-    end
-
-    class SubClass < BaseClass # triggers Representable::inherited, then OtherModule::inherited.
-    end
-
-    # test ::inherited.
-    it do
-      BaseClass.respond_to?(:other).must_equal false
-      SubClass.respond_to?(:other).must_equal true
-    end
-
-    module DifferentIncluded
-      def included(includer)
-        includer.instance_eval { def different; end }
-      end
-    end
-
-    module CombinedIncluded
-      extend DifferentIncluded # defines ::included.
-      include Representable    # overrides ::included.
-    end
-
-    class IncludingClass
-      include Representable
-      include CombinedIncluded
-    end
-
-    # test ::included.
-    it do
-      IncludingClass.respond_to?(:representable_attrs) # from Representable
-      IncludingClass.respond_to?(:different)
-    end
-  end
-
-
-  describe "#property" do
-    it "doesn't modify options hash" do
-      options = {}
-      representer.property(:title, options)
-      options.must_equal({})
-    end
-
-    representer! {}
-
-    it "returns the Definition instance" do
-      representer.property(:name).must_be_kind_of Representable::Definition
-    end
-  end
-
-  describe "#collection" do
-    class RockBand < Band
-      collection :albums
-    end
-
-    it "creates correct Definition" do
-      assert_equal "albums", RockBand.representable_attrs.get(:albums).name
-      assert RockBand.representable_attrs.get(:albums).array?
-    end
-  end
-
-  describe "#hash" do
-    it "also responds to the original method" do
-      assert_kind_of Integer, BandRepresentation.hash
-    end
-  end
-
-  class Hometown
-    attr_accessor :name
-  end
-
-  module HometownRepresentable
-    include Representable::JSON
-    property :name
-  end
-
-  # DISCUSS: i don't like the JSON requirement here, what about some generic test module?
-  class PopBand
-    include Representable::JSON
-    property :name
-    property :groupies
-    property :hometown, class: Hometown, extend: HometownRepresentable
-    attr_accessor :name, :groupies, :hometown
-  end
-
-  describe "#update_properties_from" do
-    before do
-      @band = PopBand.new
-    end
-
-    it "copies values from document to object" do
-      @band.from_hash({"name"=>"No One's Choice", "groupies"=>2})
-      assert_equal "No One's Choice", @band.name
-      assert_equal 2, @band.groupies
-    end
-
-    it "ignores non-writeable properties" do
-      @band = Class.new(Band) { property :name; collection :founders, :writeable => false; attr_accessor :founders }.new
-      @band.from_hash("name" => "Iron Maiden", "groupies" => 2, "founders" => ["Steve Harris"])
-      assert_equal "Iron Maiden", @band.name
-      assert_equal nil, @band.founders
-    end
-
-    it "always returns the represented" do
-      assert_equal @band, @band.from_hash({"name"=>"Nofx"})
-    end
-
-    it "includes false attributes" do
-      @band.from_hash({"groupies"=>false})
-      assert_equal false, @band.groupies
-    end
-
-    it "ignores properties not present in the incoming document" do
-      @band.instance_eval do
-        def name=(*); raise "I should never be called!"; end
-      end
-      @band.from_hash({})
-    end
-
-
-    # FIXME: do we need this test with XML _and_ JSON?
-    it "ignores (no-default) properties not present in the incoming document" do
-      { Representable::Hash => [:from_hash, {}],
-        Representable::XML  => [:from_xml,  xml(%{<band/>}).to_s]
-      }.each do |format, config|
-        nested_repr = Module.new do # this module is never applied. # FIXME: can we make that a simpler test?
-          include format
-          property :created_at
-        end
-
-        repr = Module.new do
-          include format
-          property :name, :class => Object, :extend => nested_repr
-        end
-
-        @band = Band.new.extend(repr)
-        @band.send(config.first, config.last)
-        assert_equal nil, @band.name, "Failed in #{format}"
-      end
-    end
-
-    describe "passing options" do
-      module TrackRepresenter
-        include Representable::Hash
-
-      end
-
-      representer! do
-        property :track, class: OpenStruct do
-          property :nr
-
-          property :length, class: OpenStruct do
-            def to_hash(options)
-              {seconds: options[:user_options][:nr]}
-            end
-
-            def from_hash(hash, options)
-              super.tap do
-                self.seconds = options[:user_options][:nr]
-              end
-            end
-          end
-
-          def to_hash(options)
-            super.merge({"nr" => options[:user_options][:nr]})
-          end
-
-          def from_hash(data, options)
-            super.tap do
-              self.nr = options[:user_options][:nr]
-            end
-          end
-        end
-      end
-
-      it "#to_hash propagates to nested objects" do
-        OpenStruct.new(track: OpenStruct.new(nr: 1, length: OpenStruct.new(seconds: nil))).extend(representer).extend(Representable::Debug).
-          to_hash(nr: 9).must_equal({"track"=>{"nr"=>9, "length"=>{seconds: 9}}})
-      end
-
-      it "#from_hash propagates to nested objects" do
-        song = OpenStruct.new.extend(representer).from_hash({"track"=>{"nr" => "replace me", "length"=>{"seconds"=>"replacing"}}}, :nr => 9)
-        song.track.nr.must_equal 9
-        song.track.length.seconds.must_equal 9
-      end
-    end
-  end
-
-  describe "#create_representation_with" do
-    before do
-      @band = PopBand.new
-      @band.name = "No One's Choice"
-      @band.groupies = 2
-    end
-
-    it "compiles document from properties in object" do
-      assert_equal({"name"=>"No One's Choice", "groupies"=>2}, @band.to_hash)
-    end
-
-    it "ignores non-readable properties" do
-      @band = Class.new(Band) { property :name; collection :founder_ids, :readable => false; attr_accessor :founder_ids }.new
-      @band.name = "Iron Maiden"
-      @band.founder_ids = [1,2,3]
-
-      hash = @band.to_hash
-      assert_equal({"name" => "Iron Maiden"}, hash)
-    end
-
-    it "does not write nil attributes" do
-      @band.groupies = nil
-      assert_equal({"name"=>"No One's Choice"}, @band.to_hash)
-    end
-
-    it "writes false attributes" do
-      @band.groupies = false
-      assert_equal({"name"=>"No One's Choice","groupies"=>false}, @band.to_hash)
-    end
-  end
-
-
-  describe ":extend and :class" do
-    module UpcaseRepresenter
-      include Representable
-      def to_hash(*); upcase; end
-      def from_hash(hsh, *args); replace hsh.upcase; end   # DISCUSS: from_hash must return self.
-    end
-    module DowncaseRepresenter
-      include Representable
-      def to_hash(*); downcase; end
-      def from_hash(hsh, *args); replace hsh.downcase; end
-    end
-    class UpcaseString < String; end
-
-
-    describe "lambda blocks" do
-      representer! do
-        property :name, :extend => lambda { |name, *| compute_representer(name) }
-      end
-
-      it "executes lambda in represented instance context" do
-        Song.new("Carnage").instance_eval do
-          def compute_representer(name)
-            UpcaseRepresenter
-          end
-          self
-        end.extend(representer).to_hash.must_equal({"name" => "CARNAGE"})
-      end
-    end
-
-    describe ":instance" do
-      obj = String.new("Fate")
-      mod = Module.new { include Representable; def from_hash(*); self; end }
-      representer! do
-        property :name, :extend => mod, :instance => lambda { |*| obj }
-      end
-
-      it "uses object from :instance but still extends it" do
-        song = Song.new.extend(representer).from_hash("name" => "Eric's Had A Bad Day")
-        song.name.must_equal obj
-        song.name.must_be_kind_of mod
-      end
-    end
-
-    describe "property with :extend" do
-      representer! do
-        property :name, :extend => lambda { |name, *| name.is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter }, :class => String
-      end
-
-      it "uses lambda when rendering" do
-        assert_equal({"name" => "you make me thick"}, Song.new("You Make Me Thick").extend(representer).to_hash )
-        assert_equal({"name" => "STEPSTRANGER"}, Song.new(UpcaseString.new "Stepstranger").extend(representer).to_hash )
-      end
-
-      it "uses lambda when parsing" do
-        Song.new.extend(representer).from_hash({"name" => "You Make Me Thick"}).name.must_equal "you make me thick"
-        Song.new.extend(representer).from_hash({"name" => "Stepstranger"}).name.must_equal "stepstranger" # DISCUSS: we compare "".is_a?(UpcaseString)
-      end
-
-      describe "with :class lambda" do
-        representer! do
-          property :name, :extend => lambda { |name, *| name.is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter },
-                          :class  => lambda { |fragment, *| fragment == "Still Failing?" ? String : UpcaseString }
-        end
-
-        it "creates instance from :class lambda when parsing" do
-          song = OpenStruct.new.extend(representer).from_hash({"name" => "Quitters Never Win"})
-          song.name.must_be_kind_of UpcaseString
-          song.name.must_equal "QUITTERS NEVER WIN"
-
-          song = OpenStruct.new.extend(representer).from_hash({"name" => "Still Failing?"})
-          song.name.must_be_kind_of String
-          song.name.must_equal "still failing?"
-        end
-      end
-    end
-
-
-    describe "collection with :extend" do
-      representer! do
-        collection :songs, :extend => lambda { |name, *| name.is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter }, :class => String
-      end
-
-      it "uses lambda for each item when rendering" do
-        Album.new([UpcaseString.new("Dean Martin"), "Charlie Still Smirks"]).extend(representer).to_hash.must_equal("songs"=>["DEAN MARTIN", "charlie still smirks"])
-      end
-
-      it "uses lambda for each item when parsing" do
-        album = Album.new.extend(representer).from_hash("songs"=>["DEAN MARTIN", "charlie still smirks"])
-        album.songs.must_equal ["dean martin", "charlie still smirks"] # DISCUSS: we compare "".is_a?(UpcaseString)
-      end
-
-      describe "with :class lambda" do
-        representer! do
-          collection :songs,  :extend => lambda { |name, *| name.is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter },
-                              :class  => lambda { |fragment, *| fragment == "Still Failing?" ? String : UpcaseString }
-        end
-
-        it "creates instance from :class lambda for each item when parsing" do
-          album = Album.new.extend(representer).from_hash("songs"=>["Still Failing?", "charlie still smirks"])
-          album.songs.must_equal ["still failing?", "CHARLIE STILL SMIRKS"]
-        end
-      end
-    end
-
-    describe ":decorator" do
-      let (:extend_rpr) { Module.new { include Representable::Hash; collection :songs, :extend => SongRepresenter } }
-      let (:decorator_rpr) { Module.new { include Representable::Hash; collection :songs, :decorator => SongRepresenter } }
-      let (:songs) { [Song.new("Bloody Mary")] }
-
-      it "is aliased to :extend" do
-        Album.new(songs).extend(extend_rpr).to_hash.must_equal Album.new(songs).extend(decorator_rpr).to_hash
-      end
-    end
-
-    describe ":binding" do
-      representer! do
-        class MyBinding < Representable::Binding
-          def write(doc, *args)
-            doc[:title] = represented.title
-          end
-        end
-        property :title, :binding => lambda { |*args| MyBinding.new(*args) }
-      end
-
-      it "uses the specified binding instance" do
-        OpenStruct.new(:title => "Affliction").extend(representer).to_hash.must_equal({:title => "Affliction"})
-      end
-    end
-
-
-    # TODO: Move to global place since it's used twice.
-    class SongRepresentation < Representable::Decorator
-      include Representable::JSON
-      property :name
-    end
-    class AlbumRepresentation < Representable::Decorator
-      include Representable::JSON
-
-      collection :songs, :class => Song, :extend => SongRepresentation
-    end
-
-    describe "::prepare" do
-      let (:song) { Song.new("Still Friends In The End") }
-      let (:album) { Album.new([song]) }
-
-      describe "module including Representable" do
-        it "uses :extend strategy" do
-          album_rpr = Module.new { include Representable::Hash; collection :songs, :class => Song, :extend => SongRepresenter}
-
-          album_rpr.prepare(album).to_hash.must_equal({"songs"=>[{"name"=>"Still Friends In The End"}]})
-          album.must_respond_to :to_hash
-        end
-      end
-
-      describe "Decorator subclass" do
-        it "uses :decorate strategy" do
-          AlbumRepresentation.prepare(album).to_hash.must_equal({"songs"=>[{"name"=>"Still Friends In The End"}]})
-          album.wont_respond_to :to_hash
-        end
-      end
-    end
-  end
-end