disposable 0.0.9 → 0.1.0

data/test/example.rb

@@ -0,0 +1,40 @@
+# run me with bundle exec ruby -Itest test/example.rb
+
+require "test_helper"
+
+ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+module Twin
+  class Album < Disposable::Twin
+    property :id # DISCUSS: needed for #save.
+    property :name
+    collection :songs, :twin => lambda { |*| Song }
+
+    extend Representer
+    include Setup
+    include Sync
+  end
+
+  class Song < Disposable::Twin
+    property :id # DISCUSS: needed for #save.
+    property :title
+    # property :album, :twin => Album
+
+    extend Representer
+    include Setup
+    include Sync
+  end
+end
+
+album = Album.last
+
+twin = Twin::Album.new(album)
+puts "existing songs (#{twin.songs.size}): #{twin.songs.inspect}"
+
+# this is what basically should happen in the representer, returning a Twin.
+twin.songs << Song.new
+twin.songs.last.title = "Back To Allentown"
+
+puts "new songs (#{twin.songs.size}): #{twin.songs.inspect}"
+
+twin.sync

data/test/expose_test.rb

@@ -0,0 +1,92 @@
+require "test_helper"
+require "disposable/expose"
+require "disposable/composition"
+
+# Disposable::Expose.
+class ExposeTest < MiniTest::Spec
+  module Model
+    Album = Struct.new(:id, :name)
+  end
+
+  module Twin
+    class Album < Disposable::Twin
+      property :id
+      property :title, from: :name
+    end
+  end
+
+  class AlbumExpose < Disposable::Expose
+    from Twin::Album.representer_class
+  end
+
+  let (:album) { Model::Album.new(1, "Dick Sandwich") }
+  subject { AlbumExpose.new(album) }
+
+  describe "readers" do
+    it  do
+      subject.id.must_equal 1
+      subject.title.must_equal "Dick Sandwich"
+    end
+  end
+
+
+  describe "writers" do
+    it do
+      subject.id = 3
+      subject.title = "Eclipse"
+
+      subject.id.must_equal 3
+      subject.title.must_equal "Eclipse"
+      album.id.must_equal 3
+      album.name.must_equal "Eclipse"
+    end
+  end
+end
+
+
+# Disposable::Composition.
+class ExposeCompositionTest < MiniTest::Spec
+  module Model
+    Band  = Struct.new(:id)
+    Album = Struct.new(:id, :name)
+  end
+
+  module Twin
+    class Album < Disposable::Twin
+      property :id,                 on: :album
+      property :name,               on: :album
+      property :band_id, from: :id, on: :band
+    end
+
+    class AlbumComposition < Disposable::Composition
+      from Twin::Album.representer_class
+    end
+  end
+
+  let (:band) { Model::Band.new(1) }
+  let (:album) { Model::Album.new(2, "Dick Sandwich") }
+  subject { Twin::AlbumComposition.new(album: album, band: band) }
+
+
+  describe "readers" do
+    it { subject.id.must_equal 2 }
+    it { subject.band_id.must_equal 1 }
+    it { subject.name.must_equal "Dick Sandwich" }
+  end
+
+
+  describe "writers" do
+    it do
+      subject.id = 3
+      subject.band_id = 4
+      subject.name = "Eclipse"
+
+      subject.id.must_equal 3
+      subject.band_id.must_equal 4
+      subject.name.must_equal "Eclipse"
+      band.id.must_equal 4
+      album.id.must_equal 3
+      album.name.must_equal "Eclipse"
+    end
+  end
+end

data/test/persisted_test.rb

