disposable 0.0.6 → 0.0.7

data/lib/disposable/composition.rb

@@ -12,9 +12,12 @@ module Disposable
   #     map( {cd: [[:id], [:name]], band: [[:id, :band_id], [:title]]} )
   #   end
   #
+  # Composition adds #initialize to the includer.
+  #
   #   album = Album.new(cd: CD.find(1), band: Band.new)
   #   album.id #=> 1
   #   album.title = "Ten Foot Pole"
+  #   album.band_id #=> nil
   #
   # It allows accessing the contained models using the `#[]` reader.
   module Composition

data/lib/disposable/twin.rb

@@ -1,46 +1,20 @@
 require 'uber/inheritable_attr'
 require 'representable/decorator'
 require 'representable/hash'
+require 'disposable/twin/representer'
+require 'disposable/twin/option'
+
+# Twin.new(model/composition hash, options)
+#   assign hash to @fields
+#   write: write to @fields
+#   sync/save is the only way to write back to the model.
 
 module Disposable
   class Twin
-    class Definition < Representable::Definition
-      def dynamic_options
-        super + [:twin]
-      end
-    end
-
-
-    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
-        Config.new(Definition)
-      end
-
-      def twin_names
-        representable_attrs.
-          find_all { |attr| attr[:twin] }.
-          collect { |attr| attr.name.to_sym }
-      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, options={}, &block)
       options[:private_name]  = options.delete(:as) || name
@@ -48,8 +22,8 @@ module Disposable
 
       representer_class.property(name, options, &block).tap do |definition|
         mod = Module.new do
-          define_method(name) { @fields[name.to_s] } # TODO: move to separate method.
-          define_method("#{name}=") { |value| @fields[name.to_s] = value }
+          define_method(name)       { read_property(name, options[:private_name]) }
+          define_method("#{name}=") { |value| write_property(name, options[:private_name], value) } # TODO: this is more like prototyping.
         end
         include mod
       end
@@ -59,157 +33,43 @@ module Disposable
       property(name, options.merge(:collection => true), &block)
     end
 
-    # this method should only be called in finders, and considered semi-private. it should only be called once as the top stack entry.
-    def self.from(model, *args) # TODO: private.
-      new(model, *args)
-    end
-
-    def self.new(model={}, object_map=ObjectMap.new)
-      super(model, object_map)
-    end
-
 
-    # TODO: improve speed when setting up a twin.
     module Initialize
-      def initialize(model, object_map)
+      def initialize(model, options={})
         @fields = {}
+        @model  = model
 
-        setup!(model, object_map)
-      end
-
-      def setup!(model, object_map)
-        options = {}
-        options, model = model, self.class._model.new if model.is_a?(Hash)
-
-
-        # model, options = nil, model if model.is_a?(Hash) # sorry but i wanna have the same API as ActiveRecord here.
-        @model = model #|| self.class._model.new
-
-        object_map[@model] = self # DISCUSS: how to we handle compositions here?
-
-        from_hash(
-          self.class.new_representer.new(@model).to_hash(:object_map => object_map). # always read from model, even when it's new.
-          merge(options)
-        )
+        from_hash(options) # assigns known properties from options.
       end
     end
