lolita 3.0.3

data/lib/lolita/configuration/field_extensions/collection.rb

@@ -0,0 +1,57 @@
+module Lolita
+  module Configuration
+    # Field Extensions is used to extend Field instances. FieldExtensions allow
+    # different field types have same property with different functionality. For
+    # example, <code>:find_options</code>, it is possible to avoid <code>order</code>
+    # and <code>group</code> usage when it is not neccessary and allow when you
+    # need it.
+    # It depends on field
+    # _type_. Each different field type, can have one extension module. Instance
+    # will be automaticly extended when type is assigned, therefor type should
+    # be called before any type-specific method is called.
+    module FieldExtensions
+      module Collection
+
+        lolita_accessor :conditions,:text_method,:value_method,:find_options
+
+        # Collect values for collection type field.
+        # Uses <code>text_method</code> for content. By default it search for
+        # first _String_ type field in DB. Uses <code>value_method</code> for value,
+        # by default it it is <code>id</code>. Use <code>conditions</code> or
+        # <code>find_options</code> for advanced search. When <code>find_options</code>
+        # is used, than <code>conditions</code> is ignored.
+        def association_values() #TODO test
+          if @association
+            klass=@dbi.association_class_name(@association).camelize.constantize
+            current_text_method=@text_method || default_text_method(klass)
+            current_value_method=@value_method || :id
+            options=@find_options || {}
+            options[:conditions]||=@conditions
+            
+            klass.find(:all,options).map{|r|
+              [r.send(current_text_method),r.send(current_value_method)]
+            }
+          else
+            []
+          end
+        end
+
+        private
+
+        def default_text_method(klass)
+          assoc_dbi=Lolita::DBI::Base.new(klass)
+          field=assoc_dbi.fields.detect{|f| f[:type].downcase=="string"}
+          if field
+            field[:name]
+          else
+            raise Lolita::FieldTypeError, %^
+            	Can't find any content field in #{assoc_dbi.klass}. 
+            	Use text_method in #{klass} to set one.
+           ^
+          end
+        end
+        # MODULE end
+      end
+    end
+  end
+end

data/lib/lolita/configuration/field_set.rb

@@ -0,0 +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
+end

data/lib/lolita/configuration/list.rb

@@ -0,0 +1,92 @@
+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
+end

data/lib/lolita/configuration/page.rb

@@ -0,0 +1,98 @@
+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)
+        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.empty? ? nil : self.sort_columns
+        unless hold
+          get_page()
+        end
+      end
+
+      def get_page()
+        @page=@dbi.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
+
+      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
+        }
+      end
+    end
+  end
+end

data/lib/lolita/configuration/tab.rb

@@ -0,0 +1,181 @@
+module Lolita
+  module Configuration
+    # Tab is used as a container for different type of resource content.
+    # It can contain fields, images, audio, video files, maps and other stuff.
+    # Tab contain following parts, that also are configurable through block or
+    # arguments passed to tab.
+    # * <tt>nested_fields_for</tt> Create fields for different DB table/collection than given.
+    # * <tt>field_set</tt> Create fields set for ease use in builders.
+    # * <tt>field</tt> Create field in tab, fields also can be included in #nested_fields_for and
+    #   #field_set
+    # * <tt>default_fields</tt>
+    # To create new tab you should pass Lolita::DBI object and tab type, default is :content
+    # ====Example
+    #     Lolita::Configuration::Tab.new(Lolita::DBI.new(Post),:images)
+    # To define tab in ORM model, through lolita configuration do the following
+    # ====Example
+    #     lolita do
+    #       tab
+    class Tab
+
+      # For different types there are different builders(cells)
+      @@available_types=[:content]
+   
+      lolita_accessor :title,:name
+      attr_accessor :dbi,:type,: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
+
+      # 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.new(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
+
+      # Return all fields in tab. If fields not defined then set default fields.
+      def fields
+        if @fields.empty?
+          set_default_fields
+        end
+        @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
+          }
+        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
+
+      # 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
+
+      # 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
+            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 || :default
+          options.each{|method,options|
+            self.send(:"#{method}=",options)
+          }
+        end
+        
+      end
+
+      private
+
+      def set_default_fields
+        if @type==:content && @fields.empty?
+          default_fields
+        end
+      end
+
+      def set_default_attributes
+        @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
+        if type==:default && fields.empty?
+          raise Lolita::NoFieldsGivenError, "At least one field must be specified for default tab."
+        end
+      end
+      
+      class << self
+        def default_types
+          @@available_types
+        end
+      end
+    end
+  end
+end