representable 2.4.0.rc3 → 2.4.0.rc4

data/test-with-deprecations/schema_test.rb

@@ -0,0 +1,148 @@
+require 'test_helper'
+
+# Include Inherit Module And Decorator Test
+class SchemaTest < MiniTest::Spec
+  module Genre
+    include Representable
+    property :genre
+  end
+
+  module LinkFeature
+    def self.included(base)
+      base.extend(Link)
+    end
+
+    module Link
+      def link
+      end
+    end
+  end
+
+
+  module Module
+    include Representable::Hash
+    feature LinkFeature
+
+    property :title
+    property :label do # extend: LabelModule
+      property :name
+      link # feature
+
+      property :location do
+        property :city
+        link # feature.
+      end
+    end
+
+    property :album, :extend => lambda { raise "don't manifest me!" } # this is not an inline decorator, don't manifest it.
+
+
+    include Genre # Schema::Included::included is called!
+  end
+
+
+  class WithLocationStreetRepresenter < Representable::Decorator
+    include Representable::Hash
+    feature LinkFeature
+
+    property :title
+    property :label do # extend: LabelModule
+      property :name
+      link # feature
+
+      property :location do
+        property :city
+        link # feature.
+      end
+    end
+  end
+
+  describe "3-level deep with features" do
+    let (:label) { OpenStruct.new(:name => "Epitaph", :location => OpenStruct.new(:city => "Sanfran", :name => "DON'T SHOW ME!")) }
+
+    # Module does correctly include features in inlines.
+    it { band.extend(Module).to_hash.must_equal({"label"=>{"name"=>"Epitaph", "location"=>{"city"=>"Sanfran"}}, "genre"=>"Punkrock"}) }
+
+    # Decorator does correctly include features in inlines.
+    it { Decorator.new(band).to_hash.must_equal({"label"=>{"name"=>"Epitaph", "location"=>{"city"=>"Sanfran"}}, "genre"=>"Punkrock"}) }
+  end
+
+
+
+  class Decorator < Representable::Decorator
+    feature Representable::Hash
+
+    include Module
+  end
+
+  # puts Decorator.representable_attrs[:definitions].inspect
+
+  let (:label) { OpenStruct.new(:name => "Fat Wreck", :city => "San Francisco", :employees => [OpenStruct.new(:name => "Mike")], :location => OpenStruct.new(:city => "Sanfran")) }
+  let (:band) { OpenStruct.new(:genre => "Punkrock", :label => label) }
+
+
+  # it { FlatlinersDecorator.new( OpenStruct.new(label: OpenStruct.new) ).
+  #   to_hash.must_equal({}) }
+  it do
+    Decorator.new(band).to_hash.must_equal({"genre"=>"Punkrock", "label"=>{"name"=>"Fat Wreck", "location"=>{"city"=>"Sanfran"}}})
+  end
+
+
+  class InheritDecorator < Representable::Decorator
+    include Representable::Hash
+
+    include Module
+
+    property :label, inherit: true do # decorator.rb:27:in `initialize': superclass must be a Class (Module given)
+      property :city
+
+      property :location, :inherit => true do
+        property :city
+      end
+    end
+  end
+
+  it do
+    InheritDecorator.new(band).to_hash.must_equal({"genre"=>"Punkrock", "label"=>{"name"=>"Fat Wreck", "city"=>"San Francisco", "location"=>{"city"=>"Sanfran"}}})
+  end
+
+
+
+  class InheritFromDecorator < InheritDecorator
+    property :label, inherit: true do
+      collection :employees do
+        property :name
+      end
+    end
+  end
+
+  require "pp"
+  pp InheritFromDecorator.representable_attrs.get(:label)[:extend].(nil).representable_attrs
+
+  it do
+    InheritFromDecorator.new(band).to_hash.must_equal({"genre"=>"Punkrock", "label"=>{"name"=>"Fat Wreck", "city"=>"San Francisco", "employees"=>[{"name"=>"Mike"}], "location"=>{"city"=>"Sanfran"}}})
+  end
+end
+
+
+class ApplyTest < MiniTest::Spec
+  class AlbumDecorator < Representable::Decorator
+    include Representable::Hash
+
+    property :title
+
+    property :hit do
+      property :title
+    end
+
+    collection :songs do
+      property :title
+    end
+
+    property :band do # yepp, people do crazy stuff like that.
+      property :label do
+        property :name
+      end
+    end
+  end
+end

