disposable 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 392f9c38f87256a9f23d4b15c5f1400ced554331
-  data.tar.gz: 415113cee0b7f66c9cd6be8504ebb1c2cc5602d6
+  metadata.gz: a86781957ac37581fc914a2f8dc9ca83b67d47e1
+  data.tar.gz: 0a994524733877ec59edb02ce050272b447e9409
 SHA512:
-  metadata.gz: debc2221e53dd47bb8029053b490f16dc5f52e6bbfd1ac268dba5e5b7702643061dac9fb1b868b34ca13a4825d5db82d564f4e5bb84a332ae0f41e3446e3204e
-  data.tar.gz: cf1861a9c4c3cddcfb8d5a80821774b388ef8471940db2cc0c46b2609500985d8af5fa4d4f8456e9222c6b28a1b88d6192eb849fc66822b8b6108c11af83cef2
+  metadata.gz: 94b995707bba8d65c9361ae3c0b50cfbd23d2c72f2f0212791800cfe8e771a815b7cef80c4d305e9481a3e284959131cc304b3fc2a0fc97076e7d28435de3898
+  data.tar.gz: 6f7fcd2584e0b0d06b2d4615d9d7280d0791591837750c2d515fdb0445de3677e69d397de557d3fc05e181e8877046bb3fa8ae884e7d75c55f207af1f55c537a

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3
+  - 1.8.7
+gemfile:
+  - gemfiles/Gemfile.rails-3.0
+  - gemfiles/Gemfile.rails-2.3

data/Gemfile

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

data/README.md

@@ -1,6 +1,89 @@
 # Disposable
 
 
+
+## Twin
+
+Twins implement light-weight domain objects that contain business logic - no persistance logic. They have read- and write access to a persistant object (or a composition of those) and expose a sub-set of accessors to that persistant "brother", making it a "data mapper-like phantom".
+
+Being designed to wrap persistant objects, a typical "brother" class could be an ActiveRecord one.
+
+```ruby
+class Song < ActiveRecord::Base
+  belongs_to :album
+end
+```
+
+You don't wanna work with that persistant brother directly anymore. A twin will wrap it and indirect domain from persistance.
+
+The twin itself has a _ridiculous_ simple API.
+
+```ruby
+class Twin::Song < Disposable::Twin
+  model ::Song                  # the persistant ActiveRecord brother class
+
+  property :title
+  property :album, twin: Album  # a nested twin.
+```
+
+
+### Creation
+
+You can create fresh, blank-slate twins yourself. They will create a new persistant object automatically.
+
+```ruby
+song = Twin::Song.new(title: "Justified Black Eye")
+
+#=> #<Twin::Song title: "Justified Black Eye">
+```
+
+This doesn't involve any database operations at all.
+
+
+### Creation Using Finders
+
+(to be implemented)
+Every `Twin` subclass exposes all finders from the brother class. However, instances from the persistance layer are automatically twin'ed.
+
+```ruby
+song = Twin::Song.find(1)
+
+#=> #<Twin::Song title: "Already Won" album: #<Twin::Album>>
+```
+
+
+### Read And Write Access
+
+All attributes declared with `property` are exposed on the twin.
+
+```ruby
+song.title #=> "Already Won"
+
+song.album.name #=> "The Songs of Tony Sly: A Tribute"
+```
+
+Note that writing to the twin **does not** change any state on the persistant brother.
+
+```ruby
+song.title = "Still Winning" # no change on Song, no write to DB.
+```
+
+
+### Saving
+
+Calling `#save` will sync all properties to the brother object and advice the persistant brother to save. This works recursively, meaning that nested twins will do the same with their pendant.
+
+```ruby
+song.save # write to DB.
+```
+
+* Twins don't know anything about the underlying persistance layer.
+* Lazy-loading
+
+
+
+## To be documented properly
+
 Facade existing (model) class
 where to decorate old instances from collections?
   option.invoice_template => .items
@@ -18,6 +101,16 @@ class Invoice
 	end
 
 
