lolita 3.1.10 → 3.1.11

data/lib/lolita/configuration/base.rb

@@ -1,76 +1,76 @@
-# Every class that include Lolita::Configuration this module assign
-# #lolita and #lolita= methods. First one is for normal Lolita configuration
-# definition, and the other one made to assing Lolita to class as a Lolita::Configuration::Base
-# object. You may want to do that to change configuration or for testing purpose.
-module Lolita
-  module Configuration
-    # Lolita could be defined inside of any class that is supported by Lolita::Adapter, for now that is
-    # * ActiveRecord::Base
-    # * Mongoid::Document
-    # Main block can hold these methods:
-    # <tt>list</tt> - List definition, see Lolitia::Configuration::List
-    # <tt>tab</tt> - Tab definition, see Lolita::Configuration::Tab
-    # <tt>tabs</tt> - Tabs definition, see Lolita::Configuration::Tabs
-    class Base
-
-      attr_reader :dbi,:klass
-      @@generators=[:tabs,:list]
-      class << self
-        def add_generator(method)
-          @@generators<<method.to_sym
-        end
-      end
-      # When configuration is defined in class than you don't need to worry about
-      # creating new object, because Lolita itself create it for that class.
-      # New object is created like when you define it in class, but <i>parent_class</i>
-      # must be given.
-      # ====Example
-      #     class Person < ActiveRecord::Base
-      #        include Lolita::Configuration
-      #        lolita
-      #     end
-      #     Person.lolita.klass #=> Person
-      #     # Init Lolita by youself
-      #
-      #     class Person < ActiveRecord::Base
-      #       include Lolita::Configuration
-      #     end
-      #     Person.lolita=Lolita::Configuration::Base.new(Person)
-      #     Person.lolita.klass #=> Person
-      def initialize(orm_class,&block)
-        @klass=orm_class
-        @dbi=Lolita::DBI::Base.new(orm_class)
-        block_given? ? self.instance_eval(&block) : self.generate!
-      end
-
-
-      # Create list variable for ::Base class and create lazy object of Lolita::LazyLoader.
-      # See Lolita::Configuration::List for more information.
-      def list &block
-        Lolita::LazyLoader.lazy_load(self,:@list,Lolita::Configuration::List,@dbi,&block)
-      end
-
-      # Create collection of Lolita::Configuration::Tab, loading lazy.
-      # See Lolita::Configuration::Tabs for details.
-      def tabs &block
-        Lolita::LazyLoader.lazy_load(self, :@tabs,Lolita::Configuration::Tabs,@dbi,&block)
-      end
-
-      # Shortcut for Lolita::Configuration::Tabs <<.
-      # Tabs should not be defined in lolita block to create onew or more Lolita::Configuration::Tab
-      # See Lolita::Configuration::Tab for details of defination.
-      def tab *args, &block
-        self.tabs<<Lolita::Configuration::Tab.add(@dbi,*args,&block)
-      end
-      
-      # Call all supported instance metods to set needed variables and initialize object with them.
-      def generate!
-        @@generators.each{|generator|
-          self.send(generator)
-        }
-      end
-      
-    end
-  end
-end
-
+# Every class that include Lolita::Configuration this module assign
+# #lolita and #lolita= methods. First one is for normal Lolita configuration
+# definition, and the other one made to assing Lolita to class as a Lolita::Configuration::Base
+# object. You may want to do that to change configuration or for testing purpose.
+module Lolita
+  module Configuration
+    # Lolita could be defined inside of any class that is supported by Lolita::Adapter, for now that is
+    # * ActiveRecord::Base
+    # * Mongoid::Document
+    # Main block can hold these methods:
+    # <tt>list</tt> - List definition, see Lolitia::Configuration::List
+    # <tt>tab</tt> - Tab definition, see Lolita::Configuration::Tab
+    # <tt>tabs</tt> - Tabs definition, see Lolita::Configuration::Tabs
+    class Base
+
+      attr_reader :dbi,:klass
+      @@generators=[:tabs,:list]
+      class << self
+        def add_generator(method)
+          @@generators<<method.to_sym
+        end
+      end
+      # When configuration is defined in class than you don't need to worry about
+      # creating new object, because Lolita itself create it for that class.
+      # New object is created like when you define it in class, but <i>parent_class</i>
+      # must be given.
+      # ====Example
+      #     class Person < ActiveRecord::Base
+      #        include Lolita::Configuration
+      #        lolita
+      #     end
+      #     Person.lolita.klass #=> Person
+      #     # Init Lolita by youself
+      #
+      #     class Person < ActiveRecord::Base
+      #       include Lolita::Configuration
+      #     end
+      #     Person.lolita=Lolita::Configuration::Base.new(Person)
+      #     Person.lolita.klass #=> Person
+      def initialize(orm_class,&block)
+        @klass=orm_class
+        @dbi=Lolita::DBI::Base.new(orm_class)
+        block_given? ? self.instance_eval(&block) : self.generate!
+      end
+
+
+      # Create list variable for ::Base class and create lazy object of Lolita::LazyLoader.
+      # See Lolita::Configuration::List for more information.
+      def list &block
+        Lolita::LazyLoader.lazy_load(self,:@list,Lolita::Configuration::List,@dbi,&block)
+      end
+
+      # Create collection of Lolita::Configuration::Tab, loading lazy.
+      # See Lolita::Configuration::Tabs for details.
+      def tabs &block
+        Lolita::LazyLoader.lazy_load(self, :@tabs,Lolita::Configuration::Tabs,@dbi,&block)
+      end
+
+      # Shortcut for Lolita::Configuration::Tabs <<.
+      # Tabs should not be defined in lolita block to create onew or more Lolita::Configuration::Tab
+      # See Lolita::Configuration::Tab for details of defination.
+      def tab *args, &block
+        self.tabs<<Lolita::Configuration::Tab.add(@dbi,*args,&block)
+      end
+      
+      # Call all supported instance metods to set needed variables and initialize object with them.
+      def generate!
+        @@generators.each{|generator|
+          self.send(generator)
+        }
+      end
+      
+    end
+  end
+end
+

