lolita 3.0.7 → 3.1.0

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

@@ -1,11 +1,13 @@
 module Lolita
   module Configuration
-    class StringField < Lolita::Configuration::Field
-
-      def initialize *args, &block
-        @type="string"
-        super
+    module Field
+      class String < Lolita::Configuration::Field::Base
+        lolita_accessor :simple, :rows
+        def initialize *args, &block
+          @type="string"
+          super
+        end
       end
     end
   end
-end
+end

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

@@ -0,0 +1,13 @@
+module Lolita
+  module Configuration
+    module Field
+      class Time < Lolita::Configuration::Field::Base
+        attr_accessor :format
+        def initialize *args
+          @type="time"
+          super
+        end
+      end
+    end
+  end
+end

data/lib/lolita/configuration/fields.rb

@@ -0,0 +1,36 @@
+module Lolita
+  module Configuration
+    # Lolita::Configuration::Tabs is container class that holds all
+    # tabs for each lolita instance. 
+    # Also it has some useful methods.
+
+    class Fields
+      include Enumerable
+      include Lolita::ObservedArray
+
+      def initialize *args,&block
+        @fields=[]
+        self.instance_eval(&block) if block_given?
+      end
+
+      def clear
+        @fields=[]
+      end
+      
+      def by_name(name)
+        @fields.detect{|field| (field.name==name.to_sym || field.name=="#{name}_id".to_sym) }
+      end
+
+      private
+
+      def collection_variable
+        @fields
+      end
+
+      def build_element(element,&block)
+        element
+      end
+
+    end
+  end
+end

data/lib/lolita/configuration/filter.rb

@@ -0,0 +1,63 @@
+module Lolita
+  module Configuration
+    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)
+        @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
+
+    end
+  end
+end

data/lib/lolita/configuration/list.rb

@@ -1,92 +1,102 @@
-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
-
-      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
-
-      # Block setter for columns
-      def column(*args,&block)
-        set_attribute(:columns)
-        if block_given?
-          @columns<<block
-        else
-          @columns<<args[0]
-        end
-      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)
+          @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
+
+      # Adds filter
+      def filter(*args,&block)
+        @filter ||= Lolita::Configuration::Filter.new(self.dbi,*args,&block)
+      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
+
+      # Block setter for columns
+      def column(*args,&block)
+        set_attribute(:columns)
+        if block_given?
+          @columns<<block
+        else
+          @columns<<args[0]
+        end
+      end
+
+    end
+  end
 end

data/lib/lolita/configuration/page.rb

@@ -71,6 +71,7 @@ module Lolita
       def get_page()
         @page=@dbi.paginate((@page_options||{}).merge(@last_options))
       end
+      
       # Return last paginated page
       # ====Example
       #     list.paginate(2)

data/lib/lolita/configuration/tab.rb

@@ -17,156 +17,162 @@ module Lolita
     #     lolita do
     #       tab(:files)
     #     end
-    class Tab
-      extend Lolita::Configuration::Factory
+    module Tab
+      class Base
+        include Lolita::Builder
 
-      # For different types there are different builders(cells)
-      @@default_tab_type=:default
-      @@available_types=[:content]
-   
-      lolita_accessor :title,:name,:type
-      attr_accessor :dbi,:current_fieldset,:current_dbi
-      attr_reader :field_sets,:nested_form
+        # For different types there are different builders(cells)
+        @@default_tab_type=:default
+        @@available_types=[:content]
+     
+        lolita_accessor :title,:name,:type
+        attr_accessor :dbi,:current_fieldset,:current_dbi
+        attr_reader :field_sets,:nested_form
 