+Why facades?
+you don't wanna add code to existing shit
+transparently change the API
+you don't have to worry about what's happening in the underlying pile of shit (GstCalculations module), you only correct the API on top of it
+no inheritance, composition whereever possible (interfaces between layers)
+optional, still use old assets
+don't/step-wise change existing "running" code
+
+you basically don't change existing code but build extracted components on top of your legacy app
+
 * facades
 * overriding public methods in facade
 * temporary Refinements
@@ -25,11 +118,49 @@ class Invoice
 * steps of refactoring
 
 
+"partial refactoring"
 "explicit refactoring"
 
 
+* make it simple to split existing model into smaller (reducing validations etc)
+* mark dead code
+* by explicit use of `facade` you can track "dirt"
+
+* rename options => DSL
 
 TODO: Write a gem description
+* generator for Facades
+loading of facades?
+location of facades? i wanna have Facade::Client, not facades/ClientFacade.
+FACADE keeps all configuration in one place (like a new has_many), also you can track which methods you actually need in your data model. this wouldn't be possible that easy with inheritance.
+
+Facadable#facade
+Facade#facaded
+
+
+idea: collect # REFAC lines
+
+
+running with Rails 2.3->4.0, 1.8.7 ..as that makes sense
+
+
+## Refinement
+
+injected into instance _after_ construction
+
+## Build
+
+
+
+FacadeClass
+  extend Build
+
+  module ClassMethods
+    def initializer
+    def another_class_method # FIXME: does that work?
+
+make anonymous class, allow overriding initializer and (works?) add class methods.
+
 
 ## Installation
 

data/Rakefile

@@ -1 +1,9 @@
 require "bundler/gem_tasks"
+require "rake/testtask"
+
+task :default => [:test]
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.test_files = FileList['test/**/*_test.rb']
+  test.verbose = true
+end

data/STUFF

@@ -1,4 +1,11 @@
 USE CASE:
 
 <% client.invoices.outstanding.each do |invoice| %>
-            <%= link_to invoice.invoice_number, {:controller => "party", :action => "invoice_show", :id => invoice.id, :entity_instance_id => client.party, :entity_type_id => EntityType::PARTY}, :onclick => "event.cancelBubble=true;" %> <%= number_to_currency(invoice.balance_out)
+            <%= link_to invoice.invoice_number, {:controller => "party", :action => "invoice_show", :id => invoice.id, :entity_instance_id => client.party, :entity_type_id => EntityType::PARTY}, :onclick => "event.cancelBubble=true;" %> <%= number_to_currency(invoice.balance_out)
+
+
+Invoice::Option::Rate <-- uses option everywhere
+  make that declaratively hook-able:
+    belongs_to Invoice::Option
+
+    Invoice::Option#rate => Rate.new(self)

data/disposable.gemspec

@@ -18,6 +18,12 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "uber"
+  spec.add_dependency "representable"
+
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "activerecord"
+  spec.add_development_dependency "sqlite3"
 end

data/gemfiles/Gemfile.rails-2.3

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in reform.gemspec
+gemspec :path => '../'
+
+gem 'rails', '2.3.18'

data/gemfiles/Gemfile.rails-2.3.lock

