platanus 0.0.29 → 0.0.30

data/lib/platanus/stacked2.rb

@@ -0,0 +1,174 @@
+# stacked.rb : Stackable attributes for ActiveRecord
+#
+# Copyright April 2012, Ignacio Baixas +mailto:ignacio@platan.us+.
+
+module Platanus
+
+  ## Adds the has_stacked association to an ActiveRecord model.
+  #
+  # TODO
+  #
+  module StackedAttr2
+
+    class NotSupportedError < StandardError; end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      # Adds an stacked attribute to the model.
+      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
+          instance_var = "@_last_#{tname_single}".to_sym
+          send :define_method, top_value_prop do
+            # Storing the last stacked value will not prevent race conditions
+            # when simultaneous updates occur.
+            last = instance_variable_get instance_var
+            return last unless last.nil?
+            instance_variable_set(instance_var, self.send(tname).first)
+          end
+          send :define_method, "#{top_value_prop}=" do |_top|
+            instance_variable_set(instance_var, _top)
+          end
+        end
+        send :private, "#{top_value_prop}="
+
+        prefix = if _options[:cache_prf].nil? then 'last_' else _options.delete(:cache_prf) end # TODO: deprecate
+
+        # generate virtual attributes
+        changes = {}
+        stacked_model = tname_class.constantize
+        stacked_model.accessible_attributes.each do |attr_name|
+          send :define_method, "#{attr_name}=" do |value| changes[attr_name] = value end
+          send :define_method, "#{attr_name}" do
+            return changes[attr_name] if changes.has_key? attr_name
+            return self.send(prefix + attr_name) if self.respond_to? prefix + attr_name # Return cached value if avaliable
+            top = self.send top_value_prop
+            return nil if top.nil?
+            return top.send attr_name
+          end
+          attr_accessible attr_name
+        end
+
+        # prepare cached attributes
+        to_cache = _options.delete(:cached)
+        unless to_cache.nil?
+          to_cache = to_cache.map do |cache_attr|
+            unless cache_attr.is_a? Hash
+              name = cache_attr.to_s
+              # attr_protected(prefix + name)
+              { to: prefix + name, from: name }
+            else
+              # TODO: Test whether options are valid.
+              cache_attr
+            end
+          end
+        end
+
+        # callbacks
+        on_stack = _options.delete(:on_stack)
+
+        # 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?
+
+        # setup main association
+        has_many _name, _options
+
+        cache_step = ->(_ctx, _top, _top_is_new) {
+          # 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, _top_is_new)
+            end
+            _ctx.send(cache_attr[:to].to_s + '=', value)
+          end
+        }
+
+        after_step = ->(_ctx, _top) {
+          # update top value property
+          _ctx.send("#{top_value_prop}=", _top)
+
+          # execute after callback
+          _ctx.send(on_stack, _top) unless on_stack.nil?
+        }
+
+        # before saving model, load changes from virtual attributes.
+        before_save do
+          if changes.count > 0
+            obj = stacked_model.new(changes)
+            changes = {} # since push sometimes saves, then we must prevent a stack overflow by unsetting changes here.
+
+            cache_step.call(self, obj, true)
+            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)
+          end
+        end
+
+        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, true)
+            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
+        end
+
+        send :define_method, "push_#{tname_single}" do |obj|
+          begin
+            return send("push_#{tname_single}!", obj)
+          rescue ActiveRecord::RecordInvalid
+            return false
+          end
+        end
+
+        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, false)
+              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
+    end
+  end
+end

data/lib/platanus/version.rb

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

data/platanus.gemspec

@@ -14,4 +14,6 @@ Gem::Specification.new do |gem|
   gem.name          = "platanus"
   gem.require_paths = ["lib","lib/platanus"]
   gem.version       = Platanus::VERSION
+
+  gem.add_runtime_dependency "multi_json", [">= 1.3.2"]
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: platanus
 version: !ruby/object:Gem::Version
-  version: 0.0.29
+  version: 0.0.30
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-29 00:00:00.000000000 Z
-dependencies: []
+date: 2012-10-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.2
 description: Platan.us utility gem
 email:
 - ignacio@platan.us
@@ -36,6 +52,7 @@ files:
 - lib/platanus/onetime.rb
 - lib/platanus/serializers/json_sym.rb
 - lib/platanus/stacked.rb
+- lib/platanus/stacked2.rb
 - lib/platanus/templates/prawn.rb
 - lib/platanus/templates/spreadsheet.rb
 - lib/platanus/traceable.rb