lolita 3.3.5 → 3.3.6

data/lib/lolita/configuration/field/time.rb

@@ -1,13 +1,13 @@
-module Lolita
-  module Configuration
-    module Field
-      class Time < Lolita::Configuration::Field::Base
-        attr_accessor :format
-        def initialize dbi,name,*args, &block
-         
-          super
-        end
-      end
-    end
-  end
-end
+module Lolita
+  module Configuration
+    module Field
+      class Time < Lolita::Configuration::Field::Base
+        attr_accessor :format
+        def initialize dbi,name,*args, &block
+         
+          super
+        end
+      end
+    end
+  end
+end

data/lib/lolita/configuration/field_set.rb

@@ -1,26 +1,26 @@
-module Lolita
-  module Configuration
-    class FieldSet
-
-      @@last_fieldset=0
-      
-      attr_reader :parent
-      attr_accessor :name
-
-      def initialize parent,name=nil
-        @parent=parent
-        self.name=name || "fieldset_#{next_fieldset}"
-      end
-
-      def fields
-        self.parent.fields.reject{|f| f.field_set!=self}
-      end
-
-      private
-
-      def next_fieldset
-        @@last_fieldset+=1
-      end
-    end
-  end
+module Lolita
+  module Configuration
+    class FieldSet
+
+      @@last_fieldset=0
+      
+      attr_reader :parent
+      attr_accessor :name
+
+      def initialize parent,name=nil
+        @parent=parent
+        self.name=name || "fieldset_#{next_fieldset}"
+      end
+
+      def fields
+        self.parent.fields.reject{|f| f.field_set!=self}
+      end
+
+      private
+
+      def next_fieldset
+        @@last_fieldset+=1
+      end
+    end
+  end
 end

data/lib/lolita/configuration/nested_form.rb