@@ -0,0 +1,41 @@
+PATH
+  remote: /home/nick/projects/disposable
+  specs:
+    disposable (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (2.3.18)
+      actionpack (= 2.3.18)
+    actionpack (2.3.18)
+      activesupport (= 2.3.18)
+      rack (~> 1.1.0)
+    activerecord (2.3.18)
+      activesupport (= 2.3.18)
+    activeresource (2.3.18)
+      activesupport (= 2.3.18)
+    activesupport (2.3.18)
+    minitest (5.0.8)
+    rack (1.1.6)
+    rails (2.3.18)
+      actionmailer (= 2.3.18)
+      actionpack (= 2.3.18)
+      activerecord (= 2.3.18)
+      activeresource (= 2.3.18)
+      activesupport (= 2.3.18)
+      rake (>= 0.8.3)
+    rake (10.1.0)
+    sqlite3 (1.3.8)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord
+  bundler (~> 1.3)
+  disposable!
+  minitest
+  rails (= 2.3.18)
+  rake
+  sqlite3

data/gemfiles/Gemfile.rails-3.0

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in reform.gemspec
+gemspec :path => '../'
+
+gem 'railties', '~> 3.0.11'
+gem 'activerecord', '~> 3.0.11'

data/gemfiles/Gemfile.rails-3.0.lock

@@ -0,0 +1,65 @@
+PATH
+  remote: /home/nick/projects/disposable
+  specs:
+    disposable (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    abstract (1.0.0)
+    actionpack (3.0.20)
+      activemodel (= 3.0.20)
+      activesupport (= 3.0.20)
+      builder (~> 2.1.2)
+      erubis (~> 2.6.6)
+      i18n (~> 0.5.0)
+      rack (~> 1.2.5)
+      rack-mount (~> 0.6.14)
+      rack-test (~> 0.5.7)
+      tzinfo (~> 0.3.23)
+    activemodel (3.0.20)
+      activesupport (= 3.0.20)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activerecord (3.0.20)
+      activemodel (= 3.0.20)
+      activesupport (= 3.0.20)
+      arel (~> 2.0.10)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.20)
+    arel (2.0.10)
+    builder (2.1.2)
+    erubis (2.6.6)
+      abstract (>= 1.0.0)
+    i18n (0.5.0)
+    json (1.8.0)
+    minitest (5.0.8)
+    rack (1.2.8)
+    rack-mount (0.6.14)
+      rack (>= 1.0.0)
+    rack-test (0.5.7)
+      rack (>= 1.0)
+    railties (3.0.20)
+      actionpack (= 3.0.20)
+      activesupport (= 3.0.20)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (~> 0.14.4)
+    rake (10.1.0)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    sqlite3 (1.3.8)
+    thor (0.14.6)
+    tzinfo (0.3.38)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 3.0.11)
+  bundler (~> 1.3)
+  disposable!
+  minitest
+  railties (~> 3.0.11)
+  rake
+  sqlite3

data/lib/disposable.rb

@@ -1,7 +1,12 @@
 require "disposable/version"
 
 module Disposable
-  # Your code goes here...
+  autoload :Twin,         'disposable/twin'
+  autoload :Composition,  'disposable/composition'
 end
 
-require "disposable/facade"
+require "disposable/facade"
+
+if defined?(ActiveRecord)
+  require 'disposable/facade/active_record'
+end

data/lib/disposable/composition.rb

@@ -0,0 +1,48 @@
+module Disposable
+  # Composition delegates accessors to models as per configuration.
+  #
+  #   class Album
+  #     include Disposable::Composition
+
+  #     map( {cd: [:id, :name], band: [:title]} )
+  #   end
+
+  #   album = Album.new(cd: CD.find(1), band: Band.new)
+  #   album.id #=> 1
+  #   album.title = "Ten Foot Pole"
+  module Composition
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def map(options)
+        @attr2obj = {}  # {song: ["title", "track"], artist: ["name"]}
+
+        options.each do |mdl, meths|
+          create_accessors(mdl, meths)
+          attr_reader mdl
+
+          meths.each { |m| @attr2obj[m.to_s] = mdl }
+        end
+      end
+
+      def create_accessors(model, methods)
+        accessors = methods.collect { |m| [m, "#{m}="] }.flatten
+        delegate *accessors << {:to => :"#{model}"}
+      end
+    end
+
+
+  private
+    def initialize(models)
+      models.each do |name, obj|
+        instance_variable_set(:"@#{name}", obj)
+      end
+
+      @_models = models.values
+    end
+
+    attr_reader:_models
+  end
+end

data/lib/disposable/facade.rb

@@ -1,25 +1,94 @@
 require "delegate"
+require "uber/inheritable_attr"
 
 module Disposable
   class Facade < SimpleDelegator
+    extend Uber::InheritableAttr
+    inheritable_attr :facade_options
+    self.facade_options = [nil, {}]
+
+
     module Facadable