data/test-with-deprecations/serialize_deserialize_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+class SerializeDeserializeTest < BaseTest
+  subject { Struct.new(:song).new.extend(representer) }
+
+  describe "deserialize" do
+    representer! do
+      property :song,
+        :instance => lambda { |fragment, *| fragment.to_s.upcase },
+        :prepare  => lambda { |fragment, *| fragment },
+        :deserialize => lambda { |object, fragment, args|
+          "#{object} #{fragment} #{args.inspect}"
+        }
+    end
+
+    it { subject.from_hash({"song" => Object}, {:volume => 9}).song.must_equal "OBJECT Object {:volume=>9}" }
+  end
+
+  describe "serialize" do
+    representer! do
+      property :song,
+        :representable => true,
+        :prepare  => lambda { |fragment, *| fragment },
+        :serialize => lambda { |object, args|
+          "#{object} #{args.inspect}"
+        }
+    end
+
+    before { subject.song = "Arrested In Shanghai" }
+
+    it { subject.to_hash({:volume => 9}).must_equal({"song"=>"Arrested In Shanghai {:volume=>9}"}) }
+  end
+end

data/test-with-deprecations/skip_test.rb

@@ -0,0 +1,81 @@
+require 'test_helper'
+
+class SkipParseTest < MiniTest::Spec
+  representer! do
+    property :title, skip_parse: lambda { |fragment, opts| opts[:skip?] and fragment == "skip me" }
+    property :band,
+      skip_parse: lambda { |fragment, opts| opts[:skip?] and fragment["name"].nil? }, class: OpenStruct do
+        property :name
+    end
+
+    collection :airplays,
+      skip_parse: lambda { |fragment, opts| opts[:skip?] and fragment["station"].nil? }, class: OpenStruct do
+        property :station
+    end
+  end
+
+  let (:song) { OpenStruct.new.extend(representer) }
+
+  # do parse.
+  it do
+    song.from_hash({
+      "title"    => "Victim Of Fate",
+      "band"     => {"name" => "Mute 98"},
+      "airplays" => [{"station" => "JJJ"}]
+    }, skip?: true)
+
+    song.title.must_equal "Victim Of Fate"
+    song.band.name.must_equal "Mute 98"
+    song.airplays[0].station.must_equal "JJJ"
+  end
+
+  # skip parsing.
+  let (:airplay) { OpenStruct.new(station: "JJJ") }
+
+  it do
+    song.from_hash({
+      "title"    => "skip me",
+      "band"     => {},
+      "airplays" => [{"station" => "JJJ"}, {}],
+    }, skip?: true)
+
+    song.title.must_equal nil
+    song.band.must_equal nil
+    song.airplays.must_equal [airplay]
+  end
+end
+
+class SkipRenderTest < MiniTest::Spec
+  representer! do
+    property :title
+    property :band,
+      skip_render: lambda { |object, opts| opts[:skip?] and object.name == "Rancid" } do
+        property :name
+    end
+
+    collection :airplays,
+      skip_render: lambda { |object, opts| puts object.inspect; opts[:skip?] and object.station == "Radio Dreyeckland" } do
+        property :station
+    end
+  end
+
+  let (:song)      { OpenStruct.new(title: "Black Night", band: OpenStruct.new(name: "Time Again")).extend(representer) }
+  let (:skip_song) { OpenStruct.new(title: "Time Bomb",   band: OpenStruct.new(name: "Rancid")).extend(representer) }
+
+  # do render.
+  it { song.to_hash(skip?: true).must_equal({"title"=>"Black Night", "band"=>{"name"=>"Time Again"}}) }
+  # skip.
+  it { skip_song.to_hash(skip?: true).must_equal({"title"=>"Time Bomb"}) }
+
+  # do render all collection items.
+  it do
+    song = OpenStruct.new(airplays: [OpenStruct.new(station: "JJJ"), OpenStruct.new(station: "ABC")]).extend(representer)
+    song.to_hash(skip?: true).must_equal({"airplays"=>[{"station"=>"JJJ"}, {"station"=>"ABC"}]})
+  end
+
+  # skip middle item.
+  it do
+    song = OpenStruct.new(airplays: [OpenStruct.new(station: "JJJ"), OpenStruct.new(station: "Radio Dreyeckland"), OpenStruct.new(station: "ABC")]).extend(representer)
+    song.to_hash(skip?: true).must_equal({"airplays"=>[{"station"=>"JJJ"}, {"station"=>"ABC"}]})
+  end
+end

data/test-with-deprecations/stringify_hash_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+class StringifyHashTest < MiniTest::Spec
+describe "#from_hash" do
+  representer!(:name => :song_representer) do
+
+    include Representable::Hash
+    include Representable::Hash::AllowSymbols
+
+    property :title
+  end
+
+  representer!(:inject => :song_representer) do
+    include Representable::Hash::AllowSymbols
+
+    property :song, :extend => song_representer, :class => OpenStruct
+   end
+
+   it "parses symbols, too" do
+     OpenStruct.new.extend(representer).from_hash({:song => {:title => "Der Optimist"}}).song.title.must_equal "Der Optimist"
+   end
+
+   it "still parses strings" do
+     OpenStruct.new.extend(representer).from_hash({"song" => {"title" => "Der Optimist"}}).song.title.must_equal "Der Optimist"
+   end
+
+   describe "with :wrap" do
+    representer!(:inject => :song_representer) do
+      include Representable::Hash::AllowSymbols
+
+      self.representation_wrap = :album
+      property :song, :extend => song_representer, :class => OpenStruct
+    end
+
+     it "parses symbols, too" do
+       OpenStruct.new.extend(representer).from_hash({:album => {:song => {:title => "Der Optimist"}}}).song.title.must_equal "Der Optimist"
+     end
+   end
+ end
+
+end

