platanus 0.0.32 → 0.0.49

data/Gemfile

@@ -1,5 +1,3 @@
 source 'https://rubygems.org'
 gemspec
-gem 'rspec'
-gem 'rspec-expectations'
 

data/lib/platanus/activable.rb

@@ -47,6 +47,8 @@ module Platanus
       self.transaction do
         run_callbacks :remove do
 
+          # TODO: disable update callbacks and validations!
+
           # Retrieve dependant properties and remove them.
           self.class.reflect_on_all_associations.select do |assoc|
             if assoc.options[:dependent] == :destroy

data/lib/platanus/canned2.rb

@@ -94,78 +94,19 @@ module Platanus
     # TODO: example
     class Profile
 
-      def is_avaliable()
-        return @shared.all? do |rule|
-          rule_ctx = RuleContext.new _ctx, _tests, @def_matcher, @def_resource
-          rule_ctx.instance_eval(&rule)
-          rule_ctx.passed?
-        end
-      end
-
-      def is_forbidden()
-        # TODO: local forbids
-      end
-
-      def is_allowed()
-      end
-
-      def
-
-      def allowance_for(_ctx, _action, _tests)
-
-        # all shared rules must pass
-        return :not_applicable unless @shared.all? do |rule|
-          rule_ctx = RuleContext.new _ctx, _tests, @def_matcher, @def_resource
-          rule_ctx.instance_eval(&rule)
-          rule_ctx.passed?
-        end
-
-        # TODO: local forbids
-
-        # process base profile
-        unless @base.nil?
-          result = @base.process _ctx, _action, _tests
-          return result if result == :not_applicable or result == :forbidden
-          matches << resu
-        end
-
-        # process subprofiles
-        if @isolated.each do |profile|
-          result = profile.process _ctx, _action, _tests
-          return :forbidden if result == :forbidden
-          result = :allowed if result == :allowed
-        end
-
-        # see if any of the registered rules pass
-        return :allowed if @rules[_action].any? do |rule|
-          rule_ctx = RuleContext.new _ctx, _tests, @def_matcher, @def_resource
-          rule_ctx.instance_eval(&rule)
-          rule_ctx.passed?
-        end
-
-        return :not_allowed
-      end
+      attr_reader :rules
+      attr_reader :def_matcher
+      attr_reader :def_resource
 
       # The initializer takes another profile as rules base.
-      def initialize(_def_matcher, _def_resource, _base=nil)
-        @base = _base
+      def initialize(_base, _def_matcher, _def_resource)
         @rules = Hash.new { |h, k| h[k] = [] }
-        @isolated = []
-        @shared = []
-
+        _base.rules.each { |k, tests| @rules[k] = tests.clone } unless _base.nil?
         raise Error.new 'Must provide a default test' if _def_matcher.nil?
         @def_matcher = _def_matcher
         @def_resource = _def_resource
       end
 
-      def always(_upon=nil, &_block)
-        @shared << (_upon || _block)
-      end
-
-      def isolate(_options={}, &_block)
-        @isolated << Profile.new _options.fetch(, @def_matcher), _options.fetch(, @def_resource)
-      end
-
       ## Adds an "allowance" rule
       def allow(_action, _upon=nil, &_block)
         @rules[_action] << (_upon || _block)
@@ -176,6 +117,11 @@ module Platanus
         # TODO
       end
 
+      ## Clear all rules related to an action
+      def clear(_action)
+        @rules[_action] = []
+      end
+
       ## SHORT HAND METHODS
 
       def upon(_expr=nil, &_block)

data/lib/platanus/stacked2.rb

@@ -6,7 +6,7 @@ module Platanus
 
   ## Adds the has_stacked association to an ActiveRecord model.
   #
-  # TODO
+  # TODO: Investigate how to turn this into an authentic association.
   #
   module StackedAttr2
 
@@ -28,49 +28,56 @@ module Platanus
         # prepare names
         tname = _name.to_s
         tname_single = tname.singularize
-        tname_class = _options.fetch(:class_name, tname_single.camelize)
+        tname_class = _options.fetch :class_name, tname_single.camelize
+        stacked_model = tname_class.constantize
+        prefix = if _options[:cache_prf].nil? then 'last_' else _options.delete(:cache_prf) end # TODO: deprecate?
 
-        # generate top_value property
+        # Generate top_value property
+        #
+        # How this property is generated can vary depending on given parameters or table structure:
+        # * If a top_value_key is provided in options, then a belongs_to association is created using it as foreign key.
+        # * If a top_xxx_id column is present, then a belongs_to association is created using if as foreign key.
+        # * If no key is provided, then a shorcut method that retrieves the stack's top is generated
+        #
         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)
+        top_value_key = if _options.has_key? :top_value_key
+          belongs_to top_value_prop.to_sym, class_name: tname_class, foreign_key: _options[:top_value_key], autosave: true
+          _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
+          belongs_to top_value_prop.to_sym, class_name: tname_class, autosave: true
+          "#{top_value_prop}_id"
         else
