lolita 3.2.0.rc.7 → 3.2.0.rc.9

data/lib/lolita/configuration/action.rb

@@ -0,0 +1,53 @@
+module Lolita
+  module Configuration
+    class Action
+
+      include Lolita::Builder
+      lolita_accessor :url
+      attr_writer :title,:html
+      attr_reader :name
+
+      def initialize(dbi,name, options ={}, &block)
+        @dbi = dbi
+        @name = name
+        options.each do |key,value|
+          self.send(:"#{key}=",value)
+        end
+        instance_eval(&block) if block_given?
+      end
+
+      def html attributes = nil
+        if attributes
+          @html = attributes
+        else
+          result = {}
+          (@html || {}).each{|k,v|
+            result[k] = v.respond_to?(:call) ? v.call : v
+          }
+          result
+        end
+      end
+
+      def title value=nil
+        if value
+          @title = value
+        else
+          if @title
+            @title.respond_to?(:call) ? @title.call : @title
+          else
+            ::I18n.t("#{@dbi.klass.to_s.underscore}.actions.#{@name}")
+          end
+        end
+      end
+
+      def view_url view, record
+        if @url.respond_to?(:call)
+          @url.call(view,record)
+        else
+          @url
+        end
+      end
+
+    end
+  end
+end

data/lib/lolita/configuration/base.rb

@@ -1,89 +1,41 @@
-# 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
+    # This is superclass of other configuration classes, that is used to configure different parts of resource. 
     class Base
+      include Lolita::Builder
+      attr_reader :dbi
+      attr_writer :component
+      alias :dbp :dbi
 
-      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)
-        @in_callback_mode = false
-        @klass=orm_class
-        @dbi=Lolita::DBI::Base.create(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)
+      def initialize(dbp, *args)
+        set_and_validate_dbp dbp
+        set_attributes *args
       end
 
-      def list=(new_list)
-        @list = new_list if new_list.is_a?(Lolita::Configuration::List)
+      def component
+        @component ||= "Lolita::Components::#{self.class.to_s.sub("Lolita::","")}Component".constantize.new(self)
       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
+      private
 
-      # 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::Factory::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)
-        }
+      def set_and_validate_dbp(dbp)
+        @dbp = dbp
+        @dbi = dbp
+        raise Lolita::UnknownDBPError.new("No DBP specified for #{self.class.to_s.split("::").last}") unless @dbp
       end
 
-      private
+      alias :set_and_validate_dbi :set_and_validate_dbp
 
-      def after_initialize
-        @dbi.klass.run(:after_lolita_loaded, :once => self)
+      # Used to set attributes if block not given.
+      def set_attributes(*args)
+        options = args && args.extract_options! || {}
+        options.each do |attr_name,value|
+          self.send("#{attr_name}=".to_sym,value)
+        end
       end
 
     end
+
   end
 end
 

data/lib/lolita/configuration/column.rb

@@ -1,48 +1,72 @@
 module Lolita
   module Configuration
-    class Column 
-
-      include Lolita::Builder
+    class Column < Lolita::Configuration::Base
       
       MAX_TEXT_SIZE=20
-      lolita_accessor :name,:title,:type,:options,:sortable
+      attr_reader :list_association_name
+      lolita_accessor :name,:title,:type,:options,:sortable, :association
       
       def initialize(dbi,*args,&block)
-        @dbi=dbi
+        set_and_validate_dbi(dbi)
         self.set_attributes(*args)
         self.instance_eval(&block) if block_given?
         validate
+        normalize_attributes
+        detect_association
+      end
+
+      def list *args, &block
+        if args && args.any? || block_given?
+          detect_association
+          list_association = args[0] && @dbi.associations[args[0].to_s.to_sym] || self.association
+          list_dbi = list_association && Lolita::DBI::Base.create(list_association.klass)
+          raise Lolita::UnknownDBPError.new("DBI is not specified for list in column #{self}") unless list_dbi
+          @list_association_name = list_association.name
+          Lolita::LazyLoader.lazy_load(self,:@list,Lolita::Configuration::NestedList, list_dbi, self, :association_name => list_association.name, &block)
+        else
+          @list
+        end
       end
 
+      # Return value of column from given record. When record matches foreign key patter, then foreign key is used.
+      # In other cases it just ask for attribute with same name as column.
       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)
+        if self.association
+          if self.association.macro == :one &&  dbi.klass.respond_to?(:human_attribute_name)
+            dbi.klass.human_attribute_name(association.name)
+            # dbi.record(record.send(association.name)).title
+          elsif dbi.klass.respond_to?(:human_attribute_name)
+            "#{dbi.klass.human_attribute_name(association.name)} (#{record.send(association.name).count})"
           else
-            record.send(self.name)
+            "#{association.name} (#{record.send(association.name).count})"
           end
         else
           record.send(self.name)
         end
       end
 