@@ -1,105 +1,105 @@
-module Lolita
-  module Configuration
-    # Accept those attributes
-    # * <tt>:name</tt> - Name of nested relation, like :comments.
-    # * <tt>:field_style</tt> - Is fields rendered with as normal (with lable and staff) or like in table (:simple). Default :simple
-    # * <tt>:expandable</tt> - Show or not "Add new" and "Delete" links in form,
-    # by default, it is expandable if association macro is :many
-    # * <tt>:field_rejection_proc</tt> - Proc, that contains condition of how to reject field. 
-    # By default form rejects all fields from parent tab that doesn't have current form as field nested_form
-    # ====Example
-    #    form = Lolita::Configuration::NestedForm.new(Lolita::Configuration::Tab::Content.new,:comments)
-    #    form.field_rejection_proc = Proc.new{|field|
-    #       field.name.to_s.match(/_id$/)
-    #    }
-    #    # form exclude all fields that ends with _id
-    class NestedForm
-      include Lolita::Builder
-      @@last_nested_form=0
-      
-      attr_reader :parent, :options, :field_style
-      attr_accessor :name, :expandable, :field_rejection_proc
-      attr_writer :build_method
-
-      def initialize parent,name=nil, options ={}
-        @parent=parent
-        @options = options
-        self.name=name || "nested_form_#{next_nested_form}"
-        set_attributes_from(options)
-      end
-
-      def allow_destroy?
-        dbi.klass.nested_attributes_options[name][:allow_destroy]
-      end
-
-      def update_only?
-        dbi.klass.nested_attributes_options[name][:update_only]
-      end
-
-      def build_method
-        @build_method || self.name
-      end
-      # Set field style - normal or simple. Default - normal.      
-      def field_style=(value)
-        allowed_values = [:normal,:simple]
-        raise ArgumentError, "Only #{allowed_values.inspect} are allowed" unless allowed_values.include?(value)
-        @field_style = value
-      end
-
-      # Detect if it's possible to add more than one field group, like if model has many other objects.
-      def expandable?
-        @expandable == true || (@expandable == nil && macro == :many)
-      end
-
-      # Create field, that is not real field, but represents nested attributes as one.
-      # It is used to create label.
-      def as_field
-        Lolita::Configuration::Factory::Field.add(dbi,self.name, :string)
-      end
-
-      # Parent (a.k.a tab) dbi
-      def dbi
-        @parent.dbi
-      end
-
-      # Fields setter. Fields should be array and each element should be Lolita::Configuration::Field object.
-      def fields=(new_fields)
-        @fields = new_fields
-      end
-
-      # Return all fields. Each time fields ar returned from @fields if its defined or calculated by using #field_rejection_proc
-      # or collected from parent (tab) where fields nested form is same with self.
-      def fields
-        if @fields
-          @fields
-        elsif field_rejection_proc
-          self.parent.fields.reject(&field_rejection_proc)
-        else
-          self.parent.fields.reject{|f| f.nested_form!=self}
-        end
-      end
-
-      # Parent (tab) dbi klass
-      def klass
-        dbi.reflect_on_association(name).klass
-      end
-
-      # Parent (tab) dbi klass reflection with #name and macros of that.
-      def macro
-        dbi.reflect_on_association(name).macro
-      end
-
-      private
-
-      def next_nested_form
-        @@last_nested_form+=1
-      end
-
-      def set_attributes_from(options)
-        options.each{|key,value|
-          instance_variable_set(:"@#{key}",value)
-        }
-      end
-    end
-  end
+module Lolita
+  module Configuration
+    # Accept those attributes
+    # * <tt>:name</tt> - Name of nested relation, like :comments.
+    # * <tt>:field_style</tt> - Is fields rendered with as normal (with lable and staff) or like in table (:simple). Default :simple
+    # * <tt>:expandable</tt> - Show or not "Add new" and "Delete" links in form,
+    # by default, it is expandable if association macro is :many
+    # * <tt>:field_rejection_proc</tt> - Proc, that contains condition of how to reject field. 
+    # By default form rejects all fields from parent tab that doesn't have current form as field nested_form
+    # ====Example
+    #    form = Lolita::Configuration::NestedForm.new(Lolita::Configuration::Tab::Content.new,:comments)
+    #    form.field_rejection_proc = Proc.new{|field|
+    #       field.name.to_s.match(/_id$/)
+    #    }
+    #    # form exclude all fields that ends with _id
+    class NestedForm
+      include Lolita::Builder
+      @@last_nested_form=0
+      
+      attr_reader :parent, :options, :field_style
+      attr_accessor :name, :expandable, :field_rejection_proc
+      attr_writer :build_method
+
+      def initialize parent,name=nil, options ={}
+        @parent=parent
+        @options = options
+        self.name=name || "nested_form_#{next_nested_form}"
+        set_attributes_from(options)
+      end
+
+      def allow_destroy?
+        dbi.klass.nested_attributes_options[name][:allow_destroy]
+      end
+
+      def update_only?
+        dbi.klass.nested_attributes_options[name][:update_only]
+      end
+
+      def build_method
+        @build_method || self.name
+      end
+      # Set field style - normal or simple. Default - normal.      
+      def field_style=(value)
+        allowed_values = [:normal,:simple]
+        raise ArgumentError, "Only #{allowed_values.inspect} are allowed" unless allowed_values.include?(value)
+        @field_style = value
+      end
+
+      # Detect if it's possible to add more than one field group, like if model has many other objects.
+      def expandable?
+        @expandable == true || (@expandable == nil && macro == :many)
+      end
+
+      # Create field, that is not real field, but represents nested attributes as one.
+      # It is used to create label.
+      def as_field
+        Lolita::Configuration::Factory::Field.add(dbi,self.name, :string)
+      end
+
+      # Parent (a.k.a tab) dbi
+      def dbi
+        @parent.dbi
+      end
+
+      # Fields setter. Fields should be array and each element should be Lolita::Configuration::Field object.
+      def fields=(new_fields)
+        @fields = new_fields
+      end
+
+      # Return all fields. Each time fields ar returned from @fields if its defined or calculated by using #field_rejection_proc
+      # or collected from parent (tab) where fields nested form is same with self.
+      def fields
+        if @fields
+          @fields
+        elsif field_rejection_proc
+          self.parent.fields.reject(&field_rejection_proc)
+        else
+          self.parent.fields.reject{|f| f.nested_form!=self}
+        end
+      end
+
+      # Parent (tab) dbi klass
+      def klass
+        dbi.reflect_on_association(name).klass
+      end
+
+      # Parent (tab) dbi klass reflection with #name and macros of that.
+      def macro
+        dbi.reflect_on_association(name).macro
+      end
+
+      private
+
+      def next_nested_form
+        @@last_nested_form+=1
+      end
+
+      def set_attributes_from(options)
+        options.each{|key,value|
+          instance_variable_set(:"@#{key}",value)
+        }
+      end
+    end
+  end
 end

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/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