lolita 3.1.17 → 3.1.18

data/lib/lolita/builder.rb

@@ -80,7 +80,7 @@ module Lolita
       end
 
       def build
-        
+    
         path = if conditions?
           switch_path do |name,state|
             if conditions_met?

data/lib/lolita/configuration/base.rb

@@ -15,9 +15,11 @@ module Lolita
 
       attr_reader :dbi,:klass
       @@generators=[:tabs,:list]
+
       class << self
+
         def add_generator(method)
-          @@generators<<method.to_sym
+          @@generators<<method.to_sym 
         end
       end
       # When configuration is defined in class than you don't need to worry about
@@ -38,8 +40,9 @@ module Lolita
       #     Person.lolita=Lolita::Configuration::Base.new(Person)
       #     Person.lolita.klass #=> Person
       def initialize(orm_class,&block)
+        @in_callback_mode = false
         @klass=orm_class
-        @dbi=Lolita::DBI::Base.new(orm_class)
+        @dbi=Lolita::DBI::Base.create(orm_class)
         block_given? ? self.instance_eval(&block) : self.generate!
       end
 
@@ -50,6 +53,10 @@ module Lolita
         Lolita::LazyLoader.lazy_load(self,:@list,Lolita::Configuration::List,@dbi,&block)
       end
 
+      def list=(new_list)
+        @list = new_list if new_list.is_a?(Lolita::Configuration::List)
+      end
+
       # Create collection of Lolita::Configuration::Tab, loading lazy.
       # See Lolita::Configuration::Tabs for details.
       def tabs &block
@@ -60,7 +67,7 @@ module Lolita
       # 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)
+        self.tabs<<Lolita::Configuration::Factory::Tab.add(@dbi,*args,&block)
       end
       
       # Call all supported instance metods to set needed variables and initialize object with them.
@@ -69,7 +76,13 @@ module Lolita
           self.send(generator)
         }
       end
-      
+
+      private
+
+      def after_initialize
+        @dbi.klass.run(:after_lolita_loaded, :once => self)
+      end
+
     end
   end
 end

data/lib/lolita/configuration/column.rb

@@ -12,7 +12,21 @@ module Lolita
         self.set_attributes(*args)
         self.instance_eval(&block) if block_given?
         validate
-        set_default_values
+      end
+
+      def value(record)
+        if self.name.to_s.match(/_id$/) && record.respond_to?(self.name.to_s.gsub(/_id$/,"").to_sym)
+          remote_record = record.send(self.name.to_s.gsub(/_id$/,"").to_sym)
+          if remote_record.respond_to?(:title)
+            remote_record.send(:title)
+          elsif remote_record.respond_to?(:name)
+            remote_record.send(:name)
+          else
+            record.send(self.name)
+          end
+        else
+          record.send(self.name)
+        end
       end
 
       def title(value=nil)
@@ -24,20 +38,34 @@ module Lolita
       def sortable?
         @sortable
       end
-
-      def currently_sorting?(params)
-        @sortable && params[:sc].to_s==self.name.to_s
+      
+      def current_sort_state(params)
+        @sortable && sort_pairs(params).detect{|pair| pair[0]==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"
+      def sort_params params
+        if @sortable
+          pairs = sort_pairs(params)
+          found_pair = false
+          pairs.each_with_index{|pair,index|
+            if pair[0] == self.name.to_s
+              pairs[index][1] = pair[1] == "asc" ? "desc" : "asc"
+              found_pair = true
+            end
+          }
+          unless found_pair
+            pairs << [self.name.to_s,"asc"]
+          end
+          (pairs.map{|pair| pair.join(",")}).join("|")
         else
-          "desc"
+          ""
         end
-        {:sc=>self.name,:sd=>direction}
       end
-      
+
+      def sort_pairs params
+        (params[:s] || "").split("|").map{|pair| pair.split(",")}
+      end
+
       # Define format, for details see Lolita::Support::Formatter and Lolita::Support::Formater::Rails
       def formatter(value=nil,&block)
         if block_given?
@@ -61,29 +89,20 @@ module Lolita
       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}")
+        options = args ? args.extract_options! : {}
+        if args[0].respond_to?(:field)
+          [:name,:type].each do |attr|
+            self.send(:"#{attr}=",args[0].send(attr))
           end