-      def facade
+      # used in facaded.
+      def facade!(facade_class=nil)
+        facade_class ||= self.class.facade_class
+        facade_class.facade!(self)
+      end
+
+      def facade(facade_class=nil)
+        facade_class ||= self.class.facade_class
+        facade_class.facade(self)
+      end
+    end
+
+
+    class << self
+      def facades(klass, options={})
+        facade_options = [klass, options] # TODO: test.
+
+        self.facade_options = facade_options
+
+        facade_class = self
+        klass.instance_eval do
+          include Facadable
+          @_facade_class = facade_class
+
+          def facade_class
+            @_facade_class
+          end
+        end # TODO: use hooks.
+      end
+
+      # TODO: move both into Facader instance.
+      def facade(facaded)
+        if facade_options.last[:if]
+          return facaded unless facade_options.last[:if].call(facaded)
+        end
+
         # TODO: check if already facaded.
-        self.class.facade_class.new(self)
+        facade!(facaded)
       end
+
+      def facade!(facaded)
+        new(facaded)
+      end
+    end
+
+    # Forward #id to facaded. this is only a concern in 1.8.
+    def id
+      __getobj__.id
     end
 
-    def self.facades(klass)
-      facade_class = self
 
-      klass.instance_eval do
-        include Facadable
-        @_facade_class = facade_class
+    alias_method :facaded, :__getobj__
+
+
+    # Extend your facade and call Song.build, includes ClassMethods (extend constructor).
+    module Subclass
+      def build(*args)
+        facade_class = self
+        Class.new(facade_options.first).class_eval do
+          include facade_class::InstanceMethods # TODO: check if exists.
+          extend facade_class::ClassMethods # TODO: check if exists.
+
+          self
+        end.new(*args)
+      end
+
+      alias_method :subclass, :build
+    end
+
 
-        def facade_class
-          @_facade_class
+    module Refine
+      def initialize(facaded) # DISCUSS: should we override ::facade here?
+        super.tap do |res|
+          refine(facaded)
         end
-      end # TODO: use hooks.
+      end
+
+      def refine(facaded)
+        facaded.extend(self.class::Refinements)
+      end
     end
   end
 end

data/lib/disposable/facade/active_record.rb

@@ -0,0 +1,11 @@
+class Disposable::Facade
+  module ActiveRecord
+    def is_a?(klass)
+      # DISCUSS: should we use facade_options here for the class?
+      #return self.class.facade_options.first == klass if self.class.facade_options.first
+      # DISCUSS: make ::facades obligatory?
+
+      klass == __getobj__.class or super
+    end
+  end
+end

data/lib/disposable/twin.rb