-    include Initialize # TODO: simplify so the whole thing with object map gets optional.
+    include Initialize
 
 
-    require 'disposable/twin/finders'
-    extend Finders
-
-    # hash for #update_attributes (model API): {title: "Future World", album: <Album>}
-    def self.save_representer
-      # TODO: do that only at compile-time!
-      save = Class.new(write_representer) # inherit configuration
-      save.representable_attrs.
-        find_all { |attr| attr[:twin] }.
-        each { |attr| attr.merge!(
-          :representable => true,
-          :serialize     => lambda { |obj, args| obj.send(:model) }) }
-
-        save.representable_attrs.each do |attr|
-          attr.merge!(:as => attr[:private_name])
-        end
-
-      save
-    end
-
-    # transform incoming model into twin API hash.
-    def self.new_representer
-      representer = Class.new(representer_class) # inherit configuration
-
-      # wrap incoming nested model in its Twin.
-      representer.representable_attrs.
-        find_all { |attr| attr[:twin] }.
-        each { |attr| attr.merge!(
-          :prepare      => lambda { |object, args|
-            if twin = args.user_options[:object_map][object]
-              twin
-            else
-              args.binding[:twin].evaluate(nil).new(object, args.user_options[:object_map])
-            end
-          }) }
-
-      # song_title => model.title
-      representer.representable_attrs.each do |attr|
-        attr.merge!(
-          :getter => lambda { |args|
-            args.represented.send("#{args.binding[:private_name]}") }, # DISCUSS: can't we do that with representable's mechanics?
-        )
-      end
-
-      representer
-    end
-
     # read/write to twin using twin's API (e.g. #record= not #album=).
     def self.write_representer
       representer = Class.new(representer_class) # inherit configuration
     end
 
-    # call save on all nested twins.
-    def self.pre_save_representer
-      representer = Class.new(write_representer)
-      representer.representable_attrs.
-        each { |attr| attr.merge!(
-          :representable => true,
-          :serialize => lambda do |twin, args|
-            processed = args.user_options[:processed_map]
-
-            twin.save(processed) unless processed[twin] # don't call save if it is already scheduled.
-          end
-        )}
-
-      representer
+  private
+    def read_property(name, private_name)
+      return @fields[name.to_s] if @fields.has_key?(name.to_s)
+      @fields[name.to_s] = read_from_model(private_name)
     end
 
+    def read_from_model(getter)
+      model.send(getter)
+    end
 
-    # it's important to stress that #save is the only entry point where we hit the database after initialize.
-    def save(processed_map=ObjectMap.new) # use that in Reform::AR.
-      processed_map[self] = true
-
-      pre_save = self.class.pre_save_representer.new(self)
-      pre_save.to_hash(:include => pre_save.twin_names, :processed_map => processed_map) # #save on nested Twins.
-
-
-
-      # what we do right now
-      # call save on all nested twins - how does that work with dependencies (eg Album needs Song id)?
-      # extract all ORM attributes
-      # write to model
-
-      sync_attrs    = self.class.save_representer.new(self).to_hash
-      # puts "sync> #{sync_attrs.inspect}"
-      # 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
+    def write_property(name, private_name, value)
+       @fields[name.to_s] = value
     end
 
-  private
-    def from_hash(options={})
+    def from_hash(options)
       self.class.write_representer.new(self).from_hash(options)
     end
 
     attr_reader :model # TODO: test
 
-
-    class ObjectMap < Hash
-    end
-
-    # class Composition < self
-    #   def initialize(hash)
-    #     hash = hash.first
-    #     composition = Class.new do
-    #       include Disposable::Composition
-    #       map( {:song => [:song_title], :requester => [:name]})
-    #       self
-    #     end.new(hash)
-
-    #     super(composition)
-    #   end
-    # end
+    include Option
   end
 end

data/lib/disposable/twin/composition.rb

@@ -0,0 +1,27 @@
+module Disposable
+  class Twin
+    class Composition
+      include Disposable::Composition
+
+      extend Uber::InheritableAttr
+      inheritable_attr :twin_classes
+      self.twin_classes = {}
+
+      # this creates one Twin per composed.
+      def self.property(name, options, &block)
+        twin_classes[options[:on]] ||= Class.new(Twin)
+        twin_classes[options[:on]].property(name, options, &block)
+
+        map options[:on] => [[name]] # why is Composition::map so awkward?
+      end
+      # TODO: test and implement ::collection
+
+      def initialize(composed)
+        twins = {}
+        composed.each { |name, model| twins[name] = self.class.twin_classes[name].new(model) }
+
+        super(twins)
+      end
+    end
+  end
+end

data/lib/disposable/twin/new.rb

