disposable 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c8eb1cfd5be42eb0cf007c4b9d84aee95b7a4275
-  data.tar.gz: 76ab1e429806470d007164fd17bdf80d0abeab1a
+  metadata.gz: 333ff0a256285692e2f30e1dd908b671a8f93a0a
+  data.tar.gz: ff98cc474bd5b508066d459489c711643d6164e1
 SHA512:
-  metadata.gz: dba5e116162e6fe0f33ff944ef1dbadb9fb8a5208c790fb92c5c0d68091a7edf83e91b9fca49029d8df00db458fb131e1be6c554293fbfcef23730034ada8602
-  data.tar.gz: e3d4ac5b51ea771c2444bbdb6b34bcfa05e5b2ff9513050915a470920fd2238e5a639a8ce69225a93cc2a876412759335a0cda068c4b11c0f61aab38ba8603b9
+  metadata.gz: 9ca99470a8d3eed471d107648d17fb8d9d3525e4191cb2d635404c5c4e9dcacf10c6fefec61ea4835a6a38a7083667a33f131a0fc442e6418c7d549e9f8c1dc1
+  data.tar.gz: c56cb7f98015746abf7ce43d05d6479e0bfa2b7c25df41a2c41f64fd3519c9613e08d755d335cb2128bc7a0b29f5b4e14dd5530bd6cf83c9b521217ad7475c21

data/CHANGES.md

@@ -1,3 +1,7 @@
+# 0.1.1
+
+* Adding `Setup::SkipSetter` and `Sync::SkipGetter`.
+
 # 0.1.0
 
 * This is the official first serious release.

data/Gemfile

@@ -3,4 +3,4 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in disposable.gemspec
 gemspec
 
-gem 'representable', path: '../representable'
+# gem 'representable', path: '../representable'

data/README.md

@@ -4,19 +4,26 @@ _Decorators on top of your ORM layer._
 
 ## Introduction
 
-Disposable gives you "_Twins_" which are domain objects, decoupled from ActiveRecord, DataMapper or whatever ORM you use.
+Disposable is the missing API of ActiveRecord*. The mission:
 
