representable 2.4.0.rc3 → 2.4.0.rc4

data/test-with-deprecations/defaults_options_test.rb

@@ -0,0 +1,93 @@
+require 'test_helper'
+
+class DefaultsOptionsTest < BaseTest
+  let (:format) { :hash }
+  let (:song) { Struct.new(:title, :author_name, :song_volume, :description).new("Revolution", "Some author", 20, nil) }
+  let (:prepared) { representer.prepare song }
+
+  describe "hash options combined with dynamic options" do
+    representer! do
+      defaults render_nil: true do |name|
+        { as: name.to_s.upcase }
+      end
+
+      property :title
+      property :author_name
+      property :description
+      property :song_volume
+    end
+
+    it { render(prepared).must_equal_document({"TITLE" => "Revolution", "AUTHOR_NAME" => "Some author", "DESCRIPTION" => nil, "SONG_VOLUME" => 20}) }
+  end
+
+  describe "with only dynamic property options" do
+    representer! do
+      defaults do |name|
+        { as: name.to_s.upcase }
+      end
+
+      property :title
+      property :author_name
+      property :description
+      property :song_volume
+    end
+
+    it { render(prepared).must_equal_document({"TITLE" => "Revolution", "AUTHOR_NAME" => "Some author", "SONG_VOLUME" => 20}) }
+  end
+
+  describe "with only hashes" do
+    representer! do
+      defaults render_nil: true
+
+      property :title
+      property :author_name
+      property :description
+      property :song_volume
+    end
+
+    it { render(prepared).must_equal_document({"title" => "Revolution", "author_name" => "Some author", "description" => nil, "song_volume" => 20}) }
+  end
+
+  describe "direct defaults hash" do
+    representer! do
+      defaults render_nil: true
+
+      property :title
+      property :author_name
+      property :description
+      property :song_volume
+    end
+
+    it { render(prepared).must_equal_document({"title" => "Revolution", "author_name" => "Some author", "description" => nil, "song_volume" => 20}) }
+  end
+
+  describe "direct defaults hash with dynamic options" do
+    representer! do
+      defaults render_nil: true do |name|
+        { as: name.to_s.upcase }
+      end
+
+      property :title
+      property :author_name
+      property :description
+      property :song_volume
+    end
+
+    it { render(prepared).must_equal_document({"TITLE" => "Revolution", "AUTHOR_NAME" => "Some author", "DESCRIPTION" => nil, "SONG_VOLUME" => 20}) }
+  end
+
+  describe "prioritizes specific options" do
+    representer! do
+      defaults render_nil: true do |name|
+        { as: name.to_s.upcase }
+      end
+
+      property :title
+      property :author_name
+      property :description, render_nil: false
+      property :song_volume, as: :volume
+    end
+
+    it { render(prepared).must_equal_document({"TITLE" => "Revolution", "AUTHOR_NAME" => "Some author", "volume" => 20}) }
+  end
+end

data/test-with-deprecations/definition_test.rb

