lolita 3.0.7 → 3.1.0

data/lib/lolita/configuration/factory.rb

@@ -10,7 +10,7 @@ module Lolita
       def add(dbi,*args,&block)
         @create_temp_object=true
         begin
-          temp_object=self.new(dbi,*args,&block)
+          temp_object=self.const_get(:Base).new(dbi,*args,&block)
         rescue Exception => e
           raise e
         ensure
@@ -24,21 +24,21 @@ module Lolita
 
       def factory(name)
         begin
-          Lolita::Configuration.const_get(:"#{to_class(name)}#{factory_name}")
-        rescue
-          error_class=Lolita.const_get(:"#{factory_name}NotFoundError")
-          raise error_class, "Can't find field Lolita::Configuration::#{to_class(name)}#{factory_name}. Add in /configuration/#{factory_name.downcase}/#{name.to_s.downcase}.rb"
+          self.const_get(:"#{to_class(name)}")
+        rescue NameError
+          error_class=Lolita::ConfigurationClassNotFound
+          raise error_class, "Can't find #{self}::#{to_class(name)}. Should be in /configuration/#{factory_name}/#{name}.rb"
         end
       end
 
       def to_class(name)
-        name.to_s.downcase.gsub(/_\w/) do |m|
+        name.to_s.downcase.gsub(/_id$/, "").gsub(/(^\w|_\w)/) do |m|
           m.gsub("_","").upcase
-        end.humanize
+        end
       end
 
       def factory_name
-        @factory_name||=self.to_s.split("::").last
+        @factory_name||=self.to_s.split("::").last.downcase
         @factory_name
       end
     end

data/lib/lolita/configuration/field.rb

@@ -23,133 +23,189 @@ module Lolita
     #         end
     #       end
     #     end
-    class Field
-      extend Lolita::Configuration::Factory
+    module Field
 
-      @@default_type="string"
-      lolita_accessor :name,:title,:type,:field_set,:nested_for,:options, :html_options,:record,:association
-      attr_reader :dbi,:nested_in
-      
-      def initialize dbi, *args, &block
-        @dbi=dbi
-        begin
-          self.set_attributes(*args)
-          self.instance_eval(&block) if block_given?
-          set_default_values
-          validate
-        rescue Exception=>e
-          unless self.class.temp_object?
-            raise e
+      class Base
+        include Lolita::Builder
+
+        @@default_type="string"
+        lolita_accessor :name,:title,:field_set,:nested_for,:options, :html_options,:record,:association
+        attr_reader :dbi,:nested_in
+        
+        def initialize dbi, *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
-      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)
+        
+        def value value=nil, &block
+          self.send(:value=,value,&block) if value || block_given?
+          unless @value
+            self.record_value
           else
-            @value
+            if @value.is_a?(Proc)
+              @value.call(self)
+            else
+              @value
+            end
           end
         end
-      end
 
-      def value=(value=nil,&block)
-        if block_given?
-          @value=block
-        else
-          @value=value
+        def value=(value=nil,&block)
+          if block_given?
+            @value=block
+          else
+            @value=value
+          end
+        end
+        
+        def type value=nil
+          @type=value.to_s.underscore if value
+          @type
         end
-      end
 
-      def name=(value)
-        @name=value.to_sym
-      end
+        def type=(value)
+          @type=value ? value.to_s.underscore : nil
+        end
 
-      def type_name
-        self.type.to_s.downcase
-      end
+        def name=(value)
+          @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}"
+        def type_name
+          self.type.to_s.downcase
         end
-        raise ArgumentError, "Field can be nested only in Lolita::DBI::Base object." unless dbi.is_a?(Lolita::DBI::Base)
-        @nested_in=dbi
-      end
-      
-      def nested?
-        !self.nested_in.nil?
-      end
 
-      def nested_in?(dbi_or_class)
-        if dbi_or_class.is_a?(Lolita::DBI::Base)
-          self.nested_in && self.nested_in.klass==dbi_or_class.klass
-        else
-          self.nested_in && self.nested_in.klass==dbi_or_class
+        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)
+          @nested_in=dbi
+        end
+        
+        def nested?
+          !self.nested_in.nil?
+        end
+
+        def nested_in?(dbi_or_class)
+          if dbi_or_class.is_a?(Lolita::DBI::Base)
+            self.nested_in && self.nested_in.klass==dbi_or_class.klass
+          else
+            self.nested_in && self.nested_in.klass==dbi_or_class
+          end
         end
