lolita 3.1.9 → 3.1.10

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,47 +1,47 @@
-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)
-      unless temp_var
-        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.class_instance
-        instance_name.instance_variable_set(var_name,temp_var.class_instance)
-      else
-        temp_var
-      end
-    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
-        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
-      @class_instance.__send__(method_name,*args,&block)
-    end
-
-    instance_methods.each { |method|
-      next if ["hash","respond_to?","__id__","__send__","to_s","object_id","method_missing","class_instance","initialize"].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)
+      unless temp_var
+        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.class_instance
+        instance_name.instance_variable_set(var_name,temp_var.class_instance)
+      else
+        temp_var
+      end
+    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
+        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
+      @class_instance.__send__(method_name,*args,&block)
+    end
+
+    instance_methods.each { |method|
+      next if ["hash","respond_to?","__id__","__send__","to_s","object_id","method_missing","class_instance","initialize"].include?(method.to_s)
+      eval("undef :#{method}")
+    }
+  end
 end

data/lib/lolita/mapping.rb

@@ -1,55 +1,55 @@
-module Lolita
-  # Create mapping for routes.
-  # Each mapping has name, like :posts, :files etc.
-  # Also it accepts options: 
-  # * <tt>:singular</tt> - singular form for route, by default it call #singularize on _name_.
-  # * <tt>:class_name</tt> - class that is related with route, by default it uses :singular, and classify it. It should be like "Post".
-  # * <tt>:path_prefix</tt> - path starts with path prefix, like /path_prefix/lolita/posts.
-  # * <tt>:path</tt> - path and path url methods starts with this path.
-  # =====Example
-  #     lolita_for :posts, :path=>"admin"
-  #     # add paths like this to routes
-  #     # admin_posts GET /admin/posts {:controller=>"lolita/rest", :action=>:index}
-  #     # edit_admin_posts GET /admin/post/1/edit {:controller=>"lolita/rest",:action=>:edit}
-  # * <tt>:module</tt> - change module for path, it changes <i>:controller</i> that is used for lolita, like, 
-  #   <code>:module=>"admin"</code>, change controller to "admin/posts". If this is used without :path then no named routes will be generated
-  # Instances of this class is used all over the Lolita, this class itself represent what name does resource has,
-  # what controller to use, what model is related with it and so on. This is used to generate urls and paths.
-  # Also eahc request containers information with mapping related to it.
-  class Mapping
-    attr_reader :class_name,:path,:singular,:plural,:path_prefix,:module,:controllers,:as
-    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]
-      @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
-      @ref = ActiveSupport::Dependencies.ref(@class_name)
-      @path_prefix=options[:path_prefix]
-      @path=(options[:path] || "lolita").to_s
-      @module=options[:module] 
-      mod=@module ? nil :  "lolita/"
-      @controllers=Hash.new{|h,k|
-        h[k]=options[:controller] || "#{mod}#{k}" 
-      }
-    end
-  
-    # Return class that is related with mapping.
-    def to
-      @ref.get
-    end
-    
-    # full path of current mapping
-    def fullpath
-      "#{@path_prefix}/#{@path}".squeeze("/")
-    end
-
-    def url_name #TODO test what with namespace
-      "#{@path}_#{@plural}"
-    end
-    
-  end
-end
+module Lolita
+  # Create mapping for routes.
+  # Each mapping has name, like :posts, :files etc.
+  # Also it accepts options: 
+  # * <tt>:singular</tt> - singular form for route, by default it call #singularize on _name_.
+  # * <tt>:class_name</tt> - class that is related with route, by default it uses :singular, and classify it. It should be like "Post".
+  # * <tt>:path_prefix</tt> - path starts with path prefix, like /path_prefix/lolita/posts.
+  # * <tt>:path</tt> - path and path url methods starts with this path.
+  # =====Example
+  #     lolita_for :posts, :path=>"admin"
+  #     # add paths like this to routes
+  #     # admin_posts GET /admin/posts {:controller=>"lolita/rest", :action=>:index}
+  #     # edit_admin_posts GET /admin/post/1/edit {:controller=>"lolita/rest",:action=>:edit}
+  # * <tt>:module</tt> - change module for path, it changes <i>:controller</i> that is used for lolita, like, 
+  #   <code>:module=>"admin"</code>, change controller to "admin/posts". If this is used without :path then no named routes will be generated
+  # Instances of this class is used all over the Lolita, this class itself represent what name does resource has,
+  # what controller to use, what model is related with it and so on. This is used to generate urls and paths.
+  # Also eahc request containers information with mapping related to it.
+  class Mapping
+    attr_reader :class_name,:path,:singular,:plural,:path_prefix,:module,:controllers,:as
+    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]
+      @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
+      @ref = ActiveSupport::Dependencies.ref(@class_name)
+      @path_prefix=options[:path_prefix]
+      @path=(options[:path] || "lolita").to_s
+      @module=options[:module] 
+      mod=@module ? nil :  "lolita/"
+      @controllers=Hash.new{|h,k|
+        h[k]=options[:controller] || "#{mod}#{k}" 
+      }
+    end
+  
+    # Return class that is related with mapping.
+    def to
+      @ref.get
+    end
+    
+    # full path of current mapping
+    def fullpath
+      "#{@path_prefix}/#{@path}".squeeze("/")
+    end
+
+    def url_name #TODO test what with namespace
+      "#{@path}_#{@plural}"
+    end
+    
+  end
+end