lolita 3.1.10 → 3.1.11

data/lib/lolita/configuration/filter.rb

@@ -1,109 +1,109 @@
-# coding: utf-8
-module Lolita
-  module Configuration
-    # Lolita::Configuration::Filter is for filtering data in list view.
-    # By now it supports these field types:
-    # - Array
-    # - Boolean
-    #  
-    # To use it, call "filter" method in list block, filter method accepts field names
-    # as arguments. You can pass block and configure each field. Field configuration is just like in tab configuration.
-    #
-    # === Examples
-    #    
-    #    # this will build country select field and is_deleted checkbox
-    #    list do
-    #      filter :country, :is_deleted
-    #    end
-    #
-    #    # For example you have text field "status" with values opened,closed,rejected
-    #    list do
-    #      filter do
-    #        field :status, :array, :options_for_select => %w(open closed rejected)
-    #        field :is_deleted, :title => "Deleted"
-    #      end
-    #    end
-    #
-    class Filter
-      include Lolita::Builder
-      attr_reader :dbi
-
-      def initialize(dbi,*args,&block)
-        @dbi = dbi
-        @fields=Lolita::Configuration::Fields.new
-        set_attributes(*args)
-        self.instance_eval(&block) if block_given?
-      end
-
-      def field *args, &block
-        field=Lolita::Configuration::Field.add(self.dbi,*args,&block)
-        field
-        @fields<<field
-        field
-      end
-
-      # Set all fields in tab. Accept <code>fields</code> as Array.
-      # Each array element can be Lolita::Configuration::Field object or
-      # Hash, that will be passed to #field method.
-      def fields=(fields)
-        if fields.is_a?(Array)
-          fields.each{|field_attr|
-            if field_attr.is_a?(Lolita::Configuration::Field)
-              @fields<<field_attr
-            else
-              self.field(field_attr)
-            end
-          }
-        end
-      end
-
-      def fields(*args, &block)
-        unless args.empty?
-          args.each do |field_name|
-            f = field(field_name)
-            f.instance_eval(&block) if block_given?
-          end
-        end
-        if @fields.empty?
-          field :search
-        end
-        @fields
-      end
-
-      # Used to set attributes if block not given.
-      def set_attributes(*args)
-        if args && args[0]
-          if args[0].is_a?(Hash)
-            args[0].each{|m,value|
-              self.send("#{m}=".to_sym,value)
-            }
-          else
-            fields *args            
-          end
-        end
-      end
-
-      def field_name field
-        "f_#{field.name}"
-      end
-
-      def options_for_select field
-        if field.options_for_select
-          field.options_for_select
-        else
-          if field.association_values.respond_to?(:call)
-           field.association_values.call(self)
-          else
-            field.association_values
-          end
-        end
-      end
-
-      def html_option_for_select field
-        {
-          :include_blank => ::I18n.t('lolita.filter.include_blank_by_title', :title => field.title)
-        }
-      end
-    end
-  end
+# coding: utf-8
+module Lolita
+  module Configuration
+    # Lolita::Configuration::Filter is for filtering data in list view.
+    # By now it supports these field types:
+    # - Array
+    # - Boolean
+    #  
+    # To use it, call "filter" method in list block, filter method accepts field names
+    # as arguments. You can pass block and configure each field. Field configuration is just like in tab configuration.
+    #
+    # === Examples
+    #    
+    #    # this will build country select field and is_deleted checkbox
+    #    list do
+    #      filter :country, :is_deleted
+    #    end
+    #
+    #    # For example you have text field "status" with values opened,closed,rejected
+    #    list do
+    #      filter do
+    #        field :status, :array, :options_for_select => %w(open closed rejected)
+    #        field :is_deleted, :title => "Deleted"
+    #      end
+    #    end
+    #
+    class Filter
+      include Lolita::Builder
+      attr_reader :dbi
+
+      def initialize(dbi,*args,&block)
+        @dbi = dbi
+        @fields=Lolita::Configuration::Fields.new
+        set_attributes(*args)
+        self.instance_eval(&block) if block_given?
+      end
+
+      def field *args, &block
+        field=Lolita::Configuration::Field.add(self.dbi,*args,&block)
+        field
+        @fields<<field
+        field
+      end
+
+      # Set all fields in tab. Accept <code>fields</code> as Array.
+      # Each array element can be Lolita::Configuration::Field object or
+      # Hash, that will be passed to #field method.
+      def fields=(fields)
+        if fields.is_a?(Array)
+          fields.each{|field_attr|
+            if field_attr.is_a?(Lolita::Configuration::Field)
+              @fields<<field_attr
+            else
+              self.field(field_attr)
+            end
+          }
+        end
+      end
+
+      def fields(*args, &block)
+        unless args.empty?
+          args.each do |field_name|
+            f = field(field_name)
+            f.instance_eval(&block) if block_given?
+          end
+        end
+        if @fields.empty?
+          field :search
+        end
+        @fields
+      end
+
+      # Used to set attributes if block not given.
+      def set_attributes(*args)
+        if args && args[0]
+          if args[0].is_a?(Hash)
+            args[0].each{|m,value|
+              self.send("#{m}=".to_sym,value)
+            }
+          else
+            fields *args            
+          end
+        end
+      end
+
+      def field_name field
+        "f_#{field.name}"
+      end
+
+      def options_for_select field
+        if field.options_for_select
+          field.options_for_select
+        else
+          if field.association_values.respond_to?(:call)
+           field.association_values.call(self)
+          else
+            field.association_values
+          end
+        end
+      end
+
+      def html_option_for_select field
+        {
+          :include_blank => ::I18n.t('lolita.filter.include_blank_by_title', :title => field.title)
+        }
+      end
+    end
+  end
 end