@@ -0,0 +1,135 @@
+require 'uber/inheritable_attr'
+require 'representable/decorator'
+require 'representable/hash'
+
+module Disposable
+  class Twin
+    class Decorator < Representable::Decorator
+      include Representable::Hash
+      include AllowSymbols
+
+      # DISCUSS: same in reform, is that a bug in represntable?
+      def self.clone # called in inheritable_attr :representer_class.
+        Class.new(self) # By subclassing, representable_attrs.clone is called.
+      end
+
+      def self.build_config
+        super.extend(ConfigExtensions)
+      end
+
+      def self.twin_names
+        representable_attrs.twin_names
+      end
+
+      def twins(&block)
+        clone_config!.
+            find_all { |attr| attr[:form] }.
+            each(&block)
+        end
+
+      module ConfigExtensions
+        def twin_names
+          find_all { |attr| attr[:twin] }.
+          collect { |attr| attr.name }
+        end
+      end
+
+
+      class Save < self
+
+      end
+    end
+
+
+
+
+    extend Uber::InheritableAttr
+    inheritable_attr :representer_class
+    self.representer_class = Class.new(Decorator)
+
+    inheritable_attr :_model
+
+    def self.model(name)
+      self._model = name
+    end
+
+    def self.property(name, *args, &block)
+      attr_accessor name
+
+      representer_class.property(name, *args, &block)
+    end
+
+    def self.from(model) # TODO: private.
+      new(model)
+    end
+
+    def self.new(model=nil)
+      model, options = nil, model if model.is_a?(Hash) # sorry but i wanna have the same API as ActiveRecord here.
+      super(model || _model.new, *[options].compact) # TODO: make this nicer.
+    end
+
+    def self.find(id)
+      new(_model.find(id))
+    end
+
+    def self.save_representer
+      # TODO: do that only at compile-time!
+      save = Class.new(representer_class) # inherit configuration
+      save.representable_attrs.
+        find_all { |attr| attr[:twin] }.
+        each { |attr| attr.merge!(
+          :representable => true) }
+      save
+    end
+
+    def self.new_representer
+      representer = Class.new(representer_class) # inherit configuration
+      representer.representable_attrs.
+        find_all { |attr| attr[:twin] }.
+        each { |attr| attr.merge!(
+          :pass_options => true,
+          :prepare      => lambda { |object, args| args.binding[:twin].new(object) }) }
+      representer
+    end
+
+
+    def to_hash(*) # DISCUSS: do we want that here?
+      model
+    end
+
+    # it's important to stress that #save is the only entry point where we hit the database after initialize.
+    def save # use that in Reform::AR.
+      twin_names    = self.class.representer_class.twin_names
+
+      raw_attrs     = self.class.representer_class.new(self).to_hash
+      save_attrs    = raw_attrs.select { |k| twin_names.include?(k) }
+      save_attrs.values.map(&:save)
+
+
+      sync_attrs    = self.class.save_representer.new(self).to_hash
+      # this is ORM-specific:
+      model.update_attributes(sync_attrs) # this also does `album: #<Album>`
+
+      # FIXME: sync again, here, or just id?
+      self.id = model.id
+    end
+
+    # below is the code for a representable-style twin:
+
+    # TODO: improve speed when setting up a twin.
+    def initialize(model, options={})
+      @model = model
+
+      # DISCUSS: does the case exist where we get model AND options? if yes, test. if no, we can save the mapping and just use options.
+      from_hash(self.class.new_representer.new(model).to_hash.
+        merge(options))
+    end
+
+  private
+    def from_hash(options={})
+      self.class.representer_class.new(self).from_hash(options)
+    end
+
+    attr_reader :model # TODO: test
+  end
+end

data/lib/disposable/version.rb

@@ -1,3 +1,3 @@
 module Disposable
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/test/active_record_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+
+require 'active_record'
+class Invoice < ActiveRecord::Base
+  has_many :invoice_items
+end
+
+class InvoiceItem < ActiveRecord::Base
+  belongs_to :invoice
+end
+
+ActiveRecord::Base.establish_connection(
+  :adapter => "sqlite3",
+  :database => "#{Dir.pwd}/database.sqlite3"
+)
+
+# ActiveRecord::Schema.define do
+#   create_table :invoices do |table|
+#     table.timestamps
+#   end
+# end
+
+# ActiveRecord::Schema.define do
+#   create_table :invoice_items do |table|
+#     table.column :invoice_id, :string
+#     table.timestamps
+#   end
+# end
+
+# TODO: test auto-loading of Rails assets.
+require 'disposable/facade/active_record'
+
+class ActiveRecordAssociationsTest < MiniTest::Spec
+  class Item < Disposable::Facade
+    facades InvoiceItem
+
+    include Disposable::Facade::ActiveRecord
+  end
+
+  let (:invoice) { Invoice.new }
+  it "allows adding facades to associations" do
+    # tests #is_a?
+    InvoiceItem.new.facade.class.must_equal Item
+    InvoiceItem.new.facade.is_a?(InvoiceItem).must_equal true
+
+    invoice.invoice_items << InvoiceItem.new.facade
+  end
+
+
+  class InvoiceFacade < Disposable::Facade
+    facades ::Invoice
+
+    include Disposable::Facade::ActiveRecord
+    #has_many :items, :class_name => ::InvoiceItem, :foreign_key_name => :invoice_item_id
+
+    module InstanceMethods # IncludeMethods, Included
+      extend ActiveSupport::Concern
+      included do
+        has_many :items, :class_name => ::InvoiceItem, :foreign_key => :invoice_item_id
+
+        def self.name
+          "anon"
+        end
+
+      end
+    end
+    module ClassMethods # ExtendMethods, Extended
+    end
+
+    extend Disposable::Facade::Subclass
+  end
+
+  it "what" do
+    invoice = InvoiceFacade.subclass
+    invoice.items << item = InvoiceItem.new
+    # TODO: test items << Facade::Item.new
+
+    invoice.items.must_equal([item])
+  end
+end

