lolita 3.3.5 → 3.3.6

data/lib/lolita/hooks/named_hook.rb

@@ -1,126 +1,126 @@
-module Lolita
-  module Hooks
-
-    # Named hooks is special hook class that uses Lolita::Hooks, but also add some other useful methods and behaviour.
-    # Main reason for named hooks is to provide filter like hooks. First thing is to define it for futher use.
-    #    Lolita::Hooks::NamedHook.add(:people) 
-    # Next step is to add hook for it. Like this
-    #    Lolita::Hooks.people.add_hook(:get_married)
-    # And then add callback for named hook.
-    #    Lolita::Hooks.person.get_merried do
-    #      go_to_honeymoon
-    #    end
-    #    john=Person.new("John")
-    #    john.run(:get_merried) # and now john will go to honeymoon
-    # Hooks are added for pluralized hook name, even if you pass like #add(:person), it will create named hook
-    # with <i>people</i> name. This will be class, and when you call #person it will create instance for that class.
-    class NamedHook
-
-      class << self
-        # Add named hook name with NamedHook class. Each hook is Hash and keys is filters. 
-        # Also it have <em>:_class</em> key that is class for named hook.
-        def add(name)
-          name=name.to_s.pluralize
-          named_hooks[name.to_sym]={:_class=>get_named_hook_class(name)}
-          add_filter_method(name)
-        end
-
-        # All defined named hook names
-        def names
-          named_hooks.keys
-        end
-
-        # Detect that named hook exist with given name.
-        def exist?(name)
-          self.names.include?(name)
-        end
-
-        # Find or create named hook instance.
-        def find_or_create(hook_name,filter_name)
-          unless filtered_hook=self.find(hook_name,filter_name)
-            named_hook=self.by_name(hook_name)
-            named_hook[:_class].new(hook_name,filter_name)
-          else
-            filtered_hook
-          end
-        end
-
-        # Find named hook filter.
-        # ====Example
-        #     Lolita::Hooks::NamedHook.find(:components,:"list")
-        def find(hook_name,filter_name)
-          if named_hook=self.by_name(hook_name)
-            named_hook[filter_name.to_sym]
-          end
-        end
-
-        # Return named hook by given name.
-        def by_name(name)
-          name=name.to_s.pluralize
-          named_hooks[name.to_sym]
-        end
-
-        private
-
-        def named_hooks
-          @@named_hooks||={}
-          @@named_hooks
-        end
-
-        def add_filter_method(name)
-          self.class_eval <<-FILTER,__FILE__,__LINE__+1
-            class << Lolita::Hooks
-              def #{name.singularize}(name)
-                Lolita::Hooks::NamedHook.find_or_create("#{name.pluralize}",name)
-              end
-            end
-          FILTER
-        end
-
-        def get_named_hook_class(name)
-          klass=Class.new(Lolita::Hooks::NamedHook)
-          klass.instance_variable_set(:"@hook_name",name.to_sym)
-          klass.send(:include,Lolita::Hooks)
-          define_named_hook_class_methods(klass)
-          klass
-        end
-
-        def define_named_hook_class_methods(klass)
-          klass.class_eval do
-            attr_accessor :name,:hook_name
-            def initialize hook_name,name
-              named_hook=self.class.by_name(hook_name)
-              @name=name
-              @hook_name=hook_name
-              unless named_hook[name.to_sym]
-                named_hook[name.to_sym]=self
-              else
-                raise ArgumentError, "Named hook #{name} for #{hook_name} already exist!"
-              end
-            end
-
-            def self.hook_name
-              @hook_name
-            end
-
-            # def self.run(*hook_names,&block)
-            #   hook_names||=[]
-            #   hook_names.extract_options!
-            #   super(*hook_names,&block)
-            #   if named_hook=self.by_name(self.hook_name)
-            #     named_hook.each{|filter_name, filter|
-            #       unless filter_name.to_sym==:"_class"
-            #         self.run(*(hook_names + [{:scope=>filter}]),&block)
-            #       end
-            #     }
-            #   end
-            # end
-            
-          end
-        end
-
-      end
-
-    end
-  end
+module Lolita
+  module Hooks
+
+    # Named hooks is special hook class that uses Lolita::Hooks, but also add some other useful methods and behaviour.
+    # Main reason for named hooks is to provide filter like hooks. First thing is to define it for futher use.
+    #    Lolita::Hooks::NamedHook.add(:people) 
+    # Next step is to add hook for it. Like this
+    #    Lolita::Hooks.people.add_hook(:get_married)
+    # And then add callback for named hook.
+    #    Lolita::Hooks.person.get_merried do
+    #      go_to_honeymoon
+    #    end
+    #    john=Person.new("John")
+    #    john.run(:get_merried) # and now john will go to honeymoon
+    # Hooks are added for pluralized hook name, even if you pass like #add(:person), it will create named hook
+    # with <i>people</i> name. This will be class, and when you call #person it will create instance for that class.
+    class NamedHook
+
+      class << self
+        # Add named hook name with NamedHook class. Each hook is Hash and keys is filters. 
+        # Also it have <em>:_class</em> key that is class for named hook.
+        def add(name)
+          name=name.to_s.pluralize
+          named_hooks[name.to_sym]={:_class=>get_named_hook_class(name)}
+          add_filter_method(name)
+        end
+
+        # All defined named hook names
+        def names
+          named_hooks.keys
+        end
+
+        # Detect that named hook exist with given name.
+        def exist?(name)
+          self.names.include?(name)
+        end
+
+        # Find or create named hook instance.
+        def find_or_create(hook_name,filter_name)
+          unless filtered_hook=self.find(hook_name,filter_name)
+            named_hook=self.by_name(hook_name)
+            named_hook[:_class].new(hook_name,filter_name)
+          else
+            filtered_hook
+          end
+        end
+
+        # Find named hook filter.
+        # ====Example
+        #     Lolita::Hooks::NamedHook.find(:components,:"list")
+        def find(hook_name,filter_name)
+          if named_hook=self.by_name(hook_name)
+            named_hook[filter_name.to_sym]
+          end
+        end
+
+        # Return named hook by given name.
+        def by_name(name)
+          name=name.to_s.pluralize
+          named_hooks[name.to_sym]
+        end
+
+        private
+
+        def named_hooks
+          @@named_hooks||={}
+          @@named_hooks
+        end
+
+        def add_filter_method(name)
+          self.class_eval <<-FILTER,__FILE__,__LINE__+1
+            class << Lolita::Hooks
+              def #{name.singularize}(name)
+                Lolita::Hooks::NamedHook.find_or_create("#{name.pluralize}",name)
+              end
+            end
+          FILTER
+        end
+
+        def get_named_hook_class(name)
+          klass=Class.new(Lolita::Hooks::NamedHook)
+          klass.instance_variable_set(:"@hook_name",name.to_sym)
+          klass.send(:include,Lolita::Hooks)
+          define_named_hook_class_methods(klass)
+          klass
+        end
+
+        def define_named_hook_class_methods(klass)
+          klass.class_eval do
+            attr_accessor :name,:hook_name
+            def initialize hook_name,name
+              named_hook=self.class.by_name(hook_name)
+              @name=name
+              @hook_name=hook_name
+              unless named_hook[name.to_sym]
+                named_hook[name.to_sym]=self
+              else
+                raise ArgumentError, "Named hook #{name} for #{hook_name} already exist!"
+              end
+            end
+
+            def self.hook_name
+              @hook_name
+            end
+
+            # def self.run(*hook_names,&block)
+            #   hook_names||=[]
+            #   hook_names.extract_options!
+            #   super(*hook_names,&block)
+            #   if named_hook=self.by_name(self.hook_name)
+            #     named_hook.each{|filter_name, filter|
+            #       unless filter_name.to_sym==:"_class"
+            #         self.run(*(hook_names + [{:scope=>filter}]),&block)
+            #       end
+            #     }
+            #   end
+            # end
+            
+          end
+        end
+
+      end
+
+    end
+  end
 end