data/lib/lolita/configuration/list.rb

@@ -1,105 +1,105 @@
-module Lolita
-  module Configuration
-    class List
-      include Lolita::Builder
-       
-      attr_reader :dbi,:initialized_attributes
-      
-      def initialize(*args,&block)
-        if args && args[0].is_a?(Lolita::DBI::Base)
-          @dbi=args.shift
-        end
-        @columns=Lolita::Configuration::Columns.new(self)
-        @set_attributes=[]
-        set_attributes(*args)
-        self.instance_eval(&block) if block_given?
-        self.generate!()
-      end
-
-      # Look for methods in Page class. Load @page on demand and call method on it.
-      def method_missing(method_name,*args,&block)
-        if Lolita::Configuration::Page.public_instance_methods.include?(method_name.to_sym)
-          @page||=Lolita::Configuration::Page.new(@dbi)
-          @page.send(method_name.to_sym,*args,&block)
-        else
-          super
-        end
-      end
-      # Set columns. Allowed classes are Lolita::Configuration::Columns or
-      # Array.
-      def columns=(value)
-        set_attribute(:columns)
-        if value.is_a?(Lolita::Configuration::Columns)
-          @columns=value
-        elsif value.is_a?(Array)
-          value.each{|el| @columns<<el}
-        else
-          raise ArgumentError.new("Columns must bet Array or Lolita::Configuration::Columns.")
-        end
-      end
-
-      # Get list columns (also block setter)
-      def columns(*args)
-        if args && !args.empty?
-          self.columns=args
-        end
-        self.generate!
-        @columns
-      end
-
-      # Generate uninitialized attributes
-      def generate!()
-        @columns.generate! unless is_set?(:columns)
-      end
-
-      # checks if filter defined
-      def filter?
-        @filter.is_a?(Lolita::Configuration::Filter)
-      end
-
-      # Filter by now works only for these field types:
-      # - belongs_to
-      # - boolean
-      #
-      def filter(*args,&block)
-        @filter ||= Lolita::Configuration::Filter.new(self.dbi,*args,&block)
-      end
-      
-      # Block setter for columns
-      def column(*args,&block)
-        set_attribute(:columns)
-        if block_given?
-          @columns<<block
-        else
-          @columns.add(Lolita::Configuration::Column.new(@dbi,*args))
-        end
-      end
-
-      private
-
-      # Used to set attributes if block not given.
-      def set_attributes(*args)
-        if args && args[0]
-          if args[0].is_a?(Hash)
-            args[0].each{|m,value|
-              self.send("#{m}=".to_sym,value)
-            }
-          else
-            raise ArgumentError.new("Lolita::Configuration::List arguments must be Hash instead of #{args[0].class}")
-          end
-        end
-      end
-      
-      # Mark attribute as set.
-      def set_attribute(var)
-        @set_attributes<<var unless is_set?(var)
-      end
-
-      # Determine if attribute is set and don't need to generate it.
-      def is_set?(var)
-        @set_attributes.include?(var)
-      end
-
-    end
-  end
+module Lolita
+  module Configuration
+    class List
+      include Lolita::Builder
+       
+      attr_reader :dbi,:initialized_attributes
+      
+      def initialize(*args,&block)
+        if args && args[0].is_a?(Lolita::DBI::Base)
+          @dbi=args.shift
+        end
+        @columns=Lolita::Configuration::Columns.new(self)
+        @set_attributes=[]
+        set_attributes(*args)
+        self.instance_eval(&block) if block_given?
+        self.generate!()
+      end
+
+      # Look for methods in Page class. Load @page on demand and call method on it.
+      def method_missing(method_name,*args,&block)
+        if Lolita::Configuration::Page.public_instance_methods.include?(method_name.to_sym)
+          @page||=Lolita::Configuration::Page.new(@dbi,self)
+          @page.send(method_name.to_sym,*args,&block)
+        else
+          super
+        end
+      end
+      # Set columns. Allowed classes are Lolita::Configuration::Columns or
+      # Array.
+      def columns=(value)
+        set_attribute(:columns)
+        if value.is_a?(Lolita::Configuration::Columns)
+          @columns=value
+        elsif value.is_a?(Array)
+          value.each{|el| @columns<<el}
+        else
+          raise ArgumentError.new("Columns must bet Array or Lolita::Configuration::Columns.")
+        end
+      end
+
+      # Get list columns (also block setter)
+      def columns(*args)
+        if args && !args.empty?
+          self.columns=args
+        end
+        self.generate!
+        @columns
+      end
+
+      # Generate uninitialized attributes
+      def generate!()
+        @columns.generate! unless is_set?(:columns)
+      end
+
+      # checks if filter defined
+      def filter?
+        @filter.is_a?(Lolita::Configuration::Filter)
+      end
+
+      # Filter by now works only for these field types:
+      # - belongs_to
+      # - boolean
+      #
+      def filter(*args,&block)
+        @filter ||= Lolita::Configuration::Filter.new(self.dbi,*args,&block)
+      end
+      
+      # Block setter for columns
+      def column(*args,&block)
+        set_attribute(:columns)
+        if block_given?
+          @columns<<block
+        else
+          @columns.add(Lolita::Configuration::Column.new(@dbi,*args))
+        end
+      end
+
+      private
+
+      # Used to set attributes if block not given.
+      def set_attributes(*args)
+        if args && args[0]
+          if args[0].is_a?(Hash)
+            args[0].each{|m,value|
+              self.send("#{m}=".to_sym,value)
+            }
+          else
+            raise ArgumentError.new("Lolita::Configuration::List arguments must be Hash instead of #{args[0].class}")
+          end
+        end
+      end
+      
+      # Mark attribute as set.
+      def set_attribute(var)
+        @set_attributes<<var unless is_set?(var)
+      end
+
+      # Determine if attribute is set and don't need to generate it.
+      def is_set?(var)
+        @set_attributes.include?(var)
+      end
+
+    end
+  end
 end