data/lib/lolita/configuration/column.rb

@@ -1,94 +1,93 @@
-module Lolita
-  module Configuration
-    class Column 
-
-      include Lolita::Builder
-      
-      MAX_TEXT_SIZE=20
-      lolita_accessor :name,:title,:type,:options,:sortable
-      
-      def initialize(dbi,*args,&block)
-        @dbi=dbi
-        self.set_attributes(*args)
-        self.instance_eval(&block) if block_given?
-        validate
-        set_default_values
-      end
-
-      def title(value=nil)
-        @title=value if value
-        @title||=@dbi.klass.human_attribute_name(@name.to_s)
-        @title
-      end
-
-      def sortable?
-        @sortable
-      end
-
-      def currently_sorting?(params)
-        @sortable && params[:sc].to_s==self.name.to_s
-      end
-
-      def sort_options(params)
-        direction=if params[:sc].to_s==self.name.to_s
-          params[:sd].to_s=="asc" ? "desc" : "asc"
-        else
-          "desc"
-        end
-        {:sc=>self.name,:sd=>direction}
-      end
-      
-      # Define format, for details see Lolita::Support::Formatter and Lolita::Support::Formater::Rails
-      def formatter(value=nil,&block)
-        if block_given?
-          @formatter=Lolita::Support::Formatter.new(value,&block) 
-        elsif value || !@formatter
-          if value.kind_of?(Lolita::Support::Formatter)
-            @formatter=value
-          else
-            @formatter=Lolita::Support::Formatter::Rails.new(value)
-          end
-        end
-        @formatter
-      end
-
-      def formatter=(value)
-        if value.kind_of?(Lolita::Support::Formatter)
-          @formatter=value
-        else
-          @formatter=Lolita::Support::Formatter::Rails.new(value)
-        end
-      end
-
-      def set_attributes(*args)
-        if !args.empty?
-          if args[0].is_a?(Hash)
-            args[0].each{|m,value|
-              self.send("#{m}=".to_sym,value)
-            }
-          elsif args[0].is_a?(Symbol) || args[0].is_a?(String)
-            self.name=args[0].to_s
-            if args[1].is_a?(Hash)
-              args[1].each{|m,value|
-                self.send("#{m}=".to_sym,value)
-              }
-            end
-          else
-            raise ArgumentError.new("Lolita::Configuration::Column arguments must be Hash or Symbol or String instead of #{args[0].class}")
-          end
-        end
-      end
-      
-      private
-      
-      def set_default_values
-        @sortable||=true
-        @sort_direction||=:desc
-      end
-
-      def validate
-        raise ArgumentError.new("Column must have name.") unless self.name
-      end
-    end
-  end
-end
+module Lolita
+  module Configuration
+    class Column 
+
+      include Lolita::Builder
+      
+      MAX_TEXT_SIZE=20
+      lolita_accessor :name,:title,:type,:options,:sortable
+      
+      def initialize(dbi,*args,&block)
+        @dbi=dbi
+        self.set_attributes(*args)
+        self.instance_eval(&block) if block_given?
+        validate
+        set_default_values
+      end
+
+      def title(value=nil)
+        @title=value if value
+        @title||=@dbi.klass.human_attribute_name(@name.to_s)
+        @title
+      end
+
+      def sortable?
+        @sortable
+      end
+
+      def currently_sorting?(params)
+        @sortable && params[:sc].to_s==self.name.to_s
+      end
+
+      def sort_options(params)
+        direction=if params[:sc].to_s==self.name.to_s
+          params[:sd].to_s=="asc" ? "desc" : "asc"
+        else
+          "desc"
+        end
+        {:sc=>self.name,:sd=>direction}
+      end
+      
+      # Define format, for details see Lolita::Support::Formatter and Lolita::Support::Formater::Rails
+      def formatter(value=nil,&block)
+        if block_given?
+          @formatter=Lolita::Support::Formatter.new(value,&block) 
+        elsif value || !@formatter
+          if value.kind_of?(Lolita::Support::Formatter)
+            @formatter=value
+          else
+            @formatter=Lolita::Support::Formatter::Rails.new(value)
+          end
+        end
+        @formatter
+      end
+
+      def formatter=(value)
+        if value.kind_of?(Lolita::Support::Formatter)
+          @formatter=value
+        else
+          @formatter=Lolita::Support::Formatter::Rails.new(value)
+        end
+      end
+
+      def set_attributes(*args)
+        if !args.empty?
+          if args[0].is_a?(Hash)
+            args[0].each{|m,value|
+              self.send("#{m}=".to_sym,value)
+            }
+          elsif args[0].is_a?(Symbol) || args[0].is_a?(String)
+            self.name=args[0].to_s
+            if args[1].is_a?(Hash)
+              args[1].each{|m,value|
+                self.send("#{m}=".to_sym,value)
+              }
+            end
+          else
+            raise ArgumentError.new("Lolita::Configuration::Column arguments must be Hash or Symbol or String instead of #{args[0].class}")
+          end
+        end
+      end
+      
+      private
+      
+      def set_default_values
+        @sort_direction||=:desc
+      end
+
+      def validate
+        raise ArgumentError.new("Column must have name.") unless self.name
+      end
+    end
+  end
+end