-          instance_var = "@_last_#{tname_single}".to_sym
+          top_value_var = "@_stacked_#{tname}_top".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)
+            last = instance_variable_get top_value_var
+            return last unless last.nil? or !last.persisted?
+            instance_variable_set(top_value_var, self.send(tname).all.first)
           end
+          nil
         end
-        send :private, "#{top_value_prop}="
 
-        prefix = if _options[:cache_prf].nil? then 'last_' else _options.delete(:cache_prf) end # TODO: deprecate
+        # When called inside callbacks, returns the new value being put at top of the stack.
+        new_value_var = "@_stacked_#{tname}_new"
+        send :define_method, "#{tname_single}_will" do
+          instance_variable_get(new_value_var)
+        end
 
-        # 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
+        # When called inside callbacks, will return the top value unless a new value is
+        # being pushed, in that case it returns the new value
+        last_value_var = "@_stacked_#{tname}_last"
+        send :define_method, "#{tname_single}_is" do
+          instance_variable_get(last_value_var)
         end
 
-        # prepare cached attributes
+        # Prepare cached attributes
+        #
+        # Attribute caching allows the parent model to store the top value for
+        # some of the stacked model attributes (defined in options using the cached key)
+        #
         to_cache = _options.delete(:cached)
-        unless to_cache.nil?
+        if to_cache
           to_cache = to_cache.map do |cache_attr|
             unless cache_attr.is_a? Hash
               name = cache_attr.to_s
@@ -83,61 +90,137 @@ module Platanus
           end
         end
 
-        # callbacks
-        on_stack = _options.delete(:on_stack)
+        # register callbacks
+        define_callbacks "stack_#{tname_single}"
 
-        # 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?
+        # push logic
+        __update_stack = ->(_ctx, _top, _new_top, _save_quiet, &_block) do
+          begin
+            # make xx_top_value avaliable for event handlers
+            _ctx.instance_variable_set(new_value_var, _top) if _new_top
+            _ctx.instance_variable_set(last_value_var, _top)
 
-        # setup main association
-        has_many _name, _options
+            _ctx.run_callbacks "stack_#{tname_single}" do
+
+              # cache required fields
+              # TODO: improve cache: convention over configuration!
+              # cache should be automatic given certain column names and should include aliased attribues and virtual attributes.
+              # has_stacked :things, cache: { prefix: '', aliases: { xx => xx }, exclude: [], virtual: { xx => xx } }
+              if to_cache
+                to_cache.each do |cache_attr|
+                  value = if cache_attr.has_key? :from
+                    _top.nil? ? nil : _top.send(cache_attr[:from])
+                  else
+                    _ctx.send(cache_attr[:virtual])
+                  end
+                  _ctx.send(cache_attr[:to].to_s + '=', value)
+                end
+              end
+
+              _block.call if _block
+
+              if _new_top
+                # TODO: this leaves the invalid record on top of the stack and invalid cached values,
+                # maybe validation should ocurr before caching...
+                raise ActiveRecord::RecordInvalid.new(_top) unless _ctx.send(tname) << _top
+              end
+
+              # reset top_value_prop to top
+              if top_value_key
+                if _save_quiet
+                  top_id = if _top.nil? then nil else _top.id end
+                  if _ctx.send(top_value_key) != top_id
+                    _ctx.update_column(top_value_key, top_id)
+                    _ctx.send(top_value_prop, false) # reset belongs_to cache
+                  end
+                else
+                  _ctx.send("#{top_value_prop}=", _top)
+                end
+              else
+                _ctx.instance_variable_set(top_value_var, _top)
+              end
+            end
+          ensure
+            _ctx.instance_variable_set(new_value_var, nil)
+            _ctx.instance_variable_set(last_value_var, nil)
+          end
+        end
+
+        # Attribute mirroring
+        #
+        # Mirroring allows using the top value attributes in the parent model,
+        # it also allows modifying the attributes in the parent model, if the model is
+        # then saved, the modified attributes are wrapped in a new stack model object and put
+        # on top.
+        #
+        mirror_cache_var = "@_stacked_#{tname}_mirror".to_sym
+        if _options.delete(:mirroring)
+          stacked_model.accessible_attributes.each do |attr_name|
+
+            unless self.method_defined? "#{attr_name}="
+              send :define_method, "#{attr_name}=" do |value|
+                mirror = instance_variable_get(mirror_cache_var)
+                mirror = instance_variable_set(mirror_cache_var, {}) if mirror.nil?
+                mirror[attr_name] = value
+              end
+            else
+              Rails.logger.warn "stacked: failed to mirror setter for #{attr_name} in #{self.to_s}"
+            end
+
+            unless self.method_defined? attr_name
+              send :define_method, attr_name do
+                mirror = instance_variable_get(mirror_cache_var)
+                return mirror[attr_name] if !mirror.nil? and mirror.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
 