-      def title(value=nil)
-        @title=value if value
-        @title||=@dbi.klass.human_attribute_name(@name.to_s)
-        @title
+      def formatted_value(record,view)
+        self.formatter.with(self.value(record),record,self)
+      end
+
+      # Set/Get title. Getter return title what was set or ask for human_attribute_name to model.
+      def title(new_title=nil)
+        if new_title
+          @title = new_title
+        end
+        Lolita::Utils.dynamic_string(@title, :default => @name && @dbi.klass.human_attribute_name(@name))
       end
 
       def sortable?
         @sortable
       end
 
+      # Find if any of received sort options matches this column.
       def current_sort_state(params)
         @sortable && sort_pairs(params).detect{|pair| pair[0]==self.name.to_s} || []
       end
 
+      # Return string with sort options for column if column is sortable.
       def sort_params params
         if @sortable
           pairs = sort_pairs(params)
@@ -62,6 +86,7 @@ module Lolita
         end
       end
 
+      # Create array of sort information from params.
       def sort_pairs params
         (params[:s] || "").split("|").map{|pair| pair.split(",")}
       end
@@ -104,7 +129,16 @@ module Lolita
       
       private
 
+      def detect_association
+        @association ||= dbi.associations[self.name]
+      end
+
+      def normalize_attributes
+        @name = @name.to_sym
+      end
+
       def validate
+        raise Lolita::UnknownDBIError.new("DBI is not specified for column #{self}") unless self.dbi
         raise ArgumentError.new("Column must have name.") unless self.name
       end
     end

data/lib/lolita/configuration/columns.rb

@@ -5,17 +5,34 @@ module Lolita
       include Enumerable
       include ObservedArray
       include Lolita::Builder
-      
-      attr_accessor :list
+
       attr_reader :dbi
+      attr_accessor :parent
       
-      def initialize(list,dbi=nil)
-        @list=list
-        @dbi=dbi || list.dbi
+      def initialize(dbi, *args, &block)
+        @dbi=dbi
         @columns=[]
+        @generated_yet = (block_given? || (args && args.any?))
+        set_attributes(*args)
+        self.instance_eval(&block) if block_given?
+      end
+
+      # Add column to columns Array. Receive attributes for column as Hash and/or block.
+      def column *args, &block
+        @columns << build_element(*args,&block)
+        @columns.last
+      end
+
+      # Find first column by name
+      def by_name(name)
+        name = name.to_sym
+        self.detect do |column|
+          column.name == name
+        end
       end
       
       def each
+        self.populate
         @columns.each_with_index{|column,index|
           if column.is_a?(Lolita::Configuration::Column)
             yield column
@@ -25,41 +42,52 @@ module Lolita
         }
       end
 
+
       def generate!
+        @generated_yet = true
         @columns.clear
         @dbi.fields.each_with_index{|field,index|
           unless field.technical?
-            @columns << Lolita::Configuration::Column.new(@dbi,field)
+            column(field)
           end
         }
       end
 
-      def add attributes={},&block
-        if block_given?
-          @columns<<build_element(&block)
-        else
-          @columns<<build_element(attributes)
-        end
-        self
+      def populate
+        self.generate! if @columns.empty? && !@generated_yet
       end
 
       private
 
+      def set_attributes(*args)
+        if args && args.any?
+          options = args.extract_options! || {}
+          args.each do |col_name|
+            column col_name
+          end
+          options.each do |key,value|
+            if key == :column
+              column value
+            end
+          end
+        end
+      end
+
+      def generate_collection_elements!
+        self.populate
+      end
+
       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)
+      def build_element(*column,&block)
+        if column[0].is_a?(Lolita::Configuration::Column)
+          column[0]
+        elsif column[0].is_a?(Proc)
+          Lolita::Configuration::Column.new(@dbi,&column[0]) 
         else
-          raise ArgumentError.new("Column can not be defined with #{column.class}.")
+          Lolita::Configuration::Column.new(@dbi,*column, &block)
         end
       end
 

data/lib/lolita/configuration/core.rb

@@ -0,0 +1,80 @@
+module Lolita
+  module Configuration
+
+    # This is class of lolita instance.
+    # 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 Core
+      attr_reader :dbi,:klass
+      @@generators=[:tabs,:list]
+
+      # 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
+        @dbp = Lolita::DBI::Base.create(orm_class)
+        @dbi = @dbp
+        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,@dbp,&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
+        Lolita::LazyLoader.lazy_load(self, :@tabs,Lolita::Configuration::Tabs,@dbp,&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::Factory::Tab.add(@dbp,*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
+
+      private
+
+      def generators
+        @@generators
+      end
+
+      def after_initialize
+        @dbp.klass.run(:after_lolita_loaded, :once => self)
+      end
+
+    end
+  end
+end