data/test/facade_test.rb

@@ -0,0 +1,128 @@
+require 'test_helper'
+
+class FacadeTest < MiniTest::Spec
+  class Track < ::Track
+  end
+
+  class Song < Disposable::Facade
+    facades Track
+  end
+
+  class Hit < Disposable::Facade
+  end
+
+  let (:track) { Track.new }
+
+  it { track.class.must_equal Track }
+  it { track.facade.class.must_equal Song }
+
+  it "allows passing facade name" do # FIXME: what if track doesn't have Facadable?
+    track.facade(Hit).class.must_equal Hit
+  end
+  # DISCUSS: should this be Hit.facade(track) ?
+
+  describe "::facade" do
+    it { Hit.facade(track).class.must_equal Hit }
+  end
+
+  it "facades only once" do
+  end
+
+  describe "#id" do
+    let (:track) do Track.new.instance_eval {
+      def id; 1; end
+      self }
+    end
+
+    # DISCUSS: this actually tests Facadable.
+    it "calls original" do
+      track.facade.id.must_equal 1
+    end
+  end
+
+  it "responds to #facaded" do
+    Song.new(facaded = Object.new).facaded.must_equal facaded
+  end
+end
+
+class FacadesWithOptionsTest < MiniTest::Spec
+  class Track < ::Track
+  end
+
+  class Song < Disposable::Facade
+    facades Track, :if => lambda { |t| t.title }
+  end
+
+  it { Track.new(:title => "Trudging").facade.class.must_equal Song }
+  it { Track.new.facade.class.must_equal Track }
+
+  describe "#facade!" do
+    it "ignores :if" do
+      Track.new.facade!.class.must_equal Song
+    end
+  end
+end
+
+class SubclassTest < MiniTest::Spec
+  class Track
+    attr_reader :title
+
+    def initialize(options)
+      @title = options[:title] # we only save this key.
+      raise "rename didn't work" if options[:name]
+    end
+  end
+
+#require 'disposable/facade/active_record'
+  class Song < Disposable::Facade
+    facades Track
+    # has_one :album
+    # rename_options
+
+    extend Subclass # do ... end instead of ClassMethods.
+    #include Disposable::Facade::ActiveRecord
+
+    module InstanceMethods
+      # DISCUSS: this could be initializer do .. end
+      def initialize(options)
+        options[:title ] = options.delete(:name)
+        super
+      end
+    end
+    module ClassMethods
+
+    end
+  end
+
+  #it { Track.facade(Song).new(:name => "Bombs Away").title.must_equal "Bombs Away" }
+  it { Song.subclass(:name => "Bombs Away").title.must_equal "Bombs Away" }
+  # it "what" do
+  #   Song.build(:name => "Bombs Away").facade(Song).is_a?(Track).must_equal true
+  # end
+end
+
+
+class RefinementsTest < MiniTest::Spec
+  class Track
+    def length
+      duration.round(2)
+    end
+
+    def duration
+      4.321
+    end
+  end
+
+  class Song < Disposable::Facade
+    facades Track
+    include Disposable::Facade::Refine
+
+    module Refinements
+      def duration
+        5.309
+      end
+    end
+  end
+
+  it { Track.new.facade.length.must_equal 5.31 }
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'disposable'
+require 'minitest/autorun'
+
+class Track
+  def initialize(options={})
+    @title = options[:title]
+  end
+
+  attr_reader :title
+end

data/test/twin/active_record_test.rb