@@ -0,0 +1,101 @@
+require "test_helper"
+
+class PersistedTest < MiniTest::Spec
+  class AlbumTwin < Disposable::Twin
+    feature Sync, Save
+    feature Persisted, Changed
+
+    property :name
+
+    property :artist do
+      # on_added
+      # on_removed
+      property :name
+    end
+
+    collection :songs do
+      # after_add: could also be existing user
+      # after_remove
+      # after_create: this means added+changed?(:persisted): song created and added.
+      # after_update
+      property :title
+    end
+  end
+
+  it do
+    artist  = Artist.new
+    ex_song = Song.create(title: "Run For Cover")
+    song    = Song.new
+    album   = Album.new(artist: artist, songs: [ex_song, song])
+
+
+    artist.persisted?.must_equal false
+    album.persisted?.must_equal false
+    ex_song.persisted?.must_equal true
+    song.persisted?.must_equal false
+
+    twin = AlbumTwin.new(album)
+    twin.persisted?.must_equal false
+    twin.changed?(:persisted?).must_equal false
+    twin.artist.persisted?.must_equal false
+    twin.artist.changed?(:persisted?).must_equal false
+    twin.songs[0].persisted?.must_equal true
+    twin.songs[0].changed?(:persisted?).must_equal false
+    twin.songs[1].persisted?.must_equal false
+    twin.songs[1].changed?(:persisted?).must_equal false
+
+    twin.save
+
+    artist.persisted?.must_equal true
+    album.persisted?.must_equal true
+    ex_song.persisted?.must_equal true
+    song.persisted?.must_equal true
+
+    twin.persisted?.must_equal true
+    twin.changed?(:persisted?).must_equal true
+    twin.artist.persisted?.must_equal true
+    twin.artist.changed?(:persisted?).must_equal true
+    twin.songs[0].persisted?.must_equal true
+    twin.songs[0].changed?(:persisted?).must_equal false
+    twin.songs[1].persisted?.must_equal true
+    twin.songs[1].changed?(:persisted?).must_equal true
+  end
+
+
+  describe "#created?" do
+    it do
+      twin = AlbumTwin.new(Album.new)
+
+      twin.created?.must_equal false
+      twin.save
+      twin.created?.must_equal true
+    end
+
+    it do
+      twin = AlbumTwin.new(Album.create)
+
+      twin.created?.must_equal false
+      twin.save
+      twin.created?.must_equal false
+    end
+  end
+
+
+  # describe "#updated?" do
+  #   it do
+  #     twin = AlbumTwin.new(Album.new)
+
+  #     twin.updated?.must_equal false
+  #     twin.save
+  #     twin.updated?.must_equal false
+  #   end
+
+  #   it do
+  #     twin = AlbumTwin.new(Album.create)
+
+  #     twin.updated?.must_equal false
+  #     twin.save
+  #     twin.updated?.must_equal true
+  #   end
+  # end
+end

data/test/test_helper.rb

@@ -1,5 +1,7 @@
 require 'disposable'
 require 'minitest/autorun'
+require "pp"
+require "representable/debug"
 
 class Track
   def initialize(options={})
@@ -13,3 +15,65 @@ end
 # require 'active_record'
 # require 'database_cleaner'
 # DatabaseCleaner.strategy = :truncation
+
+require 'active_record'
+class Artist < ActiveRecord::Base
+  has_many :albums
+end
+
+class Song < ActiveRecord::Base
+  belongs_to :artist
+end
+
+class Album < ActiveRecord::Base
+  has_many :songs
+  belongs_to :artist
+end
+
+ActiveRecord::Base.establish_connection(
+  :adapter => "sqlite3",
+  :database => "#{Dir.pwd}/database.sqlite3"
+)
+
+# uncomment this once to create a database for testing:
+
+# ActiveRecord::Schema.define do
+#   create_table :artists do |table|
+#     table.column :name, :string
+#     table.timestamps
+#   end
+#   create_table :songs do |table|
+#     table.column :title, :string
+#     table.column :artist_id, :integer
+#     table.column :album_id, :integer
+#     table.timestamps
+#   end
+#   create_table :albums do |table|
+#     table.column :name, :string
+# table.column :artist_id, :integer
+#     table.timestamps
+#   end
+# end
+
+module Disposable
+  module Comparable
+    def attributes(source)
+      source.instance_variable_get(:@fields)
+    end
+
+    def ==(other)
+      self.class == other.class and attributes(self) == attributes(other)
+    end
+  end
+
+  module Saveable
+    def save
+      @saved = true
+    end
+
+    def saved?
+      @saved
+    end
+  end
+end
+

data/test/twin/benchmarking.rb

@@ -0,0 +1,33 @@
+require "disposable/twin"
+require 'reform'
+require 'ostruct'
+require 'benchmark'
+
+class BandForm < Reform::Form
+  property :name, validates: {presence: true}
+
+  collection :songs do
+    property :title, validates: {presence: true}
+  end
+end
+
+songs = 50.times.collect { OpenStruct.new(title: "Be Stag") }
+band = OpenStruct.new(name: "Teenage Bottlerock", songs: songs)
+
+songs_params = 50.times.collect { {title: "Commando"} }
+
+time = Benchmark.measure do
+  100.times.each do
+    form = BandForm.new(band)
+    form.validate("name" => "Ramones", "songs" => songs_params)
+    form.save
+  end
+end
+
+puts time
+
+# with old Fields.new(to_hash)
+#   4.200000
+# 20%
+# with setup and new(fields).from_object(twin) instead of Fields.new(to_hash)
+#   3.680000   0.000000   3.680000 (  3.685796)