-      # To create new tab the following parametrs need to be provided.
-      # * <tt>dbi</tt> Lolita::DBI::Base object, that represents database.
-      # * <tt>*args</tt> See #set_attributes, for how these args are processed.
-      # * <tt>&block</tt> Block can be passed, anything in block will be evaled for current instance.
-      def initialize dbi,*args,&block
-        @fields=[]
-        @field_sets=[]
-        self.dbi=dbi
-        self.current_dbi=dbi
-        self.set_attributes(*args)
-        self.instance_eval(&block) if block_given?
-        validate
-      end
+        # To create new tab the following parametrs need to be provided.
+        # * <tt>dbi</tt> Lolita::DBI::Base object, that represents database.
+        # * <tt>*args</tt> See #set_attributes, for how these args are processed.
+        # * <tt>&block</tt> Block can be passed, anything in block will be evaled for current instance.
+        def initialize dbi,*args,&block
+          @fields=Lolita::Configuration::Fields.new
+          @field_sets=[]
+          self.dbi=dbi
+          self.current_dbi=dbi
+          self.set_attributes(*args)
+          self.instance_eval(&block) if block_given?
+          validate
+        end
 
-    
-      # Field setter method, accpet <i>*args</i> and <i>&block</i> to be passed.
-      # For details how to pass args and block see Lolita::Configuration::Field.
-      # Return field itself.
-      def field *args, &block
-        field=Lolita::Configuration::Field.add(self.current_dbi,*args,&block)
-        field.field_set=current_fieldset
-        if self.current_dbi!=self.dbi
-          field.nested_in=self.dbi
+      
+        # Field setter method, accpet <i>*args</i> and <i>&block</i> to be passed.
+        # For details how to pass args and block see Lolita::Configuration::Field.
+        # Return field itself.
+        def field *args, &block
+          field=Lolita::Configuration::Field.add(self.current_dbi,*args,&block)
+          field.field_set=current_fieldset
+          if self.current_dbi!=self.dbi
+            field.nested_in=self.dbi
+          end
+          @fields<<field
+          field
         end
-        @fields<<field
-        field
-      end
 
-      # Return all fields in tab.
-      def fields
-        @fields
-      end
+        # Return all fields in tab.
+        def fields
+          @fields
+        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)
-        @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
-          }
+        # 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)
+          @fields=Lolita::Configuration::Fields.new
+          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
-      end
 
-      # Create fields for tab from database.
-      # See Lolita::Adapter classes for use of DB field method.
-      def default_fields
-        self.current_dbi.fields.each{|db_field|
-          self.field(db_field)
-        }
-      end
+        # Create fields for tab from database.
+        # See Lolita::Adapter classes for use of DB field method.
+        def default_fields
+          self.current_dbi.fields.each{|db_field|
+            self.field(db_field)
+          }
+        end
 
-      # Add tab nested fields for <em>class_or_name</em> and <em>&block</em>
-      # that will be evaluted in current tab instance.
-      def nested_fields_for class_or_name,&block
-        current_class=get_class(class_or_name)
-        self.current_dbi=Lolita::DBI::Base.new(current_class)
-        self.instance_eval(&block)
-        self.current_dbi=self.dbi
-      end
+        # Add tab nested fields for <em>class_or_name</em> and <em>&block</em>
+        # that will be evaluted in current tab instance.
+        def nested_fields_for class_or_name,&block
+          current_class=get_class(class_or_name)
+          self.current_dbi=Lolita::DBI::Base.new(current_class)
+          self.instance_eval(&block)
+          self.current_dbi=self.dbi
+        end
 
-      # Return nested field for given <em>class_or_name</em>
-      def nested_fields_of class_or_name
-        current_class=get_class(class_or_name)
-        self.fields.select{|field|
-          field.nested_in?(@dbi) && field.dbi.klass==current_class
-        }
-      end
+        # Return nested field for given <em>class_or_name</em>
+        def nested_fields_of class_or_name
+          current_class=get_class(class_or_name)
+          self.fields.select{|field|
+            field.nested_in?(@dbi) && field.dbi.klass==current_class
+          }
+        end
 