@@ -0,0 +1,104 @@
+require 'test_helper'
+
+require 'active_record'
+class Album < ActiveRecord::Base
+  has_many :songs
+end
+
+class Song < ActiveRecord::Base
+  belongs_to :album
+end
+
+ActiveRecord::Base.establish_connection(
+  :adapter => "sqlite3",
+  :database => "#{Dir.pwd}/database.sqlite3"
+)
+
+# ActiveRecord::Schema.define do
+#   create_table :songs do |table|
+#     table.column :title, :string
+#     table.column :album_id, :integer
+#     table.timestamps
+#   end
+
+#    create_table :albums do |table|
+#     table.column :name, :string
+#     table.timestamps
+#   end
+# end
+
+
+class TwinActiveRecordTest < MiniTest::Spec
+  module Twin
+    class Album < Disposable::Twin
+      property :id
+      property :name
+
+      model ::Album
+    end
+
+    class Song < Disposable::Twin
+      property :id
+      property :title
+      property :album, :twin => Album#, representable: true  #, setter: lambda { |v, args| self.album=(Album.from(v)) }
+
+      model ::Song
+    end
+  end
+
+
+
+  describe "::find" do
+    let (:song_model) { ::Song.create(:title => "Savage") }
+    subject { Twin::Song.find(song_model.id) }
+
+    it { subject.id.must_equal song_model.id }
+    it { subject.title.must_equal "Savage" }
+    it { subject.album.must_equal nil }
+  end
+
+
+
+  describe "::save, nested not set" do
+    let (:twin) { Twin::Song.new(:title => "1.80 Down") }
+    before { twin.save }
+    subject { ::Song.find(twin.id) }
+
+    it { subject.attributes.slice("id", "title").
+      must_equal({"id" => subject.id, "title" => "1.80 Down"}) }
+
+    it { subject.album.must_equal nil }
+  end
+
+
+  describe "::save, nested present" do
+    let (:song) { ::Song.new(:title => "Broken", :album => album) }
+    let (:album) { ::Album.new(:name => "The Process Of  Belief") }
+
+    let(:twin) { Twin::Song.from(song) }
+
+    before { twin.save } # propagate album.save
+
+    subject { ::Song.find(twin.id) }
+
+    it { subject.attributes.slice("id", "title").
+      must_equal({"id" => subject.id, "title" => "Broken"}) }
+
+    it { subject.album.must_equal album }
+  end
+
+
+  describe "::save, nested new" do
+    let(:twin) { Twin::Song.new(:title => "How It Goes", :album => Twin::Album.new(:name => "Billy Talent")) }
+
+    before { twin.save } # propagate album.save
+
+    subject { ::Song.find(twin.id) }
+
+    it {
+      subject.attributes.slice("id", "title").
+      must_equal({"id" => subject.id, "title" => "How It Goes"}) }
+
+    it { subject.album.attributes.slice("name").must_equal("name" => "Billy Talent") }
+  end
+end

data/test/twin/composition_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+class CompositionTest < MiniTest::Spec
+  module Model
+    Band  = Struct.new(:id, :title,)
+    Album = Struct.new(:id, :name)
+  end
+
+  module Twin
+    class Album #< Disposable::Twin
+      include Disposable::Composition
+      extend Disposable::Composition::ClassMethods # FIXME.
+
+      # property :id # DISCUSS: needed for #save.
+      # property :name,   :on => :album
+      # property :title,  :on => :band # as: :band_name
+
+      # model Model::Album
+
+      map( {:album => [:id, :name], :band => [:title]} )
+    end
+  end
+
+  let (:band) { Model::Band.new(1, "Frenzal Rhomb") }
+  let (:album) { Model::Album.new(2, "Dick Sandwhich") }
+  subject { Twin::Album.new(:album => album, :band => band) }
+
+  # it { subject.id.must_equal 2 }
+  it { subject.name.must_equal "Dick Sandwhich" }
+  it { subject.title.must_equal "Frenzal Rhomb" }
+
+  # it { subject.save }
+
+  it "raises when non-mapped property" do
+    assert_raises NoMethodError do
+      subject.raise_an_exception
+    end
+  end
+
+  describe "readers to models" do
+    it { subject.album.object_id.must_equal album.object_id }
+    it { subject.band.object_id.must_equal  band.object_id }
+  end
+
+
+  describe "#_models" do
+    it { subject.send(:_models).must_equal([album, band]) }
+    it { Twin::Album.new(:album => album).send(:_models).must_equal([album]) }
+  end
+end