@@ -0,0 +1,30 @@
+module Disposable
+  class Twin
+        # transform incoming model into twin API hash.
+    def self.new_representer
+      representer = Class.new(representer_class) # inherit configuration
+
+      # wrap incoming nested model in its Twin.
+      representer.representable_attrs.
+        find_all { |attr| attr[:twin] }.
+        each { |attr| attr.merge!(
+          :prepare      => lambda { |object, args|
+            if twin = args.user_options[:object_map][object]
+              twin
+            else
+              args.binding[:twin].evaluate(nil).new(object, args.user_options[:object_map])
+            end
+          }) }
+
+      # song_title => model.title
+      representer.representable_attrs.each do |attr|
+        attr.merge!(
+          :getter => lambda { |args|
+            args.represented.send("#{args.binding[:private_name]}") }, # DISCUSS: can't we do that with representable's mechanics?
+        )
+      end
+
+      representer
+    end
+  end
+end

data/lib/disposable/twin/option.rb

@@ -3,24 +3,10 @@ module Disposable::Twin::Option
     base.extend ClassMethods
   end
 
-
-  def setup!(model, options)
-    # FIXME: merge that with original Twin.
-
-    @model = model #|| self.class._model.new
-
-    from_hash(
-      self.class.new_representer.new(@model).to_hash
-    )
-
-    # TODO: just make new_representer with :getter for option!
-    # IDEA: how can we bring that in line with Composition?
-    from_hash(options)
-  end
-
   module ClassMethods
     def option(name, options={})
-      property(name, options.merge(:readable => false))
+      # default: nil will always set an option in the, even when not in the incoming options.
+      property(name, options.merge(:readable => false, :default => nil))
     end
   end
 end

data/lib/disposable/twin/representer.rb

@@ -0,0 +1,29 @@
+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
+        Config.new(Definition)
+      end
+
+      def twin_names
+        representable_attrs.
+          find_all { |attr| attr[:twin] }.
+          collect { |attr| attr.name.to_sym }
+      end
+    end
+
+    class Definition < Representable::Definition
+      def dynamic_options
+        super + [:twin]
+      end
+    end
+  end
+end

data/lib/disposable/twin/save.rb

@@ -0,0 +1,43 @@
+module Disposable
+  class Twin
+        # call save on all nested twins.
+    def self.pre_save_representer
+      representer = Class.new(write_representer)
+      representer.representable_attrs.
+        each { |attr| attr.merge!(
+          :representable => true,
+          :serialize => lambda do |twin, args|
+            processed = args.user_options[:processed_map]
+
+            twin.save(processed) unless processed[twin] # don't call save if it is already scheduled.
+          end
+        )}
+
+      representer
+    end
+
+
+    # it's important to stress that #save is the only entry point where we hit the database after initialize.
+    def save(processed_map=ObjectMap.new) # use that in Reform::AR.
+      processed_map[self] = true
+
+      pre_save = self.class.pre_save_representer.new(self)
+      pre_save.to_hash(:include => pre_save.twin_names, :processed_map => processed_map) # #save on nested Twins.
+
+
+
+      # what we do right now
+      # call save on all nested twins - how does that work with dependencies (eg Album needs Song id)?
+      # extract all ORM attributes
+      # write to model
+
+      sync_attrs    = self.class.save_representer.new(self).to_hash
+      # puts "sync> #{sync_attrs.inspect}"
+      # 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
+  end
+end

data/lib/disposable/twin/save_.rb

@@ -0,0 +1,21 @@
+module Disposable
+  class Twin
+    # hash for #update_attributes (model API): {title: "Future World", album: <Album>}
+    def self.save_representer
+      # TODO: do that only at compile-time!
+      save = Class.new(write_representer) # inherit configuration
+      save.representable_attrs.
+        find_all { |attr| attr[:twin] }.
+        each { |attr| attr.merge!(
+          :representable => true,
+          :serialize     => lambda { |obj, args| obj.send(:model) }) }
+
+        save.representable_attrs.each do |attr|
+          attr.merge!(:as => attr[:private_name])
+        end
+
+      save
+    end
+
+  end
+end

data/lib/disposable/twin/struct.rb

@@ -0,0 +1,14 @@
+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)
+
+        from_hash(model.merge(options))
+      end
+    end
+  end
+end