data/test/twin/builder_test.rb

@@ -0,0 +1,32 @@
+require "test_helper"
+
+class BuilderTest < MiniTest::Spec
+  module Model
+    Song = Struct.new(:id, :title)
+    Hit = Struct.new(:id, :title)
+    Evergreen = Struct.new(:id, :title)
+  end
+
+  class Twin < Disposable::Twin
+    property :id
+    property :title
+    # option   :is_released
+
+    include Builder
+    builds ->(model, options) do
+      return Hit       if model.is_a? Model::Hit
+      return Evergreen if options[:evergreen]
+    end
+  end
+
+  class Hit < Twin
+  end
+
+  class Evergreen < Twin
+  end
+
+
+  it { Twin.build(Model::Song.new).must_be_instance_of Twin }
+  it { Twin.build(Model::Hit.new).must_be_instance_of  Hit }
+  it { Twin.build(Model::Evergreen.new, evergreen: true).must_be_instance_of Evergreen }
+end

data/test/twin/changed_test.rb

@@ -0,0 +1,108 @@
+require 'test_helper'
+# require 'reform/form/coercion'
+
+class ChangedWithSetupTest < MiniTest::Spec
+  module Model
+    Song  = Struct.new(:title, :length, :composer)
+    Album = Struct.new(:name, :songs, :artist)
+    Artist = Struct.new(:name)
+  end
+
+  module Twin
+    class Album < Disposable::Twin
+      feature Setup
+      feature Changed
+      # include Coercion
+      property :name
+
+      collection :songs do
+        property :title
+        property :length, type: Integer
+
+        property :composer do
+          property :name
+        end
+      end
+
+      property :artist do
+        include Setup
+        property :name
+      end
+    end
+  end
+
+
+  let (:song)     { Model::Song.new("Broken") }
+  let (:composer) { Model::Artist.new(2) }
+  let (:song_with_composer) { Model::Song.new("Broken", 246, composer) }
+  let (:artist)   { Model::Artist.new("Randy") }
+  let (:album)    { Model::Album.new("The Rest Is Silence", [song, song_with_composer], artist) }
+  let (:twin)     { Twin::Album.new(album) }
+
+  # setup: changed? is always false
+  it do
+    twin.changed?(:name).must_equal false
+    twin.changed?.must_equal false
+
+    twin.songs[0].changed?.must_equal false
+    twin.songs[0].changed?(:title).must_equal false
+    twin.songs[1].changed?.must_equal false
+    twin.songs[1].changed?(:title).must_equal false
+
+    twin.songs[1].composer.changed?(:name).must_equal false
+    twin.songs[1].composer.changed?.must_equal false
+
+    twin.artist.changed?(:name).must_equal false
+    twin.artist.changed?.must_equal false
+  end
+
+  # only when a property is assigned, it's changed.
+  it do
+    twin.name= "Out Of Bounds"
+    twin.songs[0].title= "I Have Seen"
+    twin.songs[1].title= "In A Rhyme"
+    twin.songs[1].composer.name= "Ingemar Jansson & Mikael Danielsson"
+    twin.artist.name = "No Fun At All"
+
+    twin.changed?(:name).must_equal true
+    twin.changed?.must_equal true
+
+    twin.songs[0].changed?.must_equal true
+    twin.songs[0].changed?(:title).must_equal true
+    twin.songs[1].changed?.must_equal true
+    twin.songs[1].changed?(:title).must_equal true
+
+    twin.songs[1].composer.changed?(:name).must_equal true
+    twin.songs[1].composer.changed?.must_equal true
+
+    twin.artist.changed?(:name).must_equal true
+    twin.artist.changed?.must_equal true
+
+    # you can also ask for nested twins by name.
+    twin.changed?(:songs).must_equal true
+    twin.songs[0].changed?(:composer).must_equal false
+    twin.songs[1].changed?(:composer).must_equal true
+    twin.changed?(:artist).must_equal true
+  end
+
+  # nested changes should propagate up.
+  it do
+    twin.changed?.must_equal false
+
+    twin.songs[1].composer.name = "Nofx"
+
+    twin.changed?.must_equal true
+
+    assert twin.songs.changed?
+    twin.songs[1].changed?.must_equal true
+    twin.songs[0].changed?.must_equal false
+
+    twin.artist.changed?.must_equal false
+  end
+
+  # setting identical value doesn't change.
+  it do
+    twin.name = "The Rest Is Silence"
+    twin.changed?.must_equal false
+  end
+end