lolita 3.4.2 → 3.4.3

data/lib/lolita/controllers/url_helpers.rb

@@ -2,7 +2,7 @@ module Lolita
   module Controllers
     # This module is included in all controllers and views. UrlHelper provide methods to generate lolita
     # resource paths. As all resources goes to one controller (by default), than it is very difficult to
-    # generate url with <em>:controller</em> and <em>:action</em>. 
+    # generate url with <em>:controller</em> and <em>:action</em>.
     # There are four methods for path:
     # * lolita_resources_path - goes to index action
     # * lolita_resource_path - goes to create, destroy or show, it depends what kind of method is used
@@ -34,7 +34,7 @@ module Lolita
           #     # GET /posts
           #     url_for #=> /posts
           def url_for_with_lolita options = {}
-            if options.is_a?(Hash) && !options[:use_route] && self.respond_to?(:lolita_mapping) && self.lolita_mapping
+            if request && options.is_a?(Hash) && !options[:use_route] && self.respond_to?(:lolita_mapping) && self.lolita_mapping
               controller = options[:controller].to_s
               if Lolita.mappings[lolita_mapping.name].controllers.values.include?(controller)
                 resource_type = {
@@ -47,7 +47,7 @@ module Lolita
                 options = self.send(resource_type[action] || :lolita_resource_path,options)
               end
             end
-            
+
             url_for_without_lolita(options)
           end
           alias_method_chain :url_for, :lolita
@@ -56,7 +56,7 @@ module Lolita
       end
 
       protected
-      
+
       # Path for index.
       def lolita_resources_path(*args)
         options=args.extract_options!
@@ -65,7 +65,7 @@ module Lolita
       end
 
       # Path for show, create and destroy
-      def lolita_resource_path(*args) 
+      def lolita_resource_path(*args)
         options=args.extract_options!
         mapping=args[0]
         send(lolita_resource_name(:mapping=>mapping),options)
@@ -88,7 +88,7 @@ module Lolita
       end
 
       # It return symbol, that represents named route method for path, like <i>lolita_posts_path</i> and so on.
-      # It accepts those options: 
+      # It accepts those options:
       # * <tt>:mapping</tt> - Lolita::Mapping object, that is used to detect name of named route.
       # by default it uses Lolita::InternalHelpers#lolita_mapping.
       # * <tt>:plural</tt> - What kind of named route should use, plural or singular.
@@ -97,7 +97,7 @@ module Lolita
       #     # current mapping is for posts
       #     lolita_resource_name(:action=>:edit) #=> :edit_lolita_post_path
       #     lolita_resource_name(:plural=>true,:action=>:list) #=> :list_lolita_posts_path
-      #     # for different mapping 
+      #     # for different mapping
       #     lolita_resource_name(:mapping=>comments_mapping) #=> :lolita_comment_path
       # This methods is very useful to create your own paths in views.
       def lolita_resource_name(options={}) #TODO test if path is right

data/lib/lolita/dbi/base.rb

@@ -1,56 +1,56 @@
-module Lolita
-  module DBI
-    # Lolita::DBI::Base is ORM Interface class, that handle the request to ORM classes.
-    # Depending on given class DBI::Base detect which ORM class is used and include right adapter
-    # for that class. Other Lolita classes that need to manipulate with data need to have dbi object
-    # or it can be created in that class.
-    # Lolita::DBI::Base support Mongoid and ActiveRecord::Base, or details see Lolita::Adapter.
-    class Base
-
-      def self.create(class_object)
-        dbi = self.new(class_object)
-        return dbi.adapter
-      end
-
-      attr_reader :adapter_name #return connected adapter name
-      attr_reader :klass # return related orm class object
-      attr_reader :adapter # connected Adaptee for adapter
-      
-      # Expect ORM class that is supported by Lolita. See Adapter for available adapters.
-      def initialize(class_object) 
-        @klass=class_object
-        detect_adapter
-        connect_adapter
-      end
-
-      # Detect which ORM class is given and based on it connect Adapter.
-      def detect_adapter
-        if defined?(Mongoid) && defined?(Mongoid::Document) && self.klass.ancestors.include?(Mongoid::Document)
-          @adapter_name=:mongoid
-        elsif defined?(ActiveRecord) && defined?(ActiveRecord::Base) && self.klass.ancestors.include?(ActiveRecord::Base)
-          @adapter_name=:active_record
-        else
-          raise NotORMClassError.new("Lolita::DBI::Base can not find appropriate #{self.klass} class adapter.")
-        end
-      end
-
-      # Connect Adapter by including adapter module into DBI::Base class.
-      def connect_adapter()
-        @adapter="Lolita::Adapter::#{self.adapter_name.to_s.camelize}".constantize.new(self)
-      end
-
-      def method_missing(metod,*args,&block)
-        @adapter.send(metod,*args,&block)
-      end
-
-      class << self
-        # Return Array of available adapters.
-        def adapters
-          Dir[File.expand_path(File.join(File.dirname(__FILE__),'..','adapter','**','*.rb'))].map {|f|
-            File.basename(f,".rb").to_sym
-          }.reject{|el| el==:abstract_adapter}
-        end
-      end
-    end
-  end
-end
+module Lolita
+  module DBI
+    # Lolita::DBI::Base is ORM Interface class, that handle the request to ORM classes.
+    # Depending on given class DBI::Base detect which ORM class is used and include right adapter
+    # for that class. Other Lolita classes that need to manipulate with data need to have dbi object
+    # or it can be created in that class.
+    # Lolita::DBI::Base support Mongoid and ActiveRecord::Base, or details see Lolita::Adapter.
+    class Base
+
+      def self.create(class_object)
+        dbi = self.new(class_object)
+        return dbi.adapter
+      end
+
+      attr_reader :adapter_name #return connected adapter name
+      attr_reader :klass # return related orm class object
+      attr_reader :adapter # connected Adaptee for adapter
+      
+      # Expect ORM class that is supported by Lolita. See Adapter for available adapters.
+      def initialize(class_object) 
+        @klass=class_object
+        detect_adapter
+        connect_adapter
+      end
+
+      # Detect which ORM class is given and based on it connect Adapter.
+      def detect_adapter
+        if defined?(Mongoid) && defined?(Mongoid::Document) && self.klass.ancestors.include?(Mongoid::Document)
+          @adapter_name=:mongoid
+        elsif defined?(ActiveRecord) && defined?(ActiveRecord::Base) && self.klass.ancestors.include?(ActiveRecord::Base)
+          @adapter_name=:active_record
+        else
+          raise NotORMClassError.new("Lolita::DBI::Base can not find appropriate #{self.klass} class adapter.")
+        end
+      end
+
+      # Connect Adapter by including adapter module into DBI::Base class.
+      def connect_adapter()
+        @adapter="Lolita::Adapter::#{self.adapter_name.to_s.camelize}".constantize.new(self)
+      end
+
+      def method_missing(metod,*args,&block)
+        @adapter.send(metod,*args,&block)
+      end
+
+      class << self
+        # Return Array of available adapters.
+        def adapters
+          Dir[File.expand_path(File.join(File.dirname(__FILE__),'..','adapter','**','*.rb'))].map {|f|
+            File.basename(f,".rb").to_sym
+          }.reject{|el| el==:abstract_adapter}
+        end
+      end
+    end
+  end
+end

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