data/lib/lolita/lazy_loader.rb

@@ -1,55 +1,55 @@
-module Lolita
-  class LazyLoader
-
-    #attr_reader :lazy_class,:eval_block,:class_instance
-
-    def self.lazy_load(instance_name,var_name,lazy_class,*args,&block)
-      temp_var = instance_name.instance_variable_get(var_name)
-      is_loader = temp_var.to_s =~ /Lolita::LazyLoader/
-      if !temp_var || ((args && args.any? && is_loader && temp_var.__is_args_diff__(args)) || block_given?)
-        temp_var = instance_name.instance_variable_set(var_name,self.new(lazy_class,*args,&block))
-      end
-      if temp_var.to_s =~ /Lolita::LazyLoader/
-        temp_var = instance_name.instance_variable_set(var_name,temp_var.class_instance)
-      end
-      temp_var
-    end
-
-    def __is_args_diff__(args)
-      @args != args
-    end
-
-    def initialize(lazy_class,*args,&block)
-      @args = args || []
-      @lazy_class=lazy_class
-      @eval_block=block
-    end
-
-    def class_instance
-      @class_instance || self
-    end
-
-    def method_missing(method_name,*args,&block)
-      unless @class_instance
-        @args = @args.empty? && [nil] || @args
-        arity=@lazy_class.instance_method(:initialize).arity
-        if arity==-1 # when expectign *args
-          @class_instance=@lazy_class.new(*@args,&@eval_block)
-        elsif arity.abs>0 # when expecting specific number of arguments without any *args
-          @class_instance=@lazy_class.new(*@args.slice(0..arity.abs-1),&@eval_block)
-        else
-          @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
-
-    instance_methods.each { |method|
-      next if ["!","__is_args_diff__","hash","respond_to?","__id__","__send__","to_s","object_id","method_missing","class_instance","initialize", "__args__"].include?(method.to_s)
-      eval("undef :#{method}")
-    }
-  end
+module Lolita
+  class LazyLoader
+
+    #attr_reader :lazy_class,:eval_block,:class_instance
+
+    def self.lazy_load(instance_name,var_name,lazy_class,*args,&block)
+      temp_var = instance_name.instance_variable_get(var_name)
+      is_loader = temp_var.to_s =~ /Lolita::LazyLoader/
+      if !temp_var || ((args && args.any? && is_loader && temp_var.__is_args_diff__(args)) || block_given?)
+        temp_var = instance_name.instance_variable_set(var_name,self.new(lazy_class,*args,&block))
+      end
+      if temp_var.to_s =~ /Lolita::LazyLoader/
+        temp_var = instance_name.instance_variable_set(var_name,temp_var.class_instance)
+      end
+      temp_var
+    end
+
+    def __is_args_diff__(args)
+      @args != args
+    end
+
+    def initialize(lazy_class,*args,&block)
+      @args = args || []
+      @lazy_class=lazy_class
+      @eval_block=block
+    end
+
+    def class_instance
+      @class_instance || self
+    end
+
+    def method_missing(method_name,*args,&block)
+      unless @class_instance
+        @args = @args.empty? && [nil] || @args
+        arity=@lazy_class.instance_method(:initialize).arity
+        if arity==-1 # when expectign *args
+          @class_instance=@lazy_class.new(*@args,&@eval_block)
+        elsif arity.abs>0 # when expecting specific number of arguments without any *args
+          @class_instance=@lazy_class.new(*@args.slice(0..arity.abs-1),&@eval_block)
+        else
+          @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
+
+    instance_methods.each { |method|
+      next if ["!","__is_args_diff__","hash","respond_to?","__id__","__send__","to_s","object_id","method_missing","class_instance","initialize", "__args__"].include?(method.to_s)
+      eval("undef :#{method}")
+    }
+  end
 end

data/lib/lolita/navigation/tree.rb

@@ -1,133 +1,133 @@
-module Lolita
-  module Navigation
-    class Tree
-      include Enumerable
-      include Lolita::Hooks
-
-      class<<self
-        def remember(tree)
-          @@trees||={}
-          @@trees[tree.name.to_sym]=tree
-        end
-
-        def [](name)
-          @@trees||={}
-          @@trees[name]
-        end
-      end
-
-      add_hooks :before_branch_added, :after_branch_added
-
-      attr_reader :name,:root,:default_position,:branches,:parent
-
-      def initialize(name)
-        @name=name
-        @default_possition=:append
-        @branches=[]
-      end
-
-      def each 
-        @branches.each do |branch|
-          yield branch
-          if branch.children.any?
-            branch.children.each do |child|
-              yield child
-            end
-          end
-        end
-      end
-
-      def root?
-        !parent
-      end
-
-      def visible?(view)
-        self.branches.inject([]){|result,branch| 
-          if branch.visible?(view)
-            result << true
-          else
-            result
-          end
-        }.any?
-      end
-
-      def populate_urls_in_branches(view)
-        self.each do |branch|
-          branch.populate_url(view)
-        end
-      end
-
-      def method_missing method_name, *args
-        @branches.send(method_name.to_sym,*args)
-      end
-
-
-      def append(*branch)
-        adding_branch(*branch) do |fixed_branch|
-          @branches<<fixed_branch
-        end
-      end
-
-      def prepend(*branch)
-        adding_branch(*branch) do |fixed_branch|
-          @branches.unshift(fixed_branch)
-        end
-      end
-
-      def after(given_branch,*other_branch) 
-        index=get_branch_index(given_branch)
-
-        adding_branch(*other_branch) do |fixed_branch|
-          put_in_branches(fixed_branch,index)
-        end
-      end
-
-      def before(given_branch,*other_branch)
-        index=get_branch_index(given_branch)
-
-        adding_branch(*other_branch) do |fixed_branch|
-          put_in_branches(fixed_branch,index-1)
-        end
-      end
-
-      def get_branch_index(given_branch)
-        @branches.each_with_index{|branch,index|
-          return index if given_branch==branch
-        }
-        raise ArgumentError, "Branch #{given_branch.inspect} not exists in #{self.inspect}"
-      end
-
-      def set_parent(new_parent)
-        @parent=new_parent
-      end
-      
-      private
-
-      def adding_branch *branch
-        self.run(:before_branch_added,*branch)
-        fixed_branch=fix_branch(*branch)
-        yield fixed_branch
-        @last_branch=fixed_branch
-        self.run(:after_branch_added,fixed_branch)
-        fixed_branch
-      end
-
-      def fix_branch(*branch)
-        unless branch[0].is_a?(Lolita::Navigation::Branch)
-          options=branch.extract_options!
-          Lolita::Navigation::Branch.get_or_create(*branch,options.merge(:tree=>self))
-        else
-          branch[0].tree=self
-          branch[0]
-        end
-      end
-
-      def put_in_branches branch,index
-        before_part=@branches.slice(0,index+1) || []
-        after_part=@branches.slice(index+1,@branches.size-index) || []
-        @branches=before_part+[branch]+after_part
-      end
-
-    end
-  end
+module Lolita
+  module Navigation
+    class Tree
+      include Enumerable
+      include Lolita::Hooks
+
+      class<<self
+        def remember(tree)
+          @@trees||={}
+          @@trees[tree.name.to_sym]=tree
+        end
+
+        def [](name)
+          @@trees||={}
+          @@trees[name]
+        end
+      end
+
+      add_hooks :before_branch_added, :after_branch_added
+
+      attr_reader :name,:root,:default_position,:branches,:parent
+
+      def initialize(name)
+        @name=name
+        @default_possition=:append
+        @branches=[]
+      end
+
+      def each 
+        @branches.each do |branch|
+          yield branch
+          if branch.children.any?
+            branch.children.each do |child|
+              yield child
+            end
+          end
+        end
+      end
+
+      def root?
+        !parent
+      end
+
+      def visible?(view)
+        self.branches.inject([]){|result,branch| 
+          if branch.visible?(view)
+            result << true
+          else
+            result
+          end
+        }.any?
+      end
+
+      def populate_urls_in_branches(view)
+        self.each do |branch|
+          branch.populate_url(view)
+        end
+      end
+
+      def method_missing method_name, *args
+        @branches.send(method_name.to_sym,*args)
+      end
+
+
+      def append(*branch)
+        adding_branch(*branch) do |fixed_branch|
+          @branches<<fixed_branch
+        end
+      end
+
+      def prepend(*branch)
+        adding_branch(*branch) do |fixed_branch|
+          @branches.unshift(fixed_branch)
+        end
+      end
+
+      def after(given_branch,*other_branch) 
+        index=get_branch_index(given_branch)
+
+        adding_branch(*other_branch) do |fixed_branch|
+          put_in_branches(fixed_branch,index)
+        end
+      end
+
+      def before(given_branch,*other_branch)
+        index=get_branch_index(given_branch)
+
+        adding_branch(*other_branch) do |fixed_branch|
+          put_in_branches(fixed_branch,index-1)
+        end
+      end
+
+      def get_branch_index(given_branch)
+        @branches.each_with_index{|branch,index|
+          return index if given_branch==branch
+        }
+        raise ArgumentError, "Branch #{given_branch.inspect} not exists in #{self.inspect}"
+      end
+
+      def set_parent(new_parent)
+        @parent=new_parent
+      end
+      
+      private
+
+      def adding_branch *branch
+        self.run(:before_branch_added,*branch)
+        fixed_branch=fix_branch(*branch)
+        yield fixed_branch
+        @last_branch=fixed_branch
+        self.run(:after_branch_added,fixed_branch)
+        fixed_branch
+      end
+
+      def fix_branch(*branch)
+        unless branch[0].is_a?(Lolita::Navigation::Branch)
+          options=branch.extract_options!
+          Lolita::Navigation::Branch.get_or_create(*branch,options.merge(:tree=>self))
+        else
+          branch[0].tree=self
+          branch[0]
+        end
+      end
+
+      def put_in_branches branch,index
+        before_part=@branches.slice(0,index+1) || []
+        after_part=@branches.slice(index+1,@branches.size-index) || []
+        @branches=before_part+[branch]+after_part
+      end
+
+    end
+  end
 end

data/lib/lolita/ruby_ext/accessors.rb

@@ -1,27 +1,27 @@
-class Object
-  # Works similar as <code>attr_accessor</code> only reader method is changed
-  # to allow to set value (used for Lolita blocks in different classes).
-  # ====Example
-  #     class Klass
-  #       lolita_accessor :my_method
-  #     end
-  #     k=Klass.new
-  #     k.my_method("it's me")
-  #     puts k.my_method #=> it's me
-  def lolita_accessor *methods
-    if [Class,Module].include?(self.class)
-      methods.each do |method|
-        class_eval <<-ACCESSORS,__FILE__,__LINE__+1
-        def #{method}(value=nil)
-          @#{method}=value if value
-          @#{method}
-        end
-
-        def #{method}=(value)
-          @#{method}=value
-        end
-        ACCESSORS
-      end
-    end
-  end
+class Object
+  # Works similar as <code>attr_accessor</code> only reader method is changed
+  # to allow to set value (used for Lolita blocks in different classes).
+  # ====Example
+  #     class Klass
+  #       lolita_accessor :my_method
+  #     end
+  #     k=Klass.new
+  #     k.my_method("it's me")
+  #     puts k.my_method #=> it's me
+  def lolita_accessor *methods
+    if [Class,Module].include?(self.class)
+      methods.each do |method|
+        class_eval <<-ACCESSORS,__FILE__,__LINE__+1
+        def #{method}(value=nil)
+          @#{method}=value if value
+          @#{method}
+        end
+
+        def #{method}=(value)
+          @#{method}=value
+        end
+        ACCESSORS
+      end
+    end
+  end
 end