-        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])
+              send :define_method, "#{attr_name}_changed?" do
+                mirror = instance_variable_get(mirror_cache_var)
+                return true if !mirror.nil? and mirror.has_key? attr_name
+                return self.send(prefix + attr_name + '_changed?') if self.respond_to? prefix + attr_name + '_changed?' # return cached value if avaliable
+                return true # for now just return true for non cached attributes
+              end
+
+              attr_accessible attr_name
             else
-              _ctx.send(cache_attr[:virtual], _top, _top_is_new)
+              Rails.logger.warn "stacked: failed to mirror getter for #{attr_name} in #{self.to_s}"
             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)
+
+          # before saving model, load changes from virtual attributes.
+          set_callback :save, :around do |&_block|
+
+            mirror = instance_variable_get(mirror_cache_var)
+            if !mirror.nil? and mirror.count > 0
+
+              # propagate non cached attributes (only if record is not new and there is a top state)
+              unless self.new_record?
+                top = self.send top_value_prop
+                unless top.nil?
+                  stacked_model.accessible_attributes.each do |attr_name|
+                    mirror[attr_name] = top.send(attr_name) unless mirror.has_key? attr_name
+                  end
+                end
+              end
+
+              obj = stacked_model.new(mirror)
+              instance_variable_set(mirror_cache_var, {}) # reset mirror changes
+              __update_stack.call(self, obj, true, true, &_block)
+
+            else _block.call end
           end
         end
 
+        # Push methods
+
         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...
+            __update_stack.call(self, obj, true, false) { self.save! if self.new_record? }
+            self.save! if self.changed?
           end
         end
 
@@ -149,15 +232,13 @@ module Platanus
           end
         end
 
+        # Restore methods
+
         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?
+            top = self.send(tname).all.first
+            __update_stack.call(self, top, false, false)
+            self.save! if self.changed?
           end
         end
 
@@ -168,6 +249,13 @@ module Platanus
             return false
           end
         end
+
+        # setup main association
+        # TODO: Support other kind of ordering, this would require to reevaluate top on every push
+        _options[:order] = 'created_at DESC, id DESC'
+        _options[:limit] = 1 if _options[:limit].nil?
+        _options.delete(:limit) if _options[:limit] == :no_limit
+        has_many _name, _options
       end
     end
   end

data/lib/platanus/version.rb

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

data/platanus.gemspec

@@ -12,8 +12,9 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "platanus"
-  gem.require_paths = ["lib","lib/platanus"]
+  gem.require_paths = ["lib"]
   gem.version       = Platanus::VERSION
 
   gem.add_runtime_dependency "multi_json", [">= 1.3.2"]
+  gem.add_development_dependency "rspec"
 end

data/spec/canned2_spec.rb

@@ -17,12 +17,10 @@ describe Platanus::Canned2 do
   class DummyCtx
 
     attr_reader :params
-    attr_reader :action_name
     attr_reader :current_user
 
-    def initialize(_user, _action_name=nil, _params={})
+    def initialize(_user, _params={})
       @current_user = _user
-      @action_name = _action_name
       @params = _params
     end
   end
@@ -42,7 +40,6 @@ describe Platanus::Canned2 do
       allow 'rute1#action3', upon { same(:char1, key: "current_user.char1") }
       allow 'rute1#action4', upon(:current_user) { same(:param2, key: "char2") and checks(:test1) }
       allow 'rute1#action5', upon(:current_user) { passes { current_user.char2 == params[:param2] } }
-      allow 'rute2', upon(:current_user) { same(:char1) and action_is_not(:create) }
 
       # Complex routes
       allow 'rute1#action5' do
@@ -52,8 +49,8 @@ describe Platanus::Canned2 do
     end
   end
 
-  let(:good_ctx) { DummyCtx.new(DummyUsr.new(10, "200"), 'create', char1: '10', param2: '200') }
-  let(:bad_ctx) { DummyCtx.new(DummyUsr.new(10, 30), 'create', char1: '10', param2: '200') }
+  let(:good_ctx) { DummyCtx.new(DummyUsr.new(10, "200"), char1: '10', param2: '200') }
+  let(:bad_ctx) { DummyCtx.new(DummyUsr.new(10, 30), char1: '10', param2: '200') }
 
   describe "._run" do
     context 'when using single context rules' do
@@ -76,9 +73,6 @@ describe Platanus::Canned2 do
       it "does authorize on rute with context and inline test" do
         Roles.can?(good_ctx, :user, 'rute1#action5').should be_true
       end
-      it "does not authorize on rute with context, match and action_is_not" do
-        Roles.can?(good_ctx, :user, 'rute2').should be_false
-      end
     end
 
     context 'when using multiple context rules' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: platanus
 version: !ruby/object:Gem::Version
-  version: 0.0.32
+  version: 0.0.49
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-07 00:00:00.000000000 Z
+date: 2012-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -27,6 +27,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.3.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Platan.us utility gem
 email:
 - ignacio@platan.us
@@ -68,7 +84,6 @@ post_install_message:
 rdoc_options: []
 require_paths:
 - lib
-- lib/platanus
 required_ruby_version: !ruby/object:Gem::Requirement
   none: false
   requirements: