lolita 3.1.18 → 3.2.0.rc1

data/lib/lolita/hooks.rb

@@ -59,154 +59,6 @@ module Lolita
   # ==Named hooks
   # See Lolita::Hooks::NamedHook for details.
   module Hooks
-    class Runner
-
-      class << self
-        def singleton_hook(hook_object,hook_name)
-          class << hook_object
-            def hooks_runned(name=nil)
-              @hooks_runned ||=[]
-              @hooks_runned << name if name
-              @hooks_runned
-            end
-          end
-
-          hook_object.hooks_runned(hook_name)
-        end
-
-        def runned?(hook_object,hook_name)
-          if hook_object.respond_to?(:hooks_runned)
-            hook_object.hooks_runned.include?(hook_name)
-          end
-        end
-
-        def singleton_hooks
-          @singleton_hooks || {}
-        end
-      end
-     
-      attr_accessor :hooks_run_scope, :given_callback_content
-      attr_writer :hooks_scope
-
-      def initialize(hook_class,hook_name, options)
-        @hook_class = hook_class
-        @hook_name = hook_name
-        @options = options
-        @options[:once] = @options[:once] == true ? @hook_class : @options[:once]
-      end
-
-      # Hooks scope is used to execute callbacks. By default it is class itself.
-      def hooks_scope
-        @hooks_scope || @hook_class
-      end
-
-      def run(&block)
-        if !@options[:once] || (@options[:once] && !self.class.runned?(@options[:once],@hook_name))
-          self.class.singleton_hook(@options[:once],@hook_name)
-          result = nil
-          in_hooks_scope(@options[:scope],@options[:run_scope]) do 
-            callback = get_callback(@hook_name)
-            result = run_callback(callback,&block)
-          end
-          result
-        end
-      end
-
-      # Call callback block inside of run block.
-      # ====Example
-      #     MyClass.run(:before_save) do 
-      #        do_stuff
-      #        let_content # execute callback block(-s) in same scope as run is executed.
-      #     end
-      def let_content
-        if self.given_callback_content.respond_to?(:call)
-          run_block(self.given_callback_content)
-        elsif self.given_callback_content
-          self.given_callback_content
-        end
-      end
-
-      protected
-
-       # Switch between self and given <em>scope</em>. Block will be executed with <em>scope</em>.
-      # And after that it will switch back to self.
-      def in_hooks_scope(scope,run_scope=nil)
-        begin
-          this = self
-          self.hooks_scope=scope || @hook_class
-          self.hooks_scope.define_singleton_method(:let_content) do
-            this.let_content
-          end
-          if run_scope
-            run_scope.define_singleton_method(:let_content) do
-              this.let_content
-            end
-          end
-          self.hooks_run_scope = run_scope || self.hooks_scope
-          yield
-        ensure
-          self.hooks_scope = @hook_class
-          self.hooks_run_scope = self.hooks_scope
-        end
-      end
-
-      # Return all callbacks
-      # If scope is not class then it merge class callbacks with scope callbacks. That means that
-      # class callbacks always will be called before scope callbacks.
-      def get_callback(name)
-        scope_callbacks = hooks_scope.callbacks[name.to_sym] || {}
-  
-        @hook_class.superclasses.each do |const_name|
-          scope_callbacks = @hook_class.collect_callbacks_from(name,const_name,scope_callbacks)
-        end
-        scope_callbacks
-      end
-
-      # Run callback. Each callback is Hash with <i>:methods</i> Array and </i>:blocks</i> Array
-      def run_callback(callback,&block)
-        method_results=run_methods(callback[:methods],&block)
-        block_results=run_blocks(callback[:blocks],&block)
-        method_results+block_results
-      end
-
-      # Run methods from <em>methods</em> Array
-      def run_methods methods, &block
-        result = ""
-        (methods||[]).each do |method_name|
-          result << (hooks_run_scope.__send__(method_name,&block)).to_s
-        end
-        result
-      end
-
-      # Run blocks from <em>blocks</em> Array. Also it set #given_callback_content if block is given, this
-      # will allow to call #let_content. Each block is runned with #run_block.
-      # After first run result of first block become #given_callback_content, and when next block
-      # call #let_content, this string will be returned for that block
-      def run_blocks blocks,&given_block
-        result=""
-
-        self.given_callback_content=block_given? ? given_block : nil
-
-        if blocks && !blocks.empty?
-          blocks.each do |block|
-            result << (run_block(block,&given_block)).to_s
-            self.given_callback_content=result
-          end
-        elsif block_given?
-          self.given_callback_content=nil
-          result << run_block(given_block).to_s
-        end
-        result
-      end
-
-      # Run block in scope. 
-      def run_block block, &given_block
-        hooks_run_scope.instance_eval(&block)
-      end
-
-
-    end # end of Runner
-
     def self.included(base)
       base.extend(ClassMethods)
       base.extend(CommonMethods)
@@ -240,14 +92,28 @@ module Lolita
     end
 
     module ClassMethods
+      attr_accessor :hooks_run_scope
 
-      def hooks_scope=(value)
-        @hooks_scope = value
+      # Setter for #hook_scope.
+      def hooks_scope=(object)
+        @hooks_scope=object
       end
 
-      def hooks_scope 
-        @hooks_scope || self
+      # Hooks scope is used to execute callbacks. By default it is class itself.
+      def hooks_scope
+        @hooks_scope||self
+      end
+
+      # Setter for #callback_content
+      def given_callback_content=(content)
+        @given_callback_content=content
       end
+
+      # Callback content is used to let callback content executed insede of run block.
+      def given_callback_content
+        @given_callback_content
+      end
+
       # All hooks for class. This is Array of hook names.
       def hooks
         @hooks||=[]
@@ -297,15 +163,6 @@ module Lolita
         }
       end
 
-      def in_hooks_scope(scope)
-        begin
-          self.hooks_scope = scope
-          yield
-        ensure
-          self.hooks_scope = self
-        end
-      end
-
       # run is used to execute callback. Method accept one or more <i>hook_names</i> and optional block.
       # It will raise error if hook don't exist for this class. Also it accept <em>:scope</em> options, that
       # is used to #get_callbacks and #run_callbacks.
@@ -314,10 +171,16 @@ module Lolita
       #     # this will call callbacks in MyClass instance scope, that means that self will be MyClass instance.
       def run(hook_name,*args,&block)
 
+        result=nil
         options=args ? args.extract_options! : {}
+
         raise Lolita::HookNotFound, "Hook #{hook_name} is not defined for #{self}." unless self.has_hook?(hook_name)
-        runner = Lolita::Hooks::Runner.new(self,hook_name,options)
-        runner.run(&block)
+        in_hooks_scope(options[:scope],options[:run_scope]) do
+          callback=get_callback(hook_name)
+          result=run_callback(callback,&block)
+        end
+
+        result
       end
 
       # Is hook with <em>name</em> is defined for class.
@@ -333,6 +196,20 @@ module Lolita
         end
       end
 
+      # Call callback block inside of run block.
+      # ====Example
+      #     MyClass.run(:before_save) do 
+      #        do_stuff
+      #        let_content # execute callback block(-s) in same scope as run is executed.
+      #     end
+      def let_content
+        if self.given_callback_content.respond_to?(:call)
+          run_block(self.given_callback_content)
+        elsif self.given_callback_content
+          self.given_callback_content
+        end
+      end
+
       # Set #method_missing
       def recognize_hook_methods method_name, *args, &block
         if method_name.to_s.match(/^run_(\w+)/)
@@ -341,6 +218,81 @@ module Lolita
         end
       end
 