data/test-with-deprecations/test_helper.rb

@@ -0,0 +1,135 @@
+require 'representable'
+
+require "json"
+require "psych"
+
+require 'representable/json'
+require 'representable/xml'
+require 'representable/yaml'
+require 'minitest/autorun'
+require 'test_xml/mini_test'
+
+require "representable/debug"
+
+class Album
+  attr_accessor :songs, :best_song
+  def initialize(songs=nil, best_song=nil)
+    @songs      = songs
+    @best_song  = best_song
+  end
+
+  def ==(other)
+    songs == other.songs and best_song == other.best_song
+  end
+end
+
+class Song
+  attr_accessor :name, :track # never change this, track rendered with Rails#to_json.
+  def initialize(name=nil, track=nil)
+    @name   = name
+    @track  = track
+  end
+
+  def ==(other)
+    name == other.name and track == other.track
+  end
+end
+
+module XmlHelper
+  def xml(document)
+    Nokogiri::XML(document).root
+  end
+end
+
+module AssertJson
+  module Assertions
+    def assert_json(expected, actual, msg=nil)
+      msg = message(msg, "") { diff expected, actual }
+      assert(expected.split("").sort == actual.split("").sort, msg)
+    end
+  end
+end
+
+MiniTest::Spec.class_eval do
+  include AssertJson::Assertions
+  include XmlHelper
+
+  def self.for_formats(formats)
+    formats.each do |format, cfg|
+      mod, output, input = cfg
+      yield format, mod, output, input
+    end
+  end
+
+  def render(object, *args)
+    AssertableDocument.new(object.send("to_#{format}", *args), format)
+  end
+
+  def parse(object, input, *args)
+    object.send("from_#{format}", input, *args)
+  end
+
+  class AssertableDocument
+    attr_reader :document
+
+    def initialize(document, format)
+      @document, @format = document, format
+    end
+
+    def must_equal_document(*args)
+      return document.must_equal_xml(*args) if @format == :xml
+      document.must_equal(*args)
+    end
+  end
+
+  def self.representer!(options={}, &block)
+    fmt = options # we need that so the 2nd call to ::let (within a ::describe) remembers the right format.
+
+    name   = options[:name]   || :representer
+    format = options[:module] || Representable::Hash
+
+    let(name) do
+      mod = options[:decorator] ? Class.new(Representable::Decorator) : Module.new
+
+      inject_representer(mod, fmt)
+
+      mod.module_eval do
+        include format
+        instance_exec(&block)
+      end
+
+      mod
+    end
+
+    def inject_representer(mod, options)
+      return unless options[:inject]
+
+      injected_name = options[:inject]
+      injected = send(injected_name) # song_representer
+      mod.singleton_class.instance_eval do
+        define_method(injected_name) { injected }
+      end
+    end
+  end
+
+  module TestMethods
+    def representer_for(modules=[Representable::Hash], &block)
+      Module.new do
+        extend TestMethods
+        include *modules
+        module_exec(&block)
+      end
+    end
+
+    alias_method :representer!, :representer_for
+  end
+  include TestMethods
+end
+
+class BaseTest < MiniTest::Spec
+  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  }
+
+end

data/test-with-deprecations/test_helper_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class TestHelperTest < MiniTest::Spec
+  describe "#assert_json" do
+    it "tests for equality" do
+      assert_json "{\"songs\":{\"one\":\"65\",\"two\":\"Emo Boy\"}}", "{\"songs\":{\"one\":\"65\",\"two\":\"Emo Boy\"}}"
+    end
+    
+    it "allows different key orders" do
+      assert_json "{\"songs\":{\"one\":\"65\",\"two\":\"Emo Boy\"}}", "{\"songs\":{\"two\":\"Emo Boy\",\"one\":\"65\"}}"
+    end
+    
+    it "complains when expected hash is subset" do
+      assert_raises MiniTest::Assertion do
+        assert_json "{\"songs\":{\"one\":\"65\"}}", "{\"songs\":{\"two\":\"Emo Boy\",\"one\":\"65\"}}"
+      end
+    end
+    
+    it "complains when source hash is subset" do
+      assert_raises MiniTest::Assertion do
+        assert_json "{\"songs\":{\"two\":\"Emo Boy\",\"one\":\"65\"}}", "{\"songs\":{\"one\":\"65\"}}"
+      end
+    end
+  end
+end