platanus 0.0.19 → 0.0.21

data/lib/platanus/stacked.rb

@@ -4,7 +4,9 @@
 
 module Platanus
 
-  # Adds the has_stacked association to an ActiveRecord model.
+  ## Adds the has_stacked association to an ActiveRecord model.
+  #
+  # TODO
   #
   module StackedAttr
 
@@ -17,61 +19,94 @@ module Platanus
     module ClassMethods
 
       # Adds an stacked attribute to the model.
-      def has_stacked(_name, _options={}, &block)
+      def has_stacked(_name, _options={})
+
+        # check option support
+        raise NotSupportedError.new('Only autosave mode is supported') if _options[:autosave] == false
+        raise NotSupportedError.new('has_many_through is not supported yet') if _options.has_key? :through
 
+        # prepare names
         tname = _name.to_s
         tname_single = tname.singularize
+        tname_class = _options.fetch(:class_name, tname_single.camelize)
+
+        # generate top_value property
+        top_value_prop = "top_#{tname_single}"
+        if _options.has_key? :top_value_key
+          belongs_to top_value_prop.to_sym, class_name: tname_class, foreign_key: _options.delete(:top_value_key)
+        elsif self.column_names.include? "#{top_value_prop}_id"
+          belongs_to top_value_prop.to_sym, class_name: tname_class
+        else
+          send :define_method, top_value_prop do
+            # Storing the last stacked value will not prevent race conditions
+            # when simultaneous updates occur.
+            return @_stacked_last unless @_stacked_last.nil?
+            @_stacked_last = self.send(tname).first
+          end
+          send :define_method, "#{top_value_prop}=" do |_top|
+            @_stacked_last = _top
+          end
+        end
+        send :private, "#{top_value_prop}="
 
+        # prepare cached attributes
         to_cache = _options.delete(:cached)
-        to_cache_prf = if _options[:cache_prf].nil? then 'last_' else _options.delete(:cache_prf) end
+        to_cache_prf = if _options[:cache_prf].nil? then 'last_' else _options.delete(:cache_prf) end # TODO: deprecate
 
-        # Retrieve callbacks
-        before_push = _options.delete(:before_push)
-        after_push = _options.delete(:after_push)
-
-        raise NotSupportedError.new('Only autosave mode is supported') if _options[:autosave] == false
-
-        _options[:order] = 'created_at DESC, id DESC'
-        _options[:limit] = 10 if _options[:limit].nil?
-
-        # Prepare cached attributes, generate read-only aliases without prefix.
         unless to_cache.nil?
-          to_cache = to_cache.map do |name|
-            name = name.to_s
-            # attr_protected(to_cache_prf + name)
-            send :define_method, name do self.send(to_cache_prf + name) end
-            name
+          to_cache = to_cache.map do |cache_attr|
+            unless cache_attr.is_a? Hash
+              name = cache_attr.to_s
+              # attr_protected(to_cache_prf + name)
+              send :define_method, name do self.send(to_cache_prf + name) end # generate read-only aliases without prefix. TODO: deprecate
+              { to: to_cache_prf + name, from: name }
+            else
+              # TODO: Test whether options are valid.
+              cache_attr
+            end
           end
         end
 
-        private
-        has_many _name, _options
-        public
+        # callbacks
+        on_stack = _options.delete(:on_stack)
 
-        send :define_method, "push_#{tname_single}!" do |obj|
-          self.class.transaction do
+        # limits and ordering
+        # TODO: Support other kind of ordering, this would require to reevaluate top on every push
+        _options[:order] = 'created_at DESC, id DESC'
+        _options[:limit] = 10 if _options[:limit].nil?
 
-            # execute before callbacks
-            self.send(before_push, obj) unless before_push.nil?
-            block.call(self, obj) unless block.nil?
+        # setup main association
+        has_many _name, _options
 
-            # cache required fields
-            unless to_cache.nil?
-              to_cache.each { |name| send(to_cache_prf + name + '=', obj.send(name)) }
+        cache_step = ->(_ctx, _top) {
+          # cache required fields
+          return if to_cache.nil?
+          to_cache.each do |cache_attr|
+            value = if cache_attr.has_key? :from
+              _top.nil? ? _top : _top.send(cache_attr[:from])
+            else
+              _ctx.send(cache_attr[:virtual], _top)
             end
+            _ctx.send(cache_attr[:to].to_s + '=', value)
+          end
+        }
 
-            # push attribute, this will save the model if new.
-            raise ActiveRecord::RecordInvalid.new(obj) unless self.send(tname).send('<<',obj)
+        after_step = ->(_ctx, _top) {
+          # update top value property
+          _ctx.send("#{top_value_prop}=", _top)
 
-            # update inverse association if posible
-            if self.attributes.has_key? "top_#{tname_single}_id"
-              self["top_#{tname_single}_id"] = obj.id
-            else
-              @_stacked_last = obj
-            end
+          # execute after callback
+          _ctx.send(on_stack, _top) unless on_stack.nil?
+        }
 