+      protected
+
+      # Switch between self and given <em>scope</em>. Block will be executed with <em>scope</em>.
+      # And after that it will switch back to self.
+      def in_hooks_scope(scope,run_scope=nil)
+        begin
+          self.hooks_scope=scope||self
+          if run_scope
+            run_scope.define_singleton_method(:let_content) do
+              scope.let_content
+            end
+          end
+          self.hooks_run_scope=run_scope || self.hooks_scope
+          yield
+        ensure
+          self.hooks_scope=self
+          self.hooks_run_scope=self.hooks_scope
+        end
+      end
+
+      # Run callback. Each callback is Hash with <i>:methods</i> Array and </i>:blocks</i> Array
+      def run_callback(callback,&block)
+        method_results=run_methods(callback[:methods],&block)
+        block_results=run_blocks(callback[:blocks],&block)
+        method_results+block_results
+      end
+
+      # Run methods from <em>methods</em> Array
+      def run_methods methods, &block
+        result=""
+        (methods||[]).each do |method_name|
+          result << (hooks_run_scope.__send__(method_name,&block)).to_s
+        end
+        result
+      end
+
+      # Run blocks from <em>blocks</em> Array. Also it set #given_callback_content if block is given, this
+      # will allow to call #let_content. Each block is runned with #run_block.
+      # After first run result of first block become #given_callback_content, and when next block
+      # call #let_content, this string will be returned for that block
+      def run_blocks blocks,&given_block
+        result=""
+
+        self.given_callback_content=block_given? ? given_block : nil
+
+        if blocks && !blocks.empty?
+          blocks.each do |block|
+            result << (run_block(block,&given_block)).to_s
+            self.given_callback_content=result
+          end
+        elsif block_given?
+          self.given_callback_content=nil
+          result << run_block(given_block).to_s
+        end
+        result
+      end
+
+      # Run block in scope. 
+      def run_block block, &given_block
+        hooks_run_scope.instance_eval(&block)
+      end
+
+      # Return all callbacks
+      # If scope is not class then it merge class callbacks with scope callbacks. That means that
+      # class callbacks always will be called before scope callbacks.
+      def get_callback(name)
+        scope_callbacks=hooks_scope.callbacks[name.to_sym] || {}
+  
+        superclasses.each do |const_name|
+          scope_callbacks=collect_callbacks_from(name,const_name,scope_callbacks)
+        end
+        scope_callbacks
+      end
+
+
       def collect_callbacks_from(name,const_name,scope_callbacks)
           class_callbacks=const_name.callbacks[name.to_sym] || {}
           [:methods,:blocks].each do |attr|
@@ -387,6 +339,11 @@ module Lolita
         self.class.run(*hook_names,options,&block)
       end
 
+      # See Lolita::Hooks::ClassMethods#let_content
+      def let_content
+        self.class.let_content
+      end
+
       # See Lolita::Hooks::ClassMethods#method_missing
       def method_missing(*args,&block)
         unless self.class.recognize_hook_methods(*args,:scope=>self,&block)

data/lib/lolita/lazy_loader.rb

@@ -36,9 +36,6 @@ module Lolita
           @class_instance=@lazy_class.new(&@eval_block)
         end
       end
-      if @class_instance.respond_to?(:after_initialize,true)
-        @class_instance.send(:after_initialize)
-      end
       @class_instance.__send__(method_name,*args,&block)
     end
 

data/lib/lolita/mapping.rb

@@ -18,16 +18,12 @@ module Lolita
   # Also eahc request containers information with mapping related to it.
   class Mapping
     attr_reader :class_name,:path,:singular,:plural,:path_prefix,:module,:controllers,:as
-    attr_reader :visible, :only, :append_to
     alias :name :singular
     
     
     def initialize(name,options={})
       # TODO how it is when lolita plugin extend default path and there is module is this not break the logic?
       @as=options[:as]
-      @visible = options.keys.include?(:visible) ? options[:visible] : true
-      @append_to = options[:append_to]
-      @only = options[:only] || nil
       @plural=(options[:as] ? options[:as] : name).to_sym
       @singular=(options[:singular] || @plural.to_s.singularize).to_sym
       @class_name=(options[:class_name] || name.to_s.classify).to_s
@@ -54,25 +50,6 @@ module Lolita
     def url_name #TODO test what with namespace
       "#{@path}_#{@plural}"
     end