-Twins are non-persistent domain objects. That is reflected in the name of the gem. However, they can read and write values from a persistent object.
+* Maintain a manipulatable object graph that is a copy/map of a persistent structure.
+* Prevent any write to the persistence layer until you say `sync`.
+* Help designing your domain layer without being restricted to database layouts ([renaming](#renaming), [compositions](#composition), [hash fields](#struct)).
+* Provide additional behavior like [change tracking](#change-tracking), [imperative callbacks](#imperative-callbacks) and [collection semantics](#collection-semantics).
 
-Twins are an integral part of the [Trailblazer](https://github.com/apotonick/trailblazer) architectural style which provides clean layering of concerns.
 
-They give you an encapsulated alternative to delegators that many projects use to separate domain and persistence and help you restricting the domain API.
+Disposable gives you "_Twins_": non-persistent domain objects. That is reflected in the name of the gem. They can read from and write values to a persistent object and abstract the persistence layer until data is synced to the model.
 
-## Why?
+## API
 
-The goal is to have one object that delegates reading and writing to underlying object(s). This is a fundamental concept for cells view models, representers, and reform form objects.
+The public twin API is unbelievably simple.
+
+1. `Twin::new` creates and populates the twin.
+1. `Twin#"reader"` returns the value or nested twin of the property.
+1. `Twin#"writer"=(v)` writes the value to the twin, not the model.
+1. `Twin#sync` writes all values to the model.
+1. `Twin#save` writes all values to the model and calls `save` on configured models.
 
-Twins may contain validations, nevertheless, in Trailblazer, validations (or "Contracts") sit one layer above. They still can be part of your domain, though.
 
 ## Twin
 
@@ -24,78 +31,317 @@ Twins are only # FIXME % slower than AR alone.
 
 Twins implement light-weight decorators objects with a unified interface. They map objects, hashes, and compositions of objects, along with optional hashes to inject additional options.
 
-Let me show you what I mean.
+Every twin is based on a defined schema.
 
 ```ruby
-song = Song.create(title: "Savior", length: 242)
-```
-
-## Definition
+class AlbumTwin < Disposable::Twin
+  property :title
+  property :playable?, virtual: true # context-sensitive, e.g. current_user dependent.
 
-Twins need to define every field they expose.
+  collection :songs do
+    property :name
+    property :index
+  end
 
-```ruby
-class Song::Twin < Disposable::Twin
-  property :title
-  property :length
-  option   :good?
+  property :artist do
+    property :full_name
+  end
 end
 ```
 
-## Creation
+## Constructor
 
-You need to pass model and the optional options to the twin constructor.
+Twins get populated from the decorated models.
 
 ```ruby
-twin = Song::Twin.new(song, good?: true)
+Song   = Struct.new(:name, :index)
+Artist = Struct.new(:full_name)
+Album  = Struct.new(:title, :songs, :artist)
 ```
 
-++++++ builders
+You need to pass model and the facultative options to the twin constructor.
 
-## Reading
+```ruby
+album = Album.new("Nice Try")
+twin  = AlbumTwin.new(album, playable?: current_user.can?(:play))
+```
+
+## Readers
 
 This will create a composition object of the actual model and the hash.
 
 ```ruby
-twin.title #=> "Savior"
-twin.good? #=> true
+twin.title     #=> "Nice Try"
+twin.playable? #=> true
 ```
 
 You can also override `property` values in the constructor:
 
 ```ruby
-twin = Song::Twin.new(song, title: "Plasticash")
+twin = AlbumTwin.new(album, title: "Plasticash")
 twin.title #=> "Plasticash"
 ```
 
-Let's talk about what happens to the actual model when setting values?
+## Writers
+
+Writers change values on the twin and are _not_ propagated to the model.
 
-## Writing
+```ruby
+twin.title = "Skamobile"
+twin.title  #=> "Skamobile"
+album.title #=> "Nice Try"
+```
 
-It doesn't happen. The model is only queried when _reading_ values. Writing only happens in additional modules: Syncing and Saving is where the values held in the twin are written to the model.
+Writers on nested twins will "twin" the value.
 
-## Renaming
+```ruby
+twin.songs #=> []
+twin.songs << Song.new("Adondo", 1)
+twin.songs  #=> [<Twin::Song name="Adondo" index=1 model=<Song ..>>]
+album.songs #=> []
+```
 
-## Structs
+The added twin is _not_ passed to the model. Note that the nested song is a twin, not the model itself.
 
-If you don't have a model but a simple hash, use `Struct`.
+## Sync
+
+Given the above state change on the twin, here is what happens after calling `#sync`.
 
 ```ruby
-class Song::Twin < Disposable::Twin
-  include Struct
-  property :title
-  property :length
+album.title  #=> "Nice Try"
+album.songs #=> []
+
+twin.sync
+
+album.title  #=> "Skamobile"
+album.songs #=> [<Song name="Adondo" index=1>]
+```
+
+`#sync` writes all configured attributes back to the models using public setters as `album.name=` or `album.songs=`. This is recursive and will sync the entire object graph.
+
+Note that `sync` might already trigger saving the model as persistence layers like ActiveRecord can't deal with `collection= []` and instantly persist that.
+
+You may implement your syncing manually by passing a block to `sync`.
+
+```ruby
+twin.sync do |hash|
+  hash #=> {
+  #  "title"     => "Skamobile",
+  #  "playable?" => true,
+  #  "songs"     => [{"name"=>"Adondo"...}..]
+  # }
 end
 ```
 
-Note that a hash goes into the constructor now.
+Invoking `sync` with block will _not_ write anything to the models.
+
+Needs to be included explicitly (`Sync`).
+
+## Save
+
+Calling `#save` will do `sync` plus calling `save` on all nested models. This implies that the models need to implement `#save`.
+
+```ruby
+twin.save
+#=> album.save
+#=>      .songs[0].save
+
+```
+
+Needs to be included explicitly (`Save`).
+
+## Nested Twin
+
+Nested objects can be declared with an inline twin.
+
+```ruby
+property :artist do
+  property :full_name
+end
+```
+
+The setter will automatically "twin" the model.
+
+```ruby
+twin.artist = Artist.new
+twin.artist #=> <Twin::Artist model=<Artist ..>>
+```
+
+You can also specify nested objects with an explicit class.
+
+```ruby
+property :artist, twin: TwinArtist
+```
+
+## Collections
+
+Collections can be defined analogue to `property`. The exposed API is the `Array` API.
+
+* `twin.songs = [..]` will override the existing value and "twin" every item.
+* `twin.songs << Song.new` will add and twin.
+* `twin.insert(0, Song.new)` will insert at the specified position and twin.
+
+You can also delete, replace and move items.
+
+* `twin.songs.delete( twin.songs[0] )`
+
+None of these operations are propagated to the model.
+
+## Collection Semantics
+
+In addition to the standard `Array` API the collection adds a handful of additional semantics.
+
+* `songs=`, `songs<<` and `songs.insert` track twin via `#added`.
+* `songs.delete` tracks via `#deleted`.
+* `twin.destroy( twin.songs[0] )` deletes the twin and marks it for destruction in `#to_destroy`.
+* `twin.songs.save` will call `destroy` on all models marked for destruction in `to_destroy`. Tracks destruction via `#destroyed`.
+
+Again, the model is left alone until you call `sync` or `save`.
+
+## Change Tracking
+
+The `Changed` module will allow tracking of state changes in all properties, even nested structures.
+
+```ruby
+class AlbumTwin < Disposable::Twin
+  feature Changed
+```
+
+Now, consider the following operations.
+
+```ruby
+twin.name = "Skamobile"
+twin.songs << Song.new("Skate", 2) # this adds second song.
+```
+
+This results in the following tracking results.
+
+```ruby
+twin.changed?             #=> true
+twin.changed?(:name)      #=> true
+twin.changed?(:playable?) #=> false
+twin.songs.changed?       #=> true
+twin.songs[0].changed?    #=> false
+twin.songs[1].changed?    #=> true
+```
+
+Assignments from the constructor are _not_ tracked as changes.
+
+```ruby
+twin = AlbumTwin.new(album)
+twin.changed? #=> false
+```
+
+## Persistance Tracking
+
+The `Persisted` module will track the `persisted?` field of the model, implying that your model exposes this field.
+
+```ruby
+twin.persisted? #=> false
+twin.save
+twin.persisted? #=> true
+```
+
+The `persisted?` field is a copy of the model's persisted? flag.
+
+You can also use `created?` to find out whether a twin's model was already persisted or just got created in this session.
+
+```ruby
+twin = AlbumTwin.new(Album.create) # assuming we were using ActiveRecord.
+twin.created? #=> false
+twin.save
+twin.created? #=> false
+```
+
+This will only return true when the `persisted?` field has flipped.
+
+## Renaming
+
+The `Expose` module allows renaming properties.
+
+```ruby
+class AlbumTwin < Disposable::Twin
+  feature Expose
+
+  property :song_title, from: :title
+```
+
+The public accessor is now `song_title` whereas the model's accessor needs to be `title`.
+
+```ruby
+album = OpenStruct.new(title: "Run For Cover")
+AlbumTwin.new(album).song_title #=> "Run For Cover"
+```
+
+## Composition
+
+Compositions of objects can be mapped, too.
+
+```ruby
+class AlbumTwin < Disposable::Twin
+  feature Composition
+
+  property :id,    on: :album
+  property :title, on: :album
+  property :songs, on: :cd
+  property :cd_id, on: :cd, from: :id
+```
+
+When initializing a composition, you have to pass a hash that contains the composees.
 
 ```ruby
-twin = Song::Twin.new(title: "Savior", good?: true)
+AlbumTwin.new(album: album, cd: CD.find(1))
 ```
 
+Note that renaming works here, too.
+
+## Struct
+
+Twins can also map hash properties, e.g. from a deeply nested serialized JSON column.
 
-## Compositions
+```ruby
+album.permissions #=> {admin: {read: true, write: true}, user: {destroy: false}}
+```
+
+Map that using the `Struct` module.
+
+```ruby
+class AlbumTwin < Disposable::Twin
+  property :permissions do
+     include Struct
+    property :admin do
+      include Struct
+      property :read
+      property :write
+    end
+
+    property :user # you don't have to use Struct everywhere!
+  end
+```
+
+You get fully object-oriented access to your properties.
+
+```ruby
+twin.permissions.admin.read #=> true
+```
+
+Note that you do not have to use `Struct` everywhere.
+
+```ruby
+twin.permissions.user #=> {destroy: false}
+```
+
+Of course, this works for writing, too.
+
+```ruby
+twin.permissions.admin.read = :MAYBE
+```
+
+After `sync`ing, you will find a hash in the model.
+
+```ruby
+album.permissions #=> {admin: {read: :MAYBE, write: true}, user: {destroy: false}}
+```
 
 ## With Representers
 
@@ -103,33 +349,52 @@ they indirect data, the twin's attributes get assigned without writing to the pe
 
 ## With Contracts
 
-## Collections
+## Overriding Getter for Presentation
 
-Define collections using `::collection`.
+You can override getters for presentation.
 
 ```ruby
 class AlbumTwin < Disposable::Twin
-  collection :songs do
+    property :title
 
+    def title
+      super.upcase
+    end
   end
 ```
 
-### API
+Be careful, though. The getter normally is also called in `sync` when writing properties to the models.
+
+You can skip invocation of getters in `sync` and read values from `@fields` directly by including `Sync::SkipGetter`.
 
-The API is identical to `Array` with the following additions.
+```ruby
+class AlbumTwin < Disposable::Twin
+  feature Sync
+  feature Sync::SkipGetter
+```
 
-* `#<<(model)` adds item, wraps it in twin and tracks it via `#added`.
-* `#insert(i, model)`, see `#<<`.
-* `#delete(twin)`, removes twin from collection and tracks via `#deleted`.
-* `#destroy(twin)`, removes twin from collection and tracks via `#deleted` and `#to_destroy` for destruction in `#save`.
+## Manual Coercion
 
-### Semantics
+You can override setters for manual coercion.
 
-Include `Twin::Collection::Semantics`.
+```ruby
+class AlbumTwin < Disposable::Twin
+    property :title
 
-Semantics are extensions to the pure Ruby array behavior and designed to deal with persistence layers like ActiveRecord or ROM.
+    def title=(v)
+      super(v.trim)
+    end
+  end
+```
 
-* `#save` will call `destroy` on all models marked for destruction in `to_destroy`. Tracks destruction via `#destroyed`.
+Be careful, though. The setter normally is also called in `setup` when copying properties from the models to the twin.
+
+Analogue to `SkipGetter`, include `Setup::SkipSetter` to write values directly to `@fields`.
+
+```ruby
+class AlbumTwin < Disposable::Twin
+  feature Setup::SkipSetter
+```
 
 
 ## Imperative Callbacks
@@ -235,18 +500,14 @@ This will add the `rewind!` callback to the `songs` property, resulting in the f
 
 ```ruby
 collection :songs do
-    on_add    :notify_album!
-    on_add    :reset_song!
-    on_delete :rewind!
-  end
+  on_add    :notify_album!
+  on_add    :reset_song!
+  on_delete :rewind!
+end
 ```
 
 ## Builders
 
-## Overriding Accessors
-
-super
-
 ## Used In
 
 * [Reform](https://github.com/apotonick/reform) forms are based on twins and add a little bit of form decoration on top. Every nested form is a twin.

data/lib/disposable/twin/property_processor.rb

@@ -4,8 +4,10 @@
 # For a scalar property, this will be run once and yield the property's value.
 # For a collection, this is run per item and yields the item.
 class Disposable::Twin::PropertyProcessor
-  def initialize(definition, twin)
-    @definition, @twin = definition, twin
+  def initialize(definition, twin, value=nil)
+    value ||= twin.send(definition.getter)
+    @definition = definition
+    @value      = value
   end
 
   def call(&block)
@@ -19,11 +21,11 @@ class Disposable::Twin::PropertyProcessor
 private
   def collection!
     # FIXME: the nil collection is not tested, yet!
-    (@twin.send(@definition.getter) || []).collect { |nested_twin| yield(nested_twin) }
+    (@value || []).collect { |nested_twin| yield(nested_twin) }
   end
 
   def property!
-    twin = @twin.send(@definition.getter) or return nil
+    twin = @value or return nil
     nested_model = yield(twin)
   end
 end

data/lib/disposable/twin/setup.rb

@@ -27,12 +27,24 @@ module Disposable
           name  = dfn.name
           value = options[name.to_sym] || mapper.send(name) # model.title.
 
-          send(dfn.setter, value)
+          setup_write!(dfn, value)
         end
 
         @fields.merge!(options) # FIXME: hash/string. # FIXME: call writer!!!!!!!!!!
         # from_hash(options) # assigns known properties from options.
       end
+
+      def setup_write!(dfn, value)
+        send(dfn.setter, value)
+      end
+
+
+      # Including this will _not_ use the property's setter in Setup and allow you to override it.
+      module SkipSetter
+        def setup_write!(dfn, value)
+          write_property(dfn.name, value, dfn)
+        end
+      end
     end # Setup
   end
 end

data/lib/disposable/twin/struct.rb

@@ -1,14 +1,43 @@
-module Disposable
+  module Disposable
   class Twin
     # Twin that uses a hash to populate.
     #
     #   Twin.new(id: 1)
     module Struct
-      def initialize(model, options={})
-        super # call from_hash(options) # FIXME: this is wrong and already calls from_hash(options)
+      def setup_properties!(model, options={})
+        hash_representer.new(self).from_hash(model.merge(options))
+      end
+
+      def hash_representer
+        Class.new(schema) do
+          include Representable::Hash
+          include Representable::Hash::AllowSymbols
+
+          representable_attrs.each do |dfn|
+            dfn.merge!(
+              prepare:       lambda { |model, *| model },
+              instance:      lambda { |model, *| model }, # FIXME: this is because Representable thinks this is typed? in Deserializer.
+              representable: false,
+            ) if dfn[:twin]
+          end
+        end
+      end
+
+      def sync_hash_representer
+        hash_representer.clone.tap do |rpr|
+          rpr.representable_attrs.each do |dfn|
+            dfn.merge!(
+              serialize: lambda { |model, *| model.sync! },
+              representable: true
+            ) if dfn[:twin]
+          end
+        end
+      end
 
-        from_hash(model.merge(options))
+      def sync(options={})
+        sync_hash_representer.new(self).to_hash
       end
+      alias_method :sync!, :sync
     end
   end
 end

data/lib/disposable/twin/sync.rb

@@ -20,12 +20,14 @@ class Disposable::Twin
       options_for_sync = sync_options(Decorator::Options[options])
 
       schema.each(options_for_sync) do |dfn|
+        property_value = sync_read(dfn) #
+
         unless dfn[:twin]
-          mapper.send(dfn.setter, send(dfn.getter)) # always sync the property
+          mapper.send(dfn.setter, property_value) # always sync the property
           next
         end
 
-        nested_model = PropertyProcessor.new(dfn, self).() { |twin| twin.sync!({}) }
+        nested_model = PropertyProcessor.new(dfn, self, property_value).() { |twin| twin.sync!({}) }
 
         next if nested_model.nil?
 
@@ -35,11 +37,14 @@ class Disposable::Twin
       model
     end
 
+  private
     def self.included(includer)
       includer.extend ToNestedHash::ClassMethods
     end
 
-  private
+    def sync_read(definition)
+      send(definition.getter)
+    end
 
     module ToNestedHash
       def to_nested_hash(*)
@@ -110,5 +115,13 @@ class Disposable::Twin
         super
       end
     end
+
+
+    # Include this won't use the getter #title in #sync but read directly from @fields.
+    module SkipGetter
+      def sync_read(dfn)
+        @fields[dfn.name]
+      end
+    end
   end
 end

data/lib/disposable/version.rb

@@ -1,3 +1,3 @@
 module Disposable
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/test/skip_getter_test.rb

@@ -0,0 +1,37 @@
+require "test_helper"
+
+class SkipGetterTest < MiniTest::Spec
+  Album  = Struct.new(:title, :artist)
+  Artist = Struct.new(:name)
+
+  class AlbumTwin < Disposable::Twin
+    feature Sync
+    feature Sync::SkipGetter
+
+    property :title
+    property :artist do
+      property :name
+
+      def name
+        super.upcase
+      end
+    end
+
+    def title
+      super.reverse
+    end
+  end
+
+  it do
+    album = Album.new("Wild Frontier", Artist.new("Gary Moore"))
+    twin  = AlbumTwin.new(album)
+
+    twin.title.must_equal "reitnorF dliW"
+    twin.artist.name.must_equal "GARY MOORE"
+
+    twin.sync # does NOT call getter.
+
+    album.title.must_equal "Wild Frontier"
+    album.artist.name.must_equal "Gary Moore"
+  end
+end

data/test/skip_setter_test.rb

@@ -0,0 +1,30 @@
+require "test_helper"
+
+class SkipSetterTest < MiniTest::Spec
+  Album  = Struct.new(:title, :artist)
+  Artist = Struct.new(:name)
+
+  class AlbumTwin < Disposable::Twin
+    feature Setup::SkipSetter
+
+    property :title
+    property :artist do
+      property :name
+
+      def name=(v)
+        super(v.upcase)
+      end
+    end
+
+    def title=(v)
+      super(v.reverse)
+    end
+  end
+
+  it do
+    twin = AlbumTwin.new(Album.new("Wild Frontier", Artist.new("Gary Moore")))
+
+    twin.title.must_equal "Wild Frontier"
+    twin.artist.name.must_equal "Gary Moore"
+  end
+end

data/test/twin/struct_test.rb

@@ -1,168 +1,99 @@
-# require 'test_helper'
+require 'test_helper'
 # require "representable/debug"
 
-# require 'disposable/twin/struct'
+require 'disposable/twin/struct'
 
+class TwinStructTest < MiniTest::Spec
+  class Song < Disposable::Twin
+    include Struct
+    property :number#, default: 1 # FIXME: this should be :default_if_nil so it becomes clear with a model.
+    property :cool?
+  end
 
+  # empty hash
+  # it { Song.new({}).number.must_equal 1 }
+  it { Song.new({}).number.must_equal nil } # TODO: implement default.
 
-# module Representable
-#   # The generic representer. Brings #to_hash and #from_hash to your object.
-#   # If you plan to write your own representer for a new media type, try to use this module (e.g., check how JSON reuses Hash's internal
-#   # architecture).
-#   module Object
-#     def self.included(base)
-#       base.class_eval do
-#         include Representable
-#         extend ClassMethods
-#         register_feature Representable::Object
-#       end
-#     end
+  # model hash
+  it { Song.new(number: 2).number.must_equal 2 }
 
+  # with hash and options as one hash.
+  it { Song.new(number: 3, cool?: true).cool?.must_equal true }
+  it { Song.new(number: 3, cool?: true).number.must_equal 3 }
 
-#     module ClassMethods
-#       def collection_representer_class
-#         Collection
-#       end
-#     end
+  # with model hash and options hash separated.
+  it { Song.new({number: 3}, {cool?: true}).cool?.must_equal true }
+  it { Song.new({number: 3}, {cool?: true}).number.must_equal 3 }
 
-#     def from_object(data, options={}, binding_builder=Binding)
-#       update_properties_from(data, options, binding_builder)
-#     end
 
-#     # FIXME: remove me! only here to avoid AllowSymbols from Twin:Representer
-#     def update_properties_from(doc, options, format)
-#       representable_mapper(format, options).deserialize(doc, options)
-#     end
-#   end
-# end
+  describe "writing" do
+    let (:song) { Song.new(model, {cool?: true}) }
+    let (:model) { {number: 3} }
 
+    # writer
+    it do
+      song.number = 9
+      song.number.must_equal 9
+      model[:number].must_equal 3
+    end
 
+    # writer with sync
+    it do
+      song.number = 9
+      model = song.sync
 
+      song.number.must_equal 9
+      model["number"].must_equal 9
 
+      # song.send(:model).object_id.must_equal model.object_id
+    end
+  end
 
-# class TwinStructTest < MiniTest::Spec
-#   class Song < Disposable::Twin
-#     include Struct
-#     property :number, default: 1 # FIXME: this should be :default_if_nil so it becomes clear with a model.
-#     option   :cool?
-#   end
+end
 
-#   # empty hash
-#   it { Song.new({}).number.must_equal 1 }
-#   # model hash
-#   it { Song.new(number: 2).number.must_equal 2 }
 
-#   # with hash and options as one hash.
-#   it { Song.new(number: 3, cool?: true).cool?.must_equal true }
-#   it { Song.new(number: 3, cool?: true).number.must_equal 3 }
+class TwinWithNestedStructTest < MiniTest::Spec
+  class Song < Disposable::Twin
+    property :title
+    include Sync
 
-#   # with model hash and options hash separated.
-#   it { Song.new({number: 3}, {cool?: true}).cool?.must_equal true }
-#   it { Song.new({number: 3}, {cool?: true}).number.must_equal 3 }
+    property :options, twin: true do # don't call #to_hash, this is triggered in the twin's constructor.
+      include Struct
+      property :recorded
+      property :released
 
+      property :preferences, twin: true do
+        include Struct
+        property :show_image
+        property :play_teaser
+      end
+    end
+  end
 
-#   describe "writing" do
-#     let (:song) { Song.new(model, {cool?: true}) }
-#     let (:model) { {number: 3} }
+  # FIXME: test with missing hash properties, e.g. without released and with released:false.
+  let (:model) { OpenStruct.new(title: "Seed of Fear and Anger", options: {recorded: true, released: 1,
+    preferences: {show_image: true, play_teaser: 2}}) }
 
-#     # writer
-#     it do
-#       song.number = 9
-#       song.number.must_equal 9
-#       model[:number].must_equal 3
-#     end
+  # public "hash" reader
+  it { Song.new(model).options.recorded.must_equal true }
 
-#     # writer with sync
-#     it do
-#       song.number = 9
-#       song.sync
+  # public "hash" writer
+  it ("xxx") {
+    song = Song.new(model)
 
-#       song.number.must_equal 9
-#       model["number"].must_equal 9
+    song.options.recorded = "yo"
+    song.options.recorded.must_equal "yo"
 
-#       song.send(:model).object_id.must_equal model.object_id
-#     end
-#   end
+    song.options.preferences.show_image.must_equal true
+    song.options.preferences.play_teaser.must_equal 2
 
-# end
+    song.options.preferences.show_image= 9
 
 
-# # Non-lazy initialization. This will copy all properties from the wrapped object to the twin when
-# # instantiating the twin.
+    song.sync # this is only called on the top model, e.g. in Reform#save.
 
-
-# class TwinWithNestedStructTest < MiniTest::Spec
-#   class Song < Disposable::Twin
-#     include Setup
-#     property :title
-
-#     property :options, twin: true do # don't call #to_hash, this is triggered in the twin's constructor.
-#       include Struct
-#       property :recorded
-#       property :released
-
-#       property :preferences, twin: true do
-#         include Struct
-#         property :show_image
-#         property :play_teaser
-#       end
-#     end
-#   end
-
-#   # FIXME: test with missing hash properties, e.g. without released and with released:false.
-#   let (:model) { OpenStruct.new(title: "Seed of Fear and Anger", options: {recorded: true, released: 1,
-#     preferences: {show_image: true, play_teaser: 2}}) }
-
-#   # public "hash" reader
-#   it { Song.new(model).options.recorded.must_equal true }
-
-#   # public "hash" writer
-#   it ("xxx") {
-#     song = Song.new(model)
-
-#     puts song.inspect
-
-#     # puts song.options.inspect
-#     # puts song.options.preferences.to_hash
-#     # raise
-
-#     song.options.recorded = "yo"
-#     song.options.recorded.must_equal "yo"
-
-#     song.options.preferences.show_image.must_equal true
-#     song.options.preferences.play_teaser.must_equal 2
-
-#     song.options.preferences.show_image= 9
-
-
-#     # song.extend(Disposable::Twin::Struct::Sync)
-#     song.sync # this is only called on the top model, e.g. in Reform#save.
-
-#     model.title.must_equal "Seed of Fear and Anger"
-#     model.options["recorded"].must_equal "yo"
-#     model.options["preferences"].must_equal({"show_image" => 9, "play_teaser"=>2})
-#   }
-# end
-
-
-
-# class SyncRepresenter < Representable::Decorator
-#   include Representable::Object
-
-#   property :title
-#   property :album, instance: lambda { |fragment, *| fragment } do
-#     property :name
-#   end
-# end
-
-# album = Struct.new(:name).new("Ass It Is")
-
-# SyncRepresenter.new(obj = Struct.new(:title, :album).new).from_object(Struct.new(:title, :album).new("Eternal Scream", album))
-
-# puts obj.title.inspect
-# puts obj.inspect
-# # reform
-# #   sync: twin.title = "Good Bye"
-# #         album.sync (copy attributes in nested form)
-# #           twin.name = "Matters"
-# #   save: twin.save (this will do twin.sync... does that call save on all nested twins, too, or do we still have to do that in reform?)
+    model.title.must_equal "Seed of Fear and Anger"
+    model.options["recorded"].must_equal "yo"
+    model.options["preferences"].must_equal({"show_image" => 9, "play_teaser"=>2})
+  }
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: disposable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-26 00:00:00.000000000 Z
+date: 2015-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uber
@@ -165,6 +165,8 @@ files:
 - test/example.rb
 - test/expose_test.rb
 - test/persisted_test.rb
+- test/skip_getter_test.rb
+- test/skip_setter_test.rb
 - test/test_helper.rb
 - test/twin/benchmarking.rb
 - test/twin/builder_test.rb
@@ -218,6 +220,8 @@ test_files:
 - test/example.rb
 - test/expose_test.rb
 - test/persisted_test.rb
+- test/skip_getter_test.rb
+- test/skip_setter_test.rb
 - test/test_helper.rb
 - test/twin/benchmarking.rb
 - test/twin/builder_test.rb