lolita 3.2.0.rc.17 → 3.2.1

data/lib/lolita/configuration/search.rb

@@ -1,105 +1,105 @@
-module Lolita
-  module Configuration
-    # Proxy class for search. It supports two methods #with and #run.
-    # By default with method accepts method name or nothing and creates Lolita::Search::Simple instance
-    # that will be used to run search on current dbi. 
-    # By default search run against all content fields, but when _:fields_ options is passed it search in
-    # those fields only. 
-    # ==== Example
-    #     class Post < ActiveRecord::Base
-    #       include Lolita::Configuration
-    #       lolita do
-    #         list do
-    #           search :fields => [:name]
-    #         end
-    #       end
-    #     end
-    # #with method also accepts class or instance of some class, that will be used to run search.
-    # That class should have #run method that accepts query and request. 
-    # ====Example
-    #     class MyCustomSearch
-    #       def initialize(dbi)
-    #         @dbi = dbi
-    #       end
-    #   
-    #       def run(query,request = nil)
-    #         @dbi.klass.where(:my_field => query)
-    #       end
-    #     end
-    # Also you can put your search method in model. For more see Lolita::Search::Simple
-    # ====Example
-    #     class Post < ActiveRecord::Base
-    #       include Lolita::Configuration
-    #       lolita do
-    #         list do
-    #           search :my_custom_search
-    #         end
-    #       end
-    #       
-    #       def self.my_custom_search(query,request)
-    #         self.where(:title => query, :user_id => request.params[:user_id])
-    #       end
-    #     end    
-    class Search
-      include Lolita::Builder
-      attr_reader :dbi
-      attr_writer :with, :fields
-
-      def initialize dbi, *args, &block
-        @dbi = dbi
-        set_attributes(args ? args.extract_options! : {})
-        instance_eval(&block) if block_given?
-        @with ||= args[0]!=true && args[0] ? args[0] : nil 
-      end
-
-      def with(value = nil)
-        @with = value if value
-        if !@with || [String,Symbol].include?(@with.class)
-          @with = Lolita::Search::Simple.new(dbi,@with, :fields => @fields)
-        elsif @with.class == Class
-          initialize_arity = @with.instance_method(:initialize).arity
-          @with = if initialize_arity < 0 || initialize_arity > 1
-            @with.new(dbi,:fields => @fields)
-          else
-            @with.new(dbi)
-          end
-        end
-        @with
-      end
-
-      def run(query,request = nil)
-        if self.with.method(:run).arity < 0 || self.with.method(:run).arity > 1
-          self.with.run(query,request)
-        else
-          self.with.run(query)
-        end
-      end
-      
-      def update method_name,list,request
-        if method_name == :paginate && list.search
-          search_criteria = list.search.run(request && request.params[:q] || "",request)
-          page_criteria = if search_criteria.respond_to?(:where) 
-            list.page_criteria.merge(search_criteria)
-          elsif search_criteria.nil?
-            list.page_criteria
-          else
-            search_criteria
-          end
-          list.instance_variable_set(:@page_criteria,page_criteria)
-        end
-      end
-
-      private
-
-      def set_attributes options
-        if options.respond_to?(:each)
-          options.each do |method_name, value| 
-            self.send(:"#{method_name}=",value)
-          end
-        end
-      end
-
-    end
-
-  end
+module Lolita
+  module Configuration
+    # Proxy class for search. It supports two methods #with and #run.
+    # By default with method accepts method name or nothing and creates Lolita::Search::Simple instance
+    # that will be used to run search on current dbi. 
+    # By default search run against all content fields, but when _:fields_ options is passed it search in
+    # those fields only. 
+    # ==== Example
+    #     class Post < ActiveRecord::Base
+    #       include Lolita::Configuration
+    #       lolita do
+    #         list do
+    #           search :fields => [:name]
+    #         end
+    #       end
+    #     end
+    # #with method also accepts class or instance of some class, that will be used to run search.
+    # That class should have #run method that accepts query and request. 
+    # ====Example
+    #     class MyCustomSearch
+    #       def initialize(dbi)
+    #         @dbi = dbi
+    #       end
+    #   
+    #       def run(query,request = nil)
+    #         @dbi.klass.where(:my_field => query)
+    #       end
+    #     end
+    # Also you can put your search method in model. For more see Lolita::Search::Simple
+    # ====Example
+    #     class Post < ActiveRecord::Base
+    #       include Lolita::Configuration
+    #       lolita do
+    #         list do
+    #           search :my_custom_search
+    #         end
+    #       end
+    #       
+    #       def self.my_custom_search(query,request)
+    #         self.where(:title => query, :user_id => request.params[:user_id])
+    #       end
+    #     end    
+    class Search
+      include Lolita::Builder
+      attr_reader :dbi
+      attr_writer :with, :fields
+
+      def initialize dbi, *args, &block
+        @dbi = dbi
+        set_attributes(args ? args.extract_options! : {})
+        instance_eval(&block) if block_given?
+        @with ||= args[0]!=true && args[0] ? args[0] : nil 
+      end
+
+      def with(value = nil)
+        @with = value if value
+        if !@with || [String,Symbol].include?(@with.class)
+          @with = Lolita::Search::Simple.new(dbi,@with, :fields => @fields)
+        elsif @with.class == Class
+          initialize_arity = @with.instance_method(:initialize).arity
+          @with = if initialize_arity < 0 || initialize_arity > 1
+            @with.new(dbi,:fields => @fields)
+          else
+            @with.new(dbi)
+          end
+        end
+        @with
+      end
+
+      def run(query,request = nil)
+        if self.with.method(:run).arity < 0 || self.with.method(:run).arity > 1
+          self.with.run(query,request)
+        else
+          self.with.run(query)
+        end
+      end
+      
+      def update method_name,list,request
+        if method_name == :paginate && list.search
+          search_criteria = list.search.run(request && request.params[:q] || "",request)
+          page_criteria = if search_criteria.respond_to?(:where) 
+            list.page_criteria.merge(search_criteria)
+          elsif search_criteria.nil?
+            list.page_criteria
+          else
+            search_criteria
+          end
+          list.instance_variable_set(:@page_criteria,page_criteria)
+        end
+      end
+
+      private
+
+      def set_attributes options
+        if options.respond_to?(:each)
+          options.each do |method_name, value| 
+            self.send(:"#{method_name}=",value)
+          end
+        end
+      end
+
+    end
+
+  end
 end