data/lib/lolita/configuration/page.rb

@@ -1,125 +1,126 @@
-module Lolita
-  module Configuration
-    class Page
-
-      # page options is used to define specific options for pagination like :joins or :conditions
-      lolita_accessor :page_options
-      attr_writer :per_page
-      def initialize(dbi)
-        @dbi=dbi
-        @sort_columns=[]
-      end
-
-      # Records per page (also block setter)
-      def per_page(value=nil)
-        if value
-        @per_page=value
-        self
-        else
-        @per_page
-        end
-      end
-
-      # Define new sort column with ascending sort direction
-      def asc(column)
-        @sort_columns<<[column.to_sym,:asc]
-        self
-      end
-
-      # Define new sort columns with descending sort direction
-      def desc(column)
-        @sort_columns<<[column.to_sym,:desc]
-        self
-      end
-
-      # Return all sort columns.
-      # Each column is an Array where first element is column name and second is direction
-      # ====Example
-      #     page=Lolita::Configuration::Page.new(@dbi)
-      #     page.asc(:created_at)
-      #     page.sort_columns #=> [[:created_at,:asc]]
-      def sort_columns
-        @sort_columns
-      end
-
-      # Paginate
-      # Options:
-      # * <tt>:per_page</tt> - record count per page, default uses list.per_page
-      # * <tt>:page</tt> - what page to show
-      # * <tt>:sort_columns</tt> - sort columns for page. See #sort_columns
-      # * <tt>:asc</tt> - column to sort in ascending direction
-      #     list.paginate(1,:asc=>:created_at)
-      # * <tt>:desc</tt> - column to sort in descending direction
-      #
-      # ====Example
-      #     list.paginate(1)
-      #     list.paginate
-      #     list.paginate(:per_page=>2,:page=>1)
-      def paginate *args
-        options=args ? args.extract_options! : {}
-        hold=options.delete(:hold)
-        @params=options.delete(:params)
-        set_values_from_options(options)
-        options[:page]||=((args && args.first) || 1)
-        options[:per_page]||=@per_page || 10
-        @last_options=options
-        @last_options[:sort]=self.sort_columns unless self.sort_columns.empty?
-        unless hold
-          get_page()
-        end
-      end
-
-      def get_page()
-        @page=@dbi.filter(filter_conditions).paginate((@page_options||{}).merge(@last_options))
-      end
-      
-      # Return last paginated page
-      # ====Example
-      #     list.paginate(2)
-      #     # call page to avoid another call to db
-      #     list.page
-      def last_page
-        @page
-      end
-
-      private
-
-      # returns filter conditions as Hash for get_page()
-      def filter_conditions
-        if @params
-          conditions = {}
-          @params.each_pair do |k,v|
-            if k.to_s =~ /^f_([a-z0-9_\-]+)$/ && !v.to_s.strip.blank?
-              conditions[$1.to_sym] = v
-            end
-          end
-          conditions
-        else
-          {}
-        end
-      end
-
-      def allowed_options
-        [:sort_columns,:asc,:desc]
-      end
-
-      def set_values_from_options(options)
-        allowed_options.each{|meth|
-          if options.has_key?(meth)
-            self.send(meth,options.delete(meth))
-          end
-        }
-        parse_params
-      end
-
-      def parse_params
-        if @params
-          if @params.has_key?(:sc)
-            self.send((@params[:sd] || :asc).to_sym,@params[:sc])
-          end
-        end
-      end
-
-    end
-  end
+module Lolita
+  module Configuration
+    class Page
+
+      # page options is used to define specific options for pagination like :joins or :conditions
+      lolita_accessor :page_options
+      attr_writer :per_page
+      def initialize(dbi, list=nil)
+        @dbi=dbi
+        @list = list
+        @sort_columns=[]
+      end
+
+      # Records per page (also block setter)
+      def per_page(value=nil)
+        if value
+          @per_page=value
+          self
+        else
+          @per_page
+        end
+      end
+
+      # Define new sort column with ascending sort direction
+      def asc(column)
+        @sort_columns<<[column.to_sym,:asc]
+        self
+      end
+
+      # Define new sort columns with descending sort direction
+      def desc(column)
+        @sort_columns<<[column.to_sym,:desc]
+        self
+      end
+
+      # Return all sort columns.
+      # Each column is an Array where first element is column name and second is direction
+      # ====Example
+      #     page=Lolita::Configuration::Page.new(@dbi)
+      #     page.asc(:created_at)
+      #     page.sort_columns #=> [[:created_at,:asc]]
+      def sort_columns
+        @sort_columns
+      end
+
+      # Paginate
+      # Options:
+      # * <tt>:per_page</tt> - record count per page, default uses list.per_page
+      # * <tt>:page</tt> - what page to show
+      # * <tt>:sort_columns</tt> - sort columns for page. See #sort_columns
+      # * <tt>:asc</tt> - column to sort in ascending direction
+      #     list.paginate(1,:asc=>:created_at)
+      # * <tt>:desc</tt> - column to sort in descending direction
+      #
+      # ====Example
+      #     list.paginate(1)
+      #     list.paginate
+      #     list.paginate(:per_page=>2,:page=>1)
+      def paginate *args
+        options=args ? args.extract_options! : {}
+        hold=options.delete(:hold)
+        @params=options.delete(:params)
+        set_values_from_options(options)
+        options[:page]||=((args && args.first) || 1)
+        options[:per_page]||=@per_page || 10
+        @last_options=options
+        @last_options[:sort]=self.sort_columns unless self.sort_columns.empty?
+        unless hold
+          get_page()
+        end
+      end
+
+      def get_page()
+        @page=@dbi.filter(filter_conditions).paginate((@page_options||{}).merge(@last_options))
+      end
+      
+      # Return last paginated page
+      # ====Example
+      #     list.paginate(2)
+      #     # call page to avoid another call to db
+      #     list.page
+      def last_page
+        @page
+      end
+
+      private
+
+      # returns filter conditions as Hash for get_page()
+      def filter_conditions
+        if @params
+          conditions = {}
+          @params.each_pair do |k,v|
+            if k.to_s =~ /^f_([a-z0-9_\-]+)$/ && !v.to_s.strip.blank?
+              conditions[$1.to_sym] = v
+            end
+          end
+          conditions
+        else
+          {}
+        end
+      end
+
+      def allowed_options
+        [:sort_columns,:asc,:desc]
+      end
+
+      def set_values_from_options(options)
+        allowed_options.each{|meth|
+          if options.has_key?(meth)
+            self.send(meth,options.delete(meth))
+          end
+        }
+        parse_params
+      end
+
+      def parse_params
+        if @params
+          if @params.has_key?(:sc)
+            self.send((@params[:sd] || :asc).to_sym,@params[:sc])
+          end
+        end
+      end
+
+    end
+  end
 end