-            # execute after callback
-            self.send(after_push, obj) unless after_push.nil?
+        send :define_method, "push_#{tname_single}!" do |obj|
+          self.class.transaction do
+
+            # cache, then save if new, then push and finally process state
+            cache_step.call(self, obj)
+            self.save! if self.new_record? # make sure there is an id BEFORE pushing
+            raise ActiveRecord::RecordInvalid.new(obj) unless send(tname).send('<<',obj)
+            after_step.call(self, obj)
 
             self.save! if self.changed? # Must save again, no other way...
           end
@@ -79,18 +114,29 @@ module Platanus
 
         send :define_method, "push_#{tname_single}" do |obj|
           begin
-            return self.send("push_#{tname_single}!", obj)
+            return send("push_#{tname_single}!", obj)
           rescue ActiveRecord::RecordInvalid
             return false
           end
         end
 
-        unless self.column_names.include? "top_#{tname_single}_id"
-          send :define_method, "top_#{tname_single}" do
-            # Storing the last stacked value will not prevent race conditions
-            # when simultaneous updates occur.
-            return @_stacked_last unless @_stacked_last.nil?
-            @_stacked_last = self.send(_name).first
+        send :define_method, "restore_#{tname}!" do
+          self.class.transaction do
+
+              # find current top, then restore stack state
+              top = self.send(_name).first
+              cache_step.call(self, top)
+              after_step.call(self, top)
+
+              self.save! if self.changed?
+          end
+        end
+
+        send :define_method, "restore_#{tname}" do
+          begin
+            return send("restore_#{tname}!")
+          rescue ActiveRecord::RecordInvalid
+            return false
           end
         end
       end

data/lib/platanus/version.rb

@@ -1,3 +1,3 @@
 module Platanus
-  VERSION = "0.0.19" # 0.1 will come with tests!
+  VERSION = "0.0.21" # 0.1 will come with tests!
 end

data/lib/platanus.rb

@@ -5,7 +5,6 @@ require 'platanus/stacked'
 require 'platanus/activable'
 require 'platanus/traceable'
 require 'platanus/layered'
-require 'platanus/cmap'
 require 'platanus/enum'
 require 'platanus/http_helpers'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: platanus
 version: !ruby/object:Gem::Version
-  version: 0.0.19
+  version: 0.0.21
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-03 00:00:00.000000000 Z
+date: 2012-10-08 00:00:00.000000000 Z
 dependencies: []
 description: Platan.us utility gem
 email:
@@ -28,7 +28,6 @@ files:
 - lib/platanus/activable.rb
 - lib/platanus/api_base.rb
 - lib/platanus/canned.rb
-- lib/platanus/cmap.rb
 - lib/platanus/enum.rb
 - lib/platanus/gcontroller.rb
 - lib/platanus/http_helpers.rb

data/lib/platanus/cmap.rb

@@ -1,80 +0,0 @@
-module Platanus
-
-  module Cmap
-
-    class InvalidName < Exception; end
-
-    def self.included(base)
-      base.cattr_accessor :cmap
-      base.cmap = Hash.new { |hash, key| hash[key] = {} }
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-
-      def cmap_register(_key, _value, _cat=nil)
-        if _cat.nil?; self.cmap[_key] = _value
-        else; self.cmap[_cat.to_s][_key] = _value
-        end
-      end
-
-      def cmap_convert(_key, _cat=nil)
-        if _cat.nil?; return self.cmap[_key]
-        else; return self.cmap[_cat.to_s][_key]
-        end
-      end
-
-      def cmap_convert_back(_value, _cat=nil)
-        if _cat.nil?; return self.cmap.key(_value)
-        else; return self.cmap[_cat.to_s].key(_value)
-        end
-      end
-
-      def str_attr_accessor(_target, _options={})
-        str_attr_reader(_target,_options)
-        str_attr_writer(_target,_options)
-      end
-
-      def str_attr_writer(_target, _options={})
-        _target = _target.to_s
-        _self = _options.fetch(:extend, self)
-        _cat = _options[:cat]
-        _cmap = self.cmap
-
-        _self.send(:define_method, _target + '_str=') do |value|
-          if _cat.nil?; self.send(_target + '=', _cmap.fetch(value))
-          else; self.send(_target + '=', _cmap[_cat.to_s].fetch(value)); end
-        end
-      end
-
-      def str_attr_reader(_target, _options={})
-        _target = _target.to_s
-        _self = _options.fetch(:extend, self)
-        _cat = _options[:cat]
-        _cmap = self.cmap
-
-        _self.send(:define_method, _target + '_str') do
-          if _cat.nil?; _cmap.key(self.send(_target))
-          else; _cmap[_cat.to_s].key(self.send(_target)); end
-        end
-      end
-
-      # private
-      # def cmap_converters(_cat_or_name=nil)
-        # # Define new class methods.
-        # klass = (class << self; self; end)
-        # klass.send(:define_method, _target + '_to_str') do |value|
-          # if _cat.nil?; _cmap.index(value)
-          # else; _cmap[_cat].index(value); end
-        # end
-#
-        # klass.send(:define_method, 'str_to_' + _target) do |value|
-          # if _cat.nil?; _cmap.fetch(value)
-          # else; _cmap[_cat].fetch(value); end
-        # end
-      # end
-    end
-  end
-end
-
-