representable 2.4.1 → 3.0.0

data/test-with-deprecations/schema_test.rb

@@ -1,148 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,135 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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