lolita 3.3.6 → 3.3.7

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/controllers/internal_helpers.rb

@@ -58,13 +58,14 @@ module Lolita
         end
       end
 
-      protected
-
       def is_lolita_resource?
         raise ActionController::UnknownAction unless lolita_mapping
         true
       end
 
+      protected
+
+
       def resource=(new_resource)
         instance_variable_set(:"@#{resource_name}",new_resource)
       end
@@ -72,4 +73,4 @@ module Lolita
     end
 
   end
-end
+end

data/lib/lolita/controllers/internal_helpers.rb~

@@ -0,0 +1,75 @@
+module Lolita
+  module Controllers
+
+    module InternalHelpers
+
+      def include_application_assets
+        result = ""
+        Lolita.application.assets.each do |asset_name|
+          if asset_name.match(/\.js(\.|$)/)
+            result << javascript_include_tag(asset_name)
+          elsif asset_name.match(/\.css(\.|$)/)
+            result << stylesheet_link_tag(asset_name)
+          end
+        end
+        raw(result)
+      end
+
+      def resource
+        instance_variable_get(:"@#{resource_name}")
+      end
+      
+      def resource_name
+        lolita_mapping.class_name.underscore.to_sym
+      end
+      
+      def resource_class
+        lolita_mapping.to
+      end
+      
+      def lolita_mapping(new_mapping = nil)
+        @lolita_mapping ||= request.env["lolita.mapping"]
+      end
+
+      def current_form=(form)
+        @current_form = form
+      end
+
+      def current_form(temp_form = nil)
+        if block_given?
+          old_form = @current_form
+          @current_form = temp_form
+          content = yield
+          @current_form = old_form
+        end
+        @current_form
+      end
+
+      def use_mapping(new_mapping)
+        if block_given? 
+          begin
+            @old_mapping = lolita_mapping
+            @lolita_mapping = new_mapping
+            yield
+          ensure
+            @lolita_mapping = @old_mapping
+            @old_mapping = nil
+          end
+        end
+      end
+
+      protected
+
+      def is_lolita_resource?
+        raise ActionController::UnknownAction unless lolita_mapping
+        true
+      end
+
+      def resource=(new_resource)
+        instance_variable_set(:"@#{resource_name}",new_resource)
+      end
+
+    end
+
+  end
+end

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