@@ -0,0 +1,264 @@
+require 'test_helper'
+
+class DefinitionTest < MiniTest::Spec
+  Definition = Representable::Definition
+
+  # 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 nil
+        options[:extend].must_equal Module
+      end
+      definition.name.must_equal "song"
+
+      #
+      definition[:awesome].must_equal true
+      definition[:parse_filter].must_equal Representable::Pipeline[1]
+      definition[:render_filter].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
+      definition.merge!(:parse_strategy => :sync)
+      definition[:setter].must_respond_to :evaluate
+    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].must_equal Representable::Pipeline[1]
+      definition[:parse_filter].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.must_be_kind_of Representable::Pipeline
+        merged.size.must_equal 2
+      end
+
+      # :parse_filter can also be array.
+      it { definition.merge!(:parse_filter => [2, 3])[:parse_filter].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
+
+
+  # delete!
+  describe "#delete!" do
+    let (:definition) { Definition.new(:song, serialize: "remove me!") }
+
+    before { definition[:serialize].evaluate(nil).must_equal "remove me!" }
+
+    it { definition.delete!(:serialize)[:serialize].must_equal nil }
+  end
+
+  # #inspect
+  describe "#inspect" do
+    it { Definition.new(:songs).inspect.must_equal "#<Representable::Definition ==>songs @options={:name=>\"songs\", :parse_filter=>[], :render_filter=>[]}>" }
+  end
+
+
+  describe "generic API" do
+    before do
+      @def = Representable::Definition.new(:songs)
+    end
+
+    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
+    end
+
+    describe "#typed?" do
+      it "is false per default" do
+        assert ! @def.typed?
+      end
+
+      it "is true when :class is present" do
+        assert Representable::Definition.new(:songs, :class => Hash).typed?
+      end
+
+      it "is true when :extend is present, only" do
+        assert Representable::Definition.new(:songs, :extend => Hash).typed?
+      end
+
+      it "is true when :instance is present, only" do
+        assert Representable::Definition.new(:songs, :instance => Object.new).typed?
+      end
+    end
+
+
+    describe "#representable?" do
+      it { assert Definition.new(:song, :representable => true).representable? }
+      it { Definition.new(:song, :representable => true, :extend => Object).representable?.must_equal true }
+      it { refute Definition.new(:song, :representable => false, :extend => Object).representable? }
+      it { assert Definition.new(:song, :extend => Object).representable? }
+      it { refute Definition.new(:song).representable? }
+    end
+
+
+    it "responds to #getter and returns string" do
+      assert_equal "songs", @def.getter
+    end
+
+    it "responds to #name" do
+      assert_equal "songs", @def.name
+    end
+
+    it "responds to #setter" do
+      assert_equal :"songs=", @def.setter
+    end
+
+    describe "nested: FIXME" do
+      it do
+        dfn = Representable::Definition.new(:songs, nested: Module)
+        assert dfn.typed?
+        dfn[:extend].(nil).must_equal Module
+      end
+    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
+    end
+  end
+
+  describe "#has_default?" do
+    it "returns false if no :default set" do
+      assert_equal false, Representable::Definition.new(:song).has_default?
+    end
+
+    it "returns true if :default set" do
+      assert_equal true, Representable::Definition.new(:song, :default => nil).has_default?
+    end
+  end
+
+
+  describe "#binding" do
+    it "returns true when :binding is set" do
+      assert Representable::Definition.new(:songs, :binding => Object)[:binding]
+    end
+
+    it "returns false when :binding is not set" do
+      assert !Representable::Definition.new(:songs)[:binding]
+    end
+  end
+
+  describe "#create_binding" do
+    it "executes the block (without special context)" do
+      definition = Representable::Definition.new(:title, :binding => lambda { |*args| @binding = Representable::Binding.new(*args) })
+      definition.create_binding.must_equal @binding
+    end
+  end
+
+  describe ":collection => true" do
+    before do
+      @def = Representable::Definition.new(:songs, :collection => true, :tag => :song)
+    end
+
+    it "responds to #array?" do
+      assert @def.array?
+    end
+  end
+
+
+  describe ":default => value" do
+    it "responds to #default" do
+      @def = Representable::Definition.new(:song)
+      assert_equal nil, @def[:default]
+    end
+
+    it "accepts a default value" do
+      @def = Representable::Definition.new(:song, :default => "Atheist Peace")
+      assert_equal "Atheist Peace", @def[:default]
+    end
+  end
+
+  describe ":hash => true" do
+    before do
+      @def = Representable::Definition.new(:songs, :hash => true)
+    end
+
+    it "responds to #hash?" do
+      assert @def.hash?
+      assert ! Representable::Definition.new(:songs).hash?
+    end
+  end
+
+  describe ":binding => Object" do
+    subject do
+      Representable::Definition.new(:songs, :binding => Object)
+    end
+
+    it "responds to #binding" do
+      assert_equal subject[:binding], Object
+    end
+  end
+
+  describe "#[]=" do
+    it "raises exception since it's deprecated" do
+      assert_raises NoMethodError do
+        Definition.new(:title)[:extend] = Module.new # use merge! after initialize.
+      end
+    end
+  end
+end

data/test-with-deprecations/example.rb

@@ -0,0 +1,310 @@
+require 'bundler'
+Bundler.setup
+
+require 'representable/yaml'
+require 'ostruct'
+
+def reset_representer(*module_name)
+  module_name.each do |mod|
+    mod.module_eval do
+      @representable_attrs = nil
+    end
+  end
+end
+
+class Song < OpenStruct
+end
+
+song = Song.new(:title => "Fallout", :track => 1)
+
+require 'representable/json'
+module SongRepresenter
+  include Representable::JSON
+
+  property :title
+  property :track
+end
+
+puts song.extend(SongRepresenter).to_json
+
+rox = Song.new.extend(SongRepresenter).from_json(%{ {"title":"Roxanne"} })
+puts rox.inspect
+
+module SongRepresenter
+  include Representable::JSON
+
+  self.representation_wrap= :hit
+
+  property :title
+  property :track
+end
+
+puts song.extend(SongRepresenter).to_json
+
+
+
+######### collections
+
+reset_representer(SongRepresenter)
+
+module SongRepresenter
+  include Representable::JSON
+
+  property :title
+  property :track
+  collection :composers
+end
+
+
+song = Song.new(:title => "Fallout", :composers => ["Stewart Copeland", "Sting"])
+puts song.extend(SongRepresenter).to_json
+
+
+######### nesting types
+
+class Album < OpenStruct
+  def name
+    puts @table.inspect
+    #@attributes
+    @table[:name]
+  end
+end
+
+module AlbumRepresenter
+  include Representable::JSON
+
+  property :name
+  property :song, :extend => SongRepresenter, :class => Song
+end
+
+album = Album.new(:name => "The Police", :song => song)
+puts album.extend(AlbumRepresenter).to_json
+
+reset_representer(AlbumRepresenter)
+
+module AlbumRepresenter
+  include Representable::JSON
+
+  property :name
+  collection :songs, :extend => SongRepresenter, :class => Song
+end
+
+album = Album.new(:name => "The Police", :songs => [song, Song.new(:title => "Synchronicity")])
+puts album.extend(AlbumRepresenter).to_json
+
+
+album = Album.new.extend(AlbumRepresenter).from_json(%{{"name":"Offspring","songs":[{"title":"Genocide"},{"title":"Nitro","composers":["Offspring"]}]}
+})
+puts album.inspect
+
+reset_representer(SongRepresenter)
+
+######### using helpers (customizing the rendering/parsing) 
+module AlbumRepresenter
+  include Representable::JSON
+
+  def name
+    super.upcase
+  end
+end
+
+puts Album.new(:name => "The Police").
+  extend(AlbumRepresenter).to_json
+
+reset_representer(SongRepresenter)
+
+
+######### inheritance
+module SongRepresenter
+  include Representable::JSON
+
+  property :title
+  property :track
+end
+
+module CoverSongRepresenter
+  include Representable::JSON
+  include SongRepresenter
+
+  property :covered_by
+end
+
+
+song = Song.new(:title => "Truth Hits Everybody", :covered_by => "No Use For A Name")
+puts song.extend(CoverSongRepresenter).to_json
+
+
+### XML
+require 'representable/xml'
+module SongRepresenter
+  include Representable::XML
+
+  property :title
+  property :track
+  collection :composers
+end
+song = Song.new(:title => "Fallout", :composers => ["Stewart Copeland", "Sting"])
+puts song.extend(SongRepresenter).to_xml
+
+reset_representer(SongRepresenter)
+
+
+### YAML
+require 'representable/yaml'
+module SongRepresenter
+  include Representable::YAML
+
+  property :title
+  property :track
+  collection :composers
+end
+puts song.extend(SongRepresenter).to_yaml
+
+
+SongRepresenter.module_eval do
+  @representable_attrs = nil
+end
+
+
+### YAML
+module SongRepresenter
+  include Representable::YAML
+
+  property :title
+  property :track
+  collection :composers, :style => :flow
+end
+puts song.extend(SongRepresenter).to_yaml
+
+SongRepresenter.module_eval do
+  @representable_attrs = nil
+end
+
+# R/W support
+song = Song.new(:title => "You're Wrong", :track => 4)
+module SongRepresenter
+  include Representable::Hash
+
+  property :title, :readable => false
+  property :track
+end
+puts song.extend(SongRepresenter).to_hash
+
+SongRepresenter.module_eval do
+  @representable_attrs = nil
+end
+
+module SongRepresenter
+  include Representable::Hash
+
+  property :title, :writeable => false
+  property :track
+end
+song = Song.new.extend(SongRepresenter)
+song.from_hash({:title => "Fallout", :track => 1})
+puts song
+
+######### custom methods in representer (using helpers)
+######### conditions
+######### :as
+######### XML::Collection
+######### polymorphic :extend and :class, instance context!, :instance
+class CoverSong < Song
+end
+
+songs = [Song.new(title: "Weirdo", track: 5), CoverSong.new(title: "Truth Hits Everybody", track: 6, copyright: "The Police")]
+album = Album.new(name: "Incognito", songs: songs)
+
+
+reset_representer(SongRepresenter, AlbumRepresenter)
+
+module SongRepresenter
+  include Representable::Hash
+
+  property :title
+  property :track
+end
+
+module CoverSongRepresenter
+  include Representable::Hash
+  include SongRepresenter
+
+  property :copyright
+end
+
+module AlbumRepresenter
+  include Representable::Hash
+
+  property :name
+  collection :songs, :extend => lambda { |song| song.is_a?(CoverSong) ? CoverSongRepresenter : SongRepresenter }
+end
+
+puts album.extend(AlbumRepresenter).to_hash
+
+reset_representer(AlbumRepresenter)
+
+module AlbumRepresenter
+  include Representable::Hash
+
+  property :name
+  collection :songs, 
+    :extend => lambda { |song| song.is_a?(CoverSong) ? CoverSongRepresenter : SongRepresenter },
+    :class  => lambda { |hsh| hsh.has_key?("copyright") ? CoverSong : Song } #=> {"title"=>"Weirdo", "track"=>5}
+end
+
+album = Album.new.extend(AlbumRepresenter).from_hash({"name"=>"Incognito", "songs"=>[{"title"=>"Weirdo", "track"=>5}, {"title"=>"Truth Hits Everybody", "track"=>6, "copyright"=>"The Police"}]})
+puts album.inspect
+
+reset_representer(AlbumRepresenter)
+
+module AlbumRepresenter
+  include Representable::Hash
+
+  property :name
+  collection :songs, 
+    :extend   => lambda { |song| song.is_a?(CoverSong) ? CoverSongRepresenter : SongRepresenter },
+    :instance => lambda { |hsh| hsh.has_key?("copyright") ? CoverSong.new : Song.new(original: true) }
+end
+
+album = Album.new.extend(AlbumRepresenter).from_hash({"name"=>"Incognito", "songs"=>[{"title"=>"Weirdo", "track"=>5}, {"title"=>"Truth Hits Everybody", "track"=>6, "copyright"=>"The Police"}]})
+puts album.inspect
+
+######### #hash
+
+reset_representer(SongRepresenter)
+
+module SongRepresenter
+  include Representable::JSON
+
+  property :title
+  hash :ratings
+end
+
+puts Song.new(title: "Bliss", ratings: {"Rolling Stone" => 4.9, "FryZine" => 4.5}).extend(SongRepresenter).to_json
+
+######### JSON::Hash
+
+module FavoriteSongsRepresenter
+  include Representable::JSON::Hash
+end
+
+puts( {"Nick" => "Hyper Music", "El" => "Blown In The Wind"}.extend(FavoriteSongsRepresenter).to_json)
+
+require 'representable/json/hash'
+module FavoriteSongsRepresenter
+  include Representable::JSON::Hash
+
+  values extend: SongRepresenter, class: Song
+end
+
+puts( {"Nick" => Song.new(title: "Hyper Music")}.extend(FavoriteSongsRepresenter).to_json)
+
+
+require 'representable/json/collection'
+module SongsRepresenter
+  include Representable::JSON::Collection
+
+  items extend: SongRepresenter, class: Song
+end
+
+puts [Song.new(title: "Hyper Music"), Song.new(title: "Screenager")].extend(SongsRepresenter).to_json