-      end
       
-      def set_attributes(*args)
-        if args
-          attributes=args.extract_options!
-          self.name=args.first if args.first
-          self.type=args[1] if args[1]
-          attributes.each{|attr,value|
-            self.send(:"#{attr}=",value)
+
+        def set_attributes(*args)
+          @given_attributes.each{|attr,value|
+            if (attr.to_sym==:type && !@type) || attr.to_sym!=:type
+              self.send(:"#{attr}=",value)
+            end
           }
         end
-      end
 
-      # TODO is this useable
-      def record_value #TODO test
-        if self.record
-          self.record.send(self.name.to_sym)
-        else
-          nil
+        # TODO is this useable
+        def record_value #TODO test
+          if self.record
+            self.record.send(self.name.to_sym)
+          else
+            nil
+          end
+        end
+
+        private
+       
+        def builder_local_variable_name 
+          :field
         end
-      end
 
-      private
-     
+        def set_default_values
+          self.title||=self.name.to_s.gsub("_", " ").capitalize
+          self.options||={}
+        end
 
-      def set_default_values
-        set_association
-        set_type
-        self.title||=self.name.to_s.capitalize
-        self.options||={}
-      end
+         def before_init *args
+          extract_args *args
+          set_name
+          if @name
+            process_type
+          end
+        end
 
-      def set_type
-        @type=@type.to_s.downcase if @type
-        if @association
-          @type="collection"
-        elsif @type.nil? || @type.to_s=="object"
-          @type=@@default_type
+        def process_type
+          set_association
+          set_type_from_args
+          set_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 extract_args *args
+          if args
+            @given_args=args
+            @given_attributes=@given_args.extract_options!
+          else
+            @given_args=[]
+            @given_attributes={}
+          end
+        end
 
-      def validate
-        unless self.name
-          raise Lolita::FieldNameError, "Field must have name."
+        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
-        #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

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

@@ -0,0 +1,74 @@
+module Lolita
+  module Configuration
+    module Field
+      class Array < Lolita::Configuration::Field::Base
+        lolita_accessor :conditions,:text_method,:value_method,:find_options,:association_type,:include_blank
+
+        def initialize *args,&block
+          @type="array"
+          self.builder="select"
+          @include_blank=true
+          super
+          set_association_type
+        end
+
+        def options_for_select=(value=nil)
+          @options_for_select=value
+        end
+
+        def options_for_select value=nil, &block
+          @options_for_select=value || block if value || block_given?
+          @options_for_select
+        end
+
+        # Collect values for array 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
+          @association_values||=if options_for_select
+          options_for_select
+        elsif @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
+        @association_values
+      end
+
+      private
+
+      def set_association_type #TODO test
+        if @association
+          @association_type||=(@dbi.association_macro(@association) || :one)
+        else
+          @association_type||=:one
+        end
+      end
+
+      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
+    end
+  end
+end
+end

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

@@ -0,0 +1,12 @@
+module Lolita
+  module Configuration
+    module Field
+      class BigDecimal < Lolita::Configuration::Field::Base
+        def initialize *args, &block
+          @type="big_decimal"
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -1,10 +1,12 @@
 module Lolita
   module Configuration
-    class BooleanField < Lolita::Configuration::Field
-      def initialize *args
-        @type="boolean"
-        super
+    module Field
+      class Boolean < Lolita::Configuration::Field::Base
+        def initialize *args
+          @type="boolean"
+          super
+        end
       end
     end
   end
-end
+end

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

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

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

@@ -1,10 +1,12 @@
 module Lolita
   module Configuration
-    class IntegerField < Lolita::Configuration::Field
-      def initialize *args
-        @type="integer"
-        super
+    module Field
+      class Integer < Lolita::Configuration::Field::Base
+        def initialize *args
+          @type="integer"
+          super
+        end
       end
     end
   end
-end
+end