data/test/twin/twin_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+
+class TwinTest < MiniTest::Spec
+  module Model
+    Song  = Struct.new(:id, :title, :album)
+    Album = Struct.new(:id, :name)
+  end
+
+
+  module Twin
+    class Album < Disposable::Twin
+      property :id # DISCUSS: needed for #save.
+      property :name
+
+      model Model::Album
+    end
+
+    class Song < Disposable::Twin
+      property :id # DISCUSS: needed for #save.
+      property :title
+      property :album, :twin => Album #, setter: lambda { |v, args| self.album=(Album.from(v)) }
+
+      model Model::Song
+    end
+  end
+
+
+  describe "::new" do # TODO: this creates a new model!
+    subject { Twin::Song.new }
+
+    it { subject.title.must_equal nil }
+    it { subject.album.must_equal nil }
+  end
+
+
+  describe "::new with arguments" do
+    let (:album) { Twin::Album.new(:name => "30 Years") }
+    subject { Twin::Song.new("title" => "Broken", "album" => album) }
+
+    it { subject.title.must_equal "Broken" }
+    it { subject.album.must_equal album }
+    it { subject.album.name.must_equal "30 Years" }
+  end
+
+
+  describe "::new with :symbols" do
+    subject { Twin::Song.new(:title => "Broken") }
+
+    it { subject.title.must_equal "Broken" }
+    it { subject.album.must_equal nil }
+  end
+
+
+  # DISCUSS: make ::from private.
+  describe "::from" do
+    let (:song) { Model::Song.new(1, "Broken", album) }
+    let (:album) { Model::Album.new(2, "The Process Of  Belief") }
+
+    subject {Twin::Song.from(song) }
+
+    it { subject.title.must_equal "Broken" }
+    it { subject.album.must_be_kind_of Twin::Album }
+    it { subject.album.name.must_equal album.name }
+  end
+end
+
+
+class TwinDecoratorTest < MiniTest::Spec
+  subject { TwinTest::Twin::Song.representer_class }
+
+  it { subject.twin_names.must_equal ["album"] }
+end
+
+# from is as close to from_hash as possible
+# there should be #to in a perfect API, nothing else.
+
+
+# should #new create empty associated models?

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: disposable
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-20 00:00:00.000000000 Z
+date: 2014-04-25 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: uber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: representable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +66,48 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Domain-Oriented Refactoring Framework.
 email:
 - apotonick@gmail.com
@@ -46,15 +116,30 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - STUFF
+- database.sqlite3
 - disposable.gemspec
+- gemfiles/Gemfile.rails-2.3
+- gemfiles/Gemfile.rails-2.3.lock
+- gemfiles/Gemfile.rails-3.0
+- gemfiles/Gemfile.rails-3.0.lock
 - lib/disposable.rb
+- lib/disposable/composition.rb
 - lib/disposable/facade.rb
+- lib/disposable/facade/active_record.rb
+- lib/disposable/twin.rb
 - lib/disposable/version.rb
+- test/active_record_test.rb
+- test/facade_test.rb
+- test/test_helper.rb
+- test/twin/active_record_test.rb
+- test/twin/composition_test.rb
+- test/twin/twin_test.rb
 homepage: ''
 licenses:
 - MIT
@@ -75,8 +160,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Domain-Oriented Refactoring Framework.
-test_files: []
+test_files:
+- test/active_record_test.rb
+- test/facade_test.rb
+- test/test_helper.rb
+- test/twin/active_record_test.rb
+- test/twin/composition_test.rb
+- test/twin/twin_test.rb