-      # Create new field_set for current tab with given _name_ and <em>&block</em>
-      # that will be evaluted in current tab instance.
-      def field_set name,&block
-        field_set=Lolita::Configuration::FieldSet.new(self,name)
-        self.current_fieldset=field_set
-        @field_sets<<field_set
-        self.instance_eval(&block)
-        self.current_fieldset=nil
-      end
+        # Create new field_set for current tab with given _name_ and <em>&block</em>
+        # that will be evaluted in current tab instance.
+        def field_set name,&block
+          field_set=Lolita::Configuration::FieldSet.new(self,name)
+          self.current_fieldset=field_set
+          @field_sets<<field_set
+          self.instance_eval(&block)
+          self.current_fieldset=nil
+        end
 
-      def fields_with_field_set
-        used_fieldsets=[]
-        self.fields.each{|field|
-          if !field.field_set || (!used_fieldsets.include?(field.field_set))
-            if field.field_set
-              yield field.field_set.fields,field.field_set
-              used_fieldsets<<field.field_set
-            else
-              yield field,nil
+        def fields_with_field_set
+          used_fieldsets=[]
+          self.fields.each{|field|
+            if !field.field_set || (!used_fieldsets.include?(field.field_set))
+              if field.field_set
+                yield field.field_set.fields,field.field_set
+                used_fieldsets<<field.field_set
+              else
+                yield field,nil
+              end
             end
+          }
+        end
+        # tab.field do
+        #  tab.fields_with_fieldset do |field,fieldset|
+        #    =field
+        #  end
+
+
+        # Set attributes from given <em>*args</em>.
+        # First element of args is used as <i>type</i> other interpreted as options.
+        # Every Hash key is used as setter method, and value as method value.
+        # ====Example
+        #     set_attributes(:content,:field=>{:name=>"My Field"})
+        #     set_attributes(:field=>{:name=>"My Field"})
+        def set_attributes *args
+          if args
+            options=args.extract_options!
+            self.type=args.first if args.first.is_a?(Symbol)
+            options.each{|method,options|
+              self.send(:"#{method}=",options)
+            }
           end
-        }
-      end
-      # tab.field do
-      #  tab.fields_with_fieldset do |field,fieldset|
-      #    =field
-      #  end
+          
+        end
 
+        private
 
-      # Set attributes from given <em>*args</em>.
-      # First element of args is used as <i>type</i> other interpreted as options.
-      # Every Hash key is used as setter method, and value as method value.
-      # ====Example
-      #     set_attributes(:content,:field=>{:name=>"My Field"})
-      #     set_attributes(:field=>{:name=>"My Field"})
-      def set_attributes *args
-        if args
-          options=args.extract_options!
-          self.type=args.first if args.first.is_a?(Symbol)
-          options.each{|method,options|
-            self.send(:"#{method}=",options)
-          }
+        def set_default_attributes
+          @type=@@default_tab_type unless @type
+          @name="tab_#{self.__id__}" unless @name
+          @title=@type.to_s.humanize unless @title
         end
         
-      end
-
-      private
+        def get_class(str_or_sym_or_class)
+          str_or_sym_or_class.is_a?(Class) ? str_or_sym_or_class : str_or_sym_or_class.to_s.camelize.constantize
+        end
+        
+        def validate
+          set_default_attributes
+        end
 
-      def set_default_attributes
-        @type=@@default_tab_type unless @type
-        @name="tab_#{self.__id__}" unless @name
-        @title=@type.to_s.humanize unless @title
-      end
-      
-      def get_class(str_or_sym_or_class)
-        str_or_sym_or_class.is_a?(Class) ? str_or_sym_or_class : str_or_sym_or_class.to_s.camelize.constantize
-      end
-      
-      def validate
-        set_default_attributes
-      end
-      
-      class << self
-        def default_types
-          @@available_types
+        def builder_local_variable_name
+          :tab
+        end
+        
+        class << self
+          def default_types
+            @@available_types
+          end
         end
       end
     end