data/lib/lolita/configuration/tab/content.rb

@@ -8,10 +8,10 @@ module Lolita
     	  	set_default_fields
     	  end
 
-    	  private 
+    	  private
 
         def set_default_fields
-          default_fields if @fields.empty? 
+          default_fields if @fields.empty?
         end
 
         def validate(tab, options={})
@@ -19,7 +19,7 @@ module Lolita
             raise Lolita::SameTabTypeError, "Same type tabs was detected (#{tab.type})."
           end
         end
-        
+
     	end
     end
   end

data/lib/lolita/controllers/component_helpers.rb

@@ -2,7 +2,7 @@ module Lolita
   module Controllers
   	# Helper that add #render_component method. That is shortstand for render :partial for lolita
   	# partial files. Also it provide view hooks for Lolita.
-	  # For any component there may be helper module. Modules are include in current view or 
+	  # For any component there may be helper module. Modules are include in current view or
     # controller instance when component is rendered.
     # All components ar placed in "app/helpers/components/[your component path]".
     # Component should have fallowing module structure Components::[NameSpace]::[Component name]Component
@@ -41,10 +41,10 @@ module Lolita
         @current_component_name = @rendering_components.last
         self.respond_to?(:raw) ? raw(output) : output
       end
-      
+
       def get_render_options *args
         options=args.extract_options!
-        if args.first.respond_to?(:build) 
+        if args.first.respond_to?(:build)
           name,state,options=args[0].build("",args[1],options)
         elsif args.first.class.ancestors.include?(Lolita::Configuration)
           raise ArgumentError, "Include Lolita::Builder in #{args.first.class}"
@@ -107,7 +107,7 @@ module Lolita
               class_name=possible_component_name.to_s.camelize
               helper_module = "Components::#{class_name}Component".constantize rescue nil
               if helper_module
-                self.extend(helper_module) 
+                self.extend(helper_module)
               end
             end
             @used_component_helpers[possible_component_name] = helper_module
@@ -118,7 +118,7 @@ module Lolita
           end
         end
       end
-      
+
       def helpers_for_component component_name
         names=component_name.to_s.gsub(/^\//,"").split("/")
         start_index=1 # first is lolita
@@ -128,7 +128,7 @@ module Lolita
       end
 
       # Find path for given component.
-      # 
+      #
       #    component_helper_path :"lolita/list" #=> [path_to_lolita]/app/helpers/components/lolita/list_component.rb
       def component_helper_path component_name
          @helper_paths||=$:.reject{|p| !p.match(/\/helpers$/) rescue nil}
@@ -137,10 +137,10 @@ module Lolita
           component=extra_path.pop
           paths.each do |path|
             new_path=File.join(path,"components",*extra_path,"#{component}_component.rb")
-               if File.exist?(new_path) 
+               if File.exist?(new_path)
                  return new_path
                end
-            end  
+            end
           nil
         }
         path=get_path.call(@helper_paths)
@@ -151,7 +151,7 @@ module Lolita
       def component_locals
         @component_locals[@current_component_name]
       end
-      
+
     end
   end
 end