-
-    def add_to_navigation_tree
-      tree = Lolita::Navigation::Tree[:"left_side_navigation"]
-      if self.visible
-        if self.append_to
-          parent_branch = tree.branches.detect{|b| b.options[:system_name] == self.append_to}
-          unless parent_branch
-            parent_branch = tree.append(nil,:title => lambda{|branch| 
-              return ::I18n.t("lolita.navigation." + branch.options[:system_name])
-              }, :system_name => self.append_to
-            )
-          end
-          tree = parent_branch.children
-        end
-        unless tree.branches.detect{|b| b.object.is_a?(Lolita::Mapping) && b.object.to==self.to}
-          tree.append(self)
-        end
-      end
-    end
     
   end
 end

data/lib/lolita/modules/rest.rb

@@ -2,7 +2,7 @@ module ActionDispatch::Routing
   class Mapper
     protected
     def lolita_rest_route mapping, controllers
-      resources mapping.plural,:only=>mapping.only.is_a?(Array) ? mapping.only : [:index,:new,:create,:edit,:update,:destroy],
+      resources mapping.plural,:only=>[:index,:new,:create,:edit,:update,:destroy],
         :controller=>controllers[:rest],:module=>mapping.module
     end
   end

data/lib/lolita/navigation/branch.rb

@@ -2,9 +2,8 @@ module Lolita
   module Navigation
     class Branch
 
-      attr_accessor :name,:object
+      attr_accessor :title,:name,:object
       attr_reader :level,:options,:tree,:parent
-      attr_writer :title
 
       def initialize(*args)
         
@@ -14,22 +13,6 @@ module Lolita
         assign_attributes_from_options
       end
 
-      def method_missing method_name, *args
-        if @options.keys.include?(method_name) || @options.keys.include?(method_name.to_s)
-          @options[method_name] || @options[method_name.to_s]
-        else
-          super
-        end
-      end
-
-      def title
-        if @title && @title.respond_to?(:call)
-          @title.call(self)
-        else
-          @title || self.object.to.model_name.human(:count=>2)
-        end
-      end
-
       def tree=(new_tree)
         raise ArgumentError, "Tree already assigned" if self.tree || !new_tree.is_a?(Lolita::Navigation::Tree)
         @tree=new_tree
@@ -59,10 +42,6 @@ module Lolita
         self.tree.get_branch_index(self)
       end
 
-      def subtree?
-        self.children.branches.any?
-      end
-
       def siblings
         index=self.index
         {
@@ -87,34 +66,6 @@ module Lolita
         move_to(:prepend,*args)
       end
 
-      def active?(view)
-        resource = view.respond_to?(:resource_class) ? view.send(:resource_class) : nil rescue nil
-        request = view.send(:request)
-        self_active = if self.object.is_a?(Lolita::Mapping) && self.object && self.object.to == resource
-          true
-        elsif self.options[:active].respond_to?(:call)
-          self.options[:active].call(view,self)
-        elsif self.options[:url]
-          self.options[:url] == request.path
-        end
-        self_active || (self.children.any? && self.children.branches.detect{|c_branch| c_branch.active?(view)})
-      end
-
-      def visible?(view)
-        self_visible = if self.object && self.object.respond_to?(:to)
-          view.send(:can?,:read,self.object.to)
-        elsif self.options[:visible]
-          if self.options[:visible].respond_to?(:call)
-            self.options[:visible].call(view,self,branch)
-          else
-            self.options[:visible]
-          end
-        else
-          true
-        end
-        self_visible && (self.children.any? && self.children.visible?(view) || self.children.empty?)
-      end
-
       def self.get_or_create(*args)
         options=args ? args.extract_options! : {}
         args||=[]
@@ -174,8 +125,6 @@ module Lolita
         @options.each{|key,value|
           if self.respond_to?(:"#{key}=")
             self.send(:"#{key}=",@options.delete(key))
-          else
-            self.options[key] = value
           end
         }
       end