data/lib/lolita/configuration/columns.rb

@@ -1,66 +1,66 @@
-module Lolita
-  module Configuration
-    class Columns
-
-      include Enumerable
-      include ObservedArray
-      include Lolita::Builder
-      
-      attr_accessor :list
-      attr_reader :dbi
-      
-      def initialize(list,dbi=nil)
-        @list=list
-        @dbi=dbi || list.dbi
-        @columns=[]
-      end
-      
-      def each
-        @columns.each_with_index{|column,index|
-          if column.is_a?(Lolita::Configuration::Column)
-            yield column
-          else
-            raise "Any column must be Lolita::Configuratin::Column object instead of #{column.class}."
-          end
-        }
-      end
-
-      def generate!
-        @columns.clear
-        @dbi.fields.each_with_index{|field,index|
-          @columns[index]=Lolita::Configuration::Column.new(@dbi,field)
-        }
-      end
-
-      def add attributes={},&block
-        if block_given?
-          @columns<<build_element(&block)
-        else
-          @columns<<build_element(attributes)
-        end
-        self
-      end
-
-      private
-
-      def collection_variable
-        @columns
-      end
-      
-      def build_element(column=nil,&block)
-        if column.is_a?(Lolita::Configuration::Column)
-          column
-        elsif column.is_a?(Proc)
-          Lolita::Configuration::Column.new(@dbi,&column)
-        elsif block_given?
-          Lolita::Configuration::Column.new(@dbi,&block)
-        elsif [Symbol,String,Hash].include?(column.class)
-          Lolita::Configuration::Column.new(@dbi,column)
-        else
-          raise ArgumentError.new("Column can not be defined with #{column.class}.")
-        end
-      end
-
-    end
-  end
-end
+module Lolita
+  module Configuration
+    class Columns
+
+      include Enumerable
+      include ObservedArray
+      include Lolita::Builder
+      
+      attr_accessor :list
+      attr_reader :dbi
+      
+      def initialize(list,dbi=nil)
+        @list=list
+        @dbi=dbi || list.dbi
+        @columns=[]
+      end
+      
+      def each
+        @columns.each_with_index{|column,index|
+          if column.is_a?(Lolita::Configuration::Column)
+            yield column
+          else
+            raise "Any column must be Lolita::Configuratin::Column object instead of #{column.class}."
+          end
+        }
+      end
+
+      def generate!
+        @columns.clear
+        @dbi.fields.each_with_index{|field,index|
+          @columns[index]=Lolita::Configuration::Column.new(@dbi,field)
+        }
+      end
+
+      def add attributes={},&block
+        if block_given?
+          @columns<<build_element(&block)
+        else
+          @columns<<build_element(attributes)
+        end
+        self
+      end
+
+      private
+
+      def collection_variable
+        @columns
+      end
+      
+      def build_element(column=nil,&block)
+        if column.is_a?(Lolita::Configuration::Column)
+          column
+        elsif column.is_a?(Proc)
+          Lolita::Configuration::Column.new(@dbi,&column)
+        elsif block_given?
+          Lolita::Configuration::Column.new(@dbi,&block)
+        elsif [Symbol,String,Hash].include?(column.class)
+          Lolita::Configuration::Column.new(@dbi,column)
+        else
+          raise ArgumentError.new("Column can not be defined with #{column.class}.")
+        end
+      end
+
+    end
+  end
+end