data/lib/lolita/controllers/rails_helpers.rb

@@ -5,10 +5,10 @@ module Lolita
       include Lolita::Controllers::InternalHelpers
       included do
         if self.ancestors.include?(ActionController::Base)
-          helpers = %w(resource resource_name use_mapping 
+          helpers = %w(resource resource_name use_mapping
                        resource_class lolita_mapping show_response current_form current_form=)
           hide_action *helpers
-         
+
           helper_method *helpers
           prepend_before_filter :is_lolita_resource?
           prepend_around_filter :switch_locale
@@ -17,8 +17,8 @@ module Lolita
 
       # Return instance variable named as resource
       # For 'posts' instance variable will be @posts
-      
-      
+
+
       protected
 
       def notice(msg, options = {})
@@ -84,7 +84,7 @@ module Lolita
         end
         @component_builder = @component_object.build(@component_options)
       end
-      
+
 
       private
 

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.rb

@@ -3,7 +3,7 @@ module Lolita
   # Next step is hook definition. This may be done using Lolita::Hooks#add_hook method.
   # Hooks are stored in class <i>@hooks</i> variable, that is Hash and each key is hook name
   # and each hook also is Hash that have <em>:methods</em> and <em>:blocks</em>
-  # keys. Both of those are Array, and each time you call callback method, like <i>before_save</i> and so on, block 
+  # keys. Both of those are Array, and each time you call callback method, like <i>before_save</i> and so on, block
   # and/or methods is stored. <b>Each time</b> #run is called all blocks and methods will be executed.
   # It may look like this.
   #    class MyClass
@@ -28,10 +28,10 @@ module Lolita
   #    my_object.before_save do
   #      puts "instance callback"
   #    end
-  #    
-  #    MyClass.run(:before_save) #=> 
+  #
+  #    MyClass.run(:before_save) #=>
   #      class_callback
-  #    
+  #
   #    my_object.run(:before_save) #=>
   #      class_callback
   #      instance_callback
@@ -46,7 +46,7 @@ module Lolita
   #      puts "replaced text"
   #    end
   #    # will produce #=> replaced text
-  #    
+  #
   #    MyClass.run(:before_save) do
   #      puts "before callback"
   #      let_content
@@ -84,7 +84,7 @@ module Lolita
           @singleton_hooks || {}
         end
       end
-     
+
       attr_accessor :hooks_run_scope, :given_callback_content
       attr_writer :hooks_scope
 
@@ -104,7 +104,7 @@ module Lolita
         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 
+          in_hooks_scope(@options[:scope],@options[:run_scope]) do
             callback = get_callback(@hook_name)
             result = run_callback(callback,&block)
           end
@@ -114,7 +114,7 @@ module Lolita
 
       # Call callback block inside of run block.
       # ====Example
-      #     MyClass.run(:before_save) do 
+      #     MyClass.run(:before_save) do
       #        do_stuff
       #        let_content # execute callback block(-s) in same scope as run is executed.
       #     end
@@ -155,7 +155,7 @@ module Lolita
       # 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
@@ -199,7 +199,7 @@ module Lolita
         result
       end
 
-      # Run block in scope. 
+      # Run block in scope.
       def run_block block, &given_block
         hooks_run_scope.instance_eval(&block)
       end
@@ -220,14 +220,14 @@ module Lolita
     def self.method_missing method_name,*args, &block
       if named_hook=(Lolita::Hooks::NamedHook.by_name(method_name))
         named_hook[:_class]
-      else 
+      else
         super
       end
     end
 
     # Shared methods between class and instance.
     module CommonMethods
-      
+
       # All callbacks for class or instance.
       def callbacks
         var=self.instance_variable_get(:@callbacks)
@@ -245,7 +245,7 @@ module Lolita
         @hooks_scope = value
       end
 
-      def hooks_scope 
+      def hooks_scope
         @hooks_scope || self
       end
       # All hooks for class. This is Array of hook names.
@@ -279,7 +279,7 @@ module Lolita
       # ====Example
       #     add_hook :before_save
       #     MyClass.add_hooks :after_save, :around_save
-      def add_hook(*names) 
+      def add_hook(*names)
         (names||[]).each{|hook_name|
           self.class_eval <<-HOOK,__FILE__,__LINE__+1
             def self.#{hook_name}(*methods,&block)
@@ -325,8 +325,8 @@ module Lolita
         self.all_hooks.include?(name.to_sym)
       end
 
-      # Try to recognize named run methods like 
-      #    MyClass.run_after_save # will call MyClass.run(:after_save) 
+      # Try to recognize named run methods like
+      #    MyClass.run_after_save # will call MyClass.run(:after_save)
       def method_missing(*args, &block)
         unless self.recognize_hook_methods(*args,&block)
           super