+        elsif args[0]
+          self.name = args[0]
+        end
+        options.each do |attr_name,value|
+          self.send(:"#{attr_name}=",value)
         end
       end
       
       private
-      
-      def set_default_values
-        @sort_direction||=:desc
-      end
 
       def validate
         raise ArgumentError.new("Column must have name.") unless self.name

data/lib/lolita/configuration/columns.rb

@@ -28,7 +28,7 @@ module Lolita
       def generate!
         @columns.clear
         @dbi.fields.each_with_index{|field,index|
-          unless Lolita::Configuration::Helper.tehnical_field?(field,@dbi)
+          unless field.technical?
             @columns << Lolita::Configuration::Column.new(@dbi,field)
           end
         }

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

@@ -0,0 +1,45 @@
+module Lolita
+  module Configuration
+    module Factory
+      class Field
+        # There are three ways to add field.
+        # *<tt>first</tt> - Pass name and type
+        #   Field.add(dbi,"name","type")
+        # *<tt>second</tt> - Pass it through hash
+        #   Field.add(dbi,:name => "name", :type => "type")
+        # *<tt>third</tt> - Pass dbi_field
+        #   Field.add(dbi,:dbi_field => dbi.fields.first)
+        def self.add(dbi,*args,&block)
+          
+          options = args ? args.extract_options! : {}
+          dbi_field = options[:dbi_field]
+          name = args[0] || options[:name] || (dbi_field ? dbi_field.name : nil)
+          dbi_field ||= dbi.field_by_name(name)
+          dbi_field ||= dbi.field_by_association(name)
+          association ||= detect_association(dbi,name)
+
+          type = args[1] || options[:type] || 
+            (association ? :array : nil ) ||
+            (dbi_field ? dbi_field.type : nil) || 
+            :string
+          options[:dbi_field] = dbi_field
+          if !name || !type
+            raise Lolita::FieldTypeError, "type not defined. Set is as second argument or as :dbi_field where value is Adapter::[ORM]::Field object."
+          else
+             
+            field_class(type).new(dbi,name,type,options,&block)
+          end
+
+        end
+
+        def self.detect_association(dbi,name)
+          dbi.associations[name.to_sym]
+        end
+
+        def self.field_class(name)
+          ("Lolita::Configuration::Field::"+name.to_s.camelize).constantize
+        end
+      end
+    end
+  end
+end

data/lib/lolita/configuration/factory/tab.rb

@@ -0,0 +1,18 @@
+module Lolita
+  module Configuration
+    module Factory
+      class Tab
+
+        def self.add(dbi,*args, &block)
+          type = args && args[0].is_a?(Symbol) ? args[0] : :default
+          field_class(type).new(dbi,*args,&block)
+        end
+
+        def self.field_class(name)
+          ("Lolita::Configuration::Tab::"+name.to_s.camelize).constantize
+        end
+
+      end
+    end
+  end
+end

data/lib/lolita/configuration/field.rb

@@ -28,47 +28,25 @@ module Lolita
       class Base
         include Lolita::Builder
 
-        @@default_type="string"
-        lolita_accessor :name,:title,:field_set, :nested_form,:nested_for,:options, :html_options,:record,:association
+        @@default_type = :string
+        lolita_accessor :name,:title,:field_set, :nested_form,:nested_for,:options, :html_options
         attr_reader :dbi,:nested_in
+        attr_accessor :dbi_field
         
-        def initialize dbi, *args, &block
+        def initialize dbi,name,*args, &block
           @dbi=dbi
-          before_init(*args)
-          begin
-            self.set_attributes(*args)
-            if block_given?
-              self.instance_eval(&block)
-              process_type unless @type 
-            end
-            set_default_values
-            validate
-          rescue Exception=>e
-            unless Lolita::Configuration::Field.temp_object?
-              raise e
-            end
-          end
-        end
-        
-        def value value=nil, &block
-          self.send(:value=,value,&block) if value || block_given?
-          unless @value
-            self.record_value
-          else
-            if @value.is_a?(Proc)
-              @value.call(self)
-            else
-              @value
-            end
-          end
-        end
+          self.name = name
+          options = args ? args.extract_options! : {}
+          type = args[0]
+
+          self.type = type || @@default_type
 
-        def value=(value=nil,&block)
+          self.set_attributes(options)
           if block_given?
-            @value=block
-          else
-            @value=value
+            self.instance_eval(&block)
           end
+          set_default_values
+          validate
         end
         
         def title(value=nil)
@@ -87,18 +65,16 @@ module Lolita
         end
 
         def name=(value)
-          @name=value ? value.to_sym : nil
-        end
-
-        def type_name
-          self.type.to_s.downcase
+          @name= value ? value.to_sym : nil
         end
 
         def nested_in=(dbi)
           unless self.dbi.associations_class_names.include?(dbi.klass.to_s)
             raise Lolita::ReferenceError, "There is no association between #{self.dbi.klass} and #{dbi.klass}"
           end
-          raise ArgumentError, "Field can be nested only in Lolita::DBI::Base object." unless dbi.is_a?(Lolita::DBI::Base)
+          if !dbi.is_a?(Lolita::DBI::Base) && !dbi.class.to_s.match(/Lolita::Adapter/)
+            raise ArgumentError, "Field can be nested only in Lolita::DBI::Base object." 
+          end
           @nested_in=dbi
         end
         
@@ -107,29 +83,26 @@ module Lolita
         end
 
         def nested_in?(dbi_or_class)
-          if dbi_or_class.is_a?(Lolita::DBI::Base)
+          if dbi_or_class.respond_to?(:klass)
             self.nested_in && self.nested_in.klass==dbi_or_class.klass
           else
             self.nested_in && self.nested_in.klass==dbi_or_class
           end
         end
       
-
-        def set_attributes(*args)
-          @given_attributes.each{|attr,value|
-            if (attr.to_sym==:type && !@type) || attr.to_sym!=:type
+        def set_attributes(attributes)
+          excluded_keys = [:name,:type]
+          attributes.each{|attr,value|
+            unless excluded_keys.include?(attr.to_sym)
               self.send(:"#{attr}=",value)
             end
           }
         end
 
-        # TODO is this useable
-        def record_value #TODO test
-          if self.record
-            self.record.send(self.name.to_sym)
-          else
-            nil
-          end
+        def find_dbi_field
+          @dbi_field ||= self.dbi.fields.detect{|field|
+            field.name.to_s == @name.to_s || (field.association && field.association.name.to_s == @name.to_s)
+          }
         end
 
         private
@@ -141,77 +114,19 @@ module Lolita
         def set_default_values
           self.options||={}
           self.html_options ||= {}
-        end
-
-         def before_init *args
-          extract_args *args
-          set_name
-          if @name
-            process_type
-          end
-        end
-
-        def process_type
-          set_association
-          set_type_from_args
-          set_type
-        end
-
-         def extract_args *args
-          if args
-            @given_args=args
-            @given_attributes=@given_args.extract_options!
+          @html_options[:class] = if @html_options[:class]
+            "#{@html_options[:class]} #{self.type}"
           else
-            @given_args=[]
-            @given_attributes={}
+            self.type.to_s
           end
         end
 
-        def set_name
-          if @given_args.first
-            self.name=@given_args.first 
-          else
-            self.name=@given_attributes[:name]
-          end
-        end
-
-        def set_type_from_args
-          self.type=@given_args[1] if @given_args[1]
-        end
-
-        def set_type
-          if !@type
-           if @association
-                self.type="array"
-            elsif dbi_field=self.dbi.fields.detect{|f| f[:name].to_s==@name.to_s}
-              self.type=dbi_field[:type]
-              self.options=dbi_field[:options]
-            end
-          end
-          if @type.nil? || @type.to_s.downcase=="object"
-            self.type=@@default_type
-          end
-        end
-
-        # Need here because this don't know how to recognize association.
-        # TODO maybe need move to adapter, and it is converted there
-        def set_association #TODO test
-          assoc_name=@name.to_s.gsub(/_id$/,"") 
-          @association||=@dbi.reflect_on_association(assoc_name.to_sym) ||
-            @dbi.reflect_on_association(assoc_name.pluralize.to_sym)
-        end
-
         def validate
           unless self.name
             raise Lolita::FieldNameError, "Field must have name."
           end
-          #FIXME need this validation
-          #        if !@value && !@dbi.klass.instance_methods.include?(self.name.to_s)
-          #          raise Lolita::FieldNameError, "#{@dbi.klass} must respond to #{self.name} method."
-          #        end
         end
-       
       end
     end
   end
-end
+end