lolita 3.4.2 → 3.4.3

data/lib/lolita/components/base.rb

@@ -1,12 +1,12 @@
-module Lolita
-  module Components
-    
-    class Base
-      attr_reader :parent
-      def initialize(parent)
-        @parent = parent
-      end
-    end
-
-  end
+module Lolita
+  module Components
+    
+    class Base
+      attr_reader :parent
+      def initialize(parent)
+        @parent = parent
+      end
+    end
+
+  end
 end

data/lib/lolita/configuration.rb

@@ -1,61 +1,61 @@
-module Lolita
-   # All classes that want to use lolita for configuration should include this module.
-  module Configuration
-    # When Lolita::Configuration is included, it add hook for class <em>:after_lolita_loaded</em> and define class methods
-    # <em>lolita</em> and <em>lolita=</em> and instance method <em>lolita</em> that refers to class method with same name.
-    def self.included(base)
-      base.class_eval do
-        include Lolita::Hooks
-        add_hook :after_lolita_loaded
-
-        extend ClassMethods
-        def lolita
-          self.class.lolita
-        end
-      end
-    end
-
-    module ClassMethods
-      # This is main method for configuration, it initialize new Lolita::Configuration::Core object, that have other methost to 
-      # define different parts of configuration.
-      def lolita(&block)
-        Lolita::LazyLoader.lazy_load(self,:@lolita,Lolita::Configuration::Core,self,&block)
-      end
-      
-      def lolita=(value)
-        if value.is_a?(Lolita::Configuration::Core) || value.nil?
-          @lolita = value
-        else
-          raise ArgumentError.new("Only Lolita::Configuration::Core is acceptable.")
-        end
-      end
-    end
-  end
-end
-
-require 'lolita/configuration/base'
-require 'lolita/configuration/core'
-require 'lolita/configuration/list'
-require 'lolita/configuration/nested_list'
-require 'lolita/configuration/tabs'
-require 'lolita/configuration/tab'
-require 'lolita/configuration/columns'
-require 'lolita/configuration/column'
-require 'lolita/configuration/fields'
-require 'lolita/configuration/field'
-require 'lolita/configuration/field_set'
-require 'lolita/configuration/nested_form'
-require 'lolita/configuration/search'
-require 'lolita/configuration/filter'
-require 'lolita/configuration/action'
-
-require 'lolita/configuration/factory/field'
-require 'lolita/configuration/factory/tab'
-
-# Configuration for fields and tabs
-["field","tab"].each do |type|
-  Dir["#{File.dirname(__FILE__)}/configuration/#{type}/**/*.*"].each do |path|
-    base_name=File.basename(path,".rb")
-    require "lolita/configuration/#{type}/#{base_name}"
-  end
+module Lolita
+   # All classes that want to use lolita for configuration should include this module.
+  module Configuration
+    # When Lolita::Configuration is included, it add hook for class <em>:after_lolita_loaded</em> and define class methods
+    # <em>lolita</em> and <em>lolita=</em> and instance method <em>lolita</em> that refers to class method with same name.
+    def self.included(base)
+      base.class_eval do
+        include Lolita::Hooks
+        add_hook :after_lolita_loaded
+
+        extend ClassMethods
+        def lolita
+          self.class.lolita
+        end
+      end
+    end
+
+    module ClassMethods
+      # This is main method for configuration, it initialize new Lolita::Configuration::Core object, that have other methost to 
+      # define different parts of configuration.
+      def lolita(&block)
+        Lolita::LazyLoader.lazy_load(self,:@lolita,Lolita::Configuration::Core,self,&block)
+      end
+      
+      def lolita=(value)
+        if value.is_a?(Lolita::Configuration::Core) || value.nil?
+          @lolita = value
+        else
+          raise ArgumentError.new("Only Lolita::Configuration::Core is acceptable.")
+        end
+      end
+    end
+  end
+end
+
+require 'lolita/configuration/base'
+require 'lolita/configuration/core'
+require 'lolita/configuration/list'
+require 'lolita/configuration/nested_list'
+require 'lolita/configuration/tabs'
+require 'lolita/configuration/tab'
+require 'lolita/configuration/columns'
+require 'lolita/configuration/column'
+require 'lolita/configuration/fields'
+require 'lolita/configuration/field'
+require 'lolita/configuration/field_set'
+require 'lolita/configuration/nested_form'
+require 'lolita/configuration/search'
+require 'lolita/configuration/filter'
+require 'lolita/configuration/action'
+
+require 'lolita/configuration/factory/field'
+require 'lolita/configuration/factory/tab'
+
+# Configuration for fields and tabs
+["field","tab"].each do |type|
+  Dir["#{File.dirname(__FILE__)}/configuration/#{type}/**/*.*"].each do |path|
+    base_name=File.basename(path,".rb")
+    require "lolita/configuration/#{type}/#{base_name}"
+  end
 end

data/lib/lolita/configuration/column.rb

@@ -1,181 +1,181 @@
-module Lolita
-  module Configuration
-    # column in a list
-    #
-    # === Examples
-    # lolita do
-    #   list do
-    #     column :title, sortable: true
-    #     column :full_name, sortable: 'first_name'
-    #     column :is_public do
-    #       formatter do |value, record, view|
-    #         value ? 'Yes' : 'No'
-    #       end
-    #     end
-    #
-    #     column do
-    #       title "ID"
-    #       name :id
-    #       formatter do|value, record, view|
-    #         view.link_to(value, view.url_for(action: 'edit', id: value))
-    #       end
-    #     end
-    #
-    #     column :updated_at, title: 'Date', formatter: '%d.%m.%Y., %H:%M'
-    #   end
-    # end
-    class Column < Lolita::Configuration::Base
-      MAX_TEXT_SIZE = 20
-      attr_reader :list_association_name
-      lolita_accessor :name, :title, :type, :options, :sortable, :association
-
-      def initialize(dbi, *args, &block)
-        set_and_validate_dbi(dbi)
-        set_attributes(*args)
-        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] || association
-          list_dbi = list_association && Lolita::DBI::Base.create(list_association.klass)
-          fail 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 association
-          if 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
-            "#{association.name} (#{record.send(association.name).count})"
-          end
-        else
-          record.send(name)
-        end
-      end
-
-      def formatted_value(record, view)
-        formatter.with(value(record), record, view)
-      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).find { |pair| pair[0] == sort_by_name } || []
-      end
-
-      # Return string with sort options for column if column is sortable.
-      def sort_params(params)
-        if @sortable
-          pairs = sort_pairs(params)
-          found_pair = false
-          pairs.each_with_index{|pair, index|
-            if pair[0] == sort_by_name
-              pairs[index][1] = pair[1] == 'asc' ? 'desc' : 'asc'
-              found_pair = true
-            end
-          }
-          unless found_pair
-            pairs << [sort_by_name, 'asc']
-          end
-          (pairs.map { |pair| pair.join(',') }).join('|')
-        else
-          ''
-        end
-      end
-
-      # returns value to sort by
-      # in default it will be column name, but you can specify it
-      # in field configuration
-      #
-      # === Examples
-      # list do
-      #   field :name, sortable: 'some_table.first_name'
-      # end
-      def sort_by_name
-        @sortable.is_a?(TrueClass) ? name.to_s : @sortable.to_s
-      end
-
-      # Create array of sort information from params.
-      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?
-          @formatter = Lolita::Support::Formatter.new(value, &block)
-        elsif value || !@formatter
-          if value.kind_of?(Lolita::Support::Formatter)
-            @formatter = value
-          else
-            @formatter = Lolita::Support::Formatter::Rails.new(value)
-          end
-        end
-        @formatter
-      end
-
-      def formatter=(value)
-        if value.kind_of?(Lolita::Support::Formatter)
-          @formatter = value
-        else
-          @formatter = Lolita::Support::Formatter::Rails.new(value)
-        end
-      end
-
-      def set_attributes(*args)
-        options = args ? args.extract_options! : {}
-        if args[0].respond_to?(:field)
-          [:name, :type].each do |attr|
-            send(:"#{attr}=", args[0].send(attr))
-          end
-        elsif args[0]
-          self.name = args[0]
-        end
-        options.each do |attr_name, value|
-          send(:"#{attr_name}=", value)
-        end
-      end
-
-      private
-
-      def detect_association
-        @association ||= dbi.associations[name]
-      end
-
-      def normalize_attributes
-        @name = @name.to_sym
-      end
-
-      def validate
-        fail Lolita::UnknownDBIError.new("DBI is not specified for column #{self}") unless dbi
-        fail ArgumentError.new('Column must have name.') unless name
-      end
-    end
-  end
-end
+module Lolita
+  module Configuration
+    # column in a list
+    #
+    # === Examples
+    # lolita do
+    #   list do
+    #     column :title, sortable: true
+    #     column :full_name, sortable: 'first_name'
+    #     column :is_public do
+    #       formatter do |value, record, view|
+    #         value ? 'Yes' : 'No'
+    #       end
+    #     end
+    #
+    #     column do
+    #       title "ID"
+    #       name :id
+    #       formatter do|value, record, view|
+    #         view.link_to(value, view.url_for(action: 'edit', id: value))
+    #       end
+    #     end
+    #
+    #     column :updated_at, title: 'Date', formatter: '%d.%m.%Y., %H:%M'
+    #   end
+    # end
+    class Column < Lolita::Configuration::Base
+      MAX_TEXT_SIZE = 20
+      attr_reader :list_association_name
+      lolita_accessor :name, :title, :type, :options, :sortable, :association
+
+      def initialize(dbi, *args, &block)
+        set_and_validate_dbi(dbi)
+        set_attributes(*args)
+        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] || association
+          list_dbi = list_association && Lolita::DBI::Base.create(list_association.klass)
+          fail 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 association
+          if 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
+            "#{association.name} (#{record.send(association.name).count})"
+          end
+        else
+          record.send(name)
+        end
+      end
+
+      def formatted_value(record, view)
+        formatter.with(value(record), record, view)
+      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).find { |pair| pair[0] == sort_by_name } || []
+      end
+
+      # Return string with sort options for column if column is sortable.
+      def sort_params(params)
+        if @sortable
+          pairs = sort_pairs(params)
+          found_pair = false
+          pairs.each_with_index{|pair, index|
+            if pair[0] == sort_by_name
+              pairs[index][1] = pair[1] == 'asc' ? 'desc' : 'asc'
+              found_pair = true
+            end
+          }
+          unless found_pair
+            pairs << [sort_by_name, 'asc']
+          end
+          (pairs.map { |pair| pair.join(',') }).join('|')
+        else
+          ''
+        end
+      end
+
+      # returns value to sort by
+      # in default it will be column name, but you can specify it
+      # in field configuration
+      #
+      # === Examples
+      # list do
+      #   field :name, sortable: 'some_table.first_name'
+      # end
+      def sort_by_name
+        @sortable.is_a?(TrueClass) ? name.to_s : @sortable.to_s
+      end
+
+      # Create array of sort information from params.
+      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?
+          @formatter = Lolita::Support::Formatter.new(value, &block)
+        elsif value || !@formatter
+          if value.kind_of?(Lolita::Support::Formatter)
+            @formatter = value
+          else
+            @formatter = Lolita::Support::Formatter::Rails.new(value)
+          end
+        end
+        @formatter
+      end
+
+      def formatter=(value)
+        if value.kind_of?(Lolita::Support::Formatter)
+          @formatter = value
+        else
+          @formatter = Lolita::Support::Formatter::Rails.new(value)
+        end
+      end
+
+      def set_attributes(*args)
+        options = args ? args.extract_options! : {}
+        if args[0].respond_to?(:field)
+          [:name, :type].each do |attr|
+            send(:"#{attr}=", args[0].send(attr))
+          end
+        elsif args[0]
+          self.name = args[0]
+        end
+        options.each do |attr_name, value|
+          send(:"#{attr_name}=", value)
+        end
+      end
+
+      private
+
+      def detect_association
+        @association ||= dbi.associations[name]
+      end
+
+      def normalize_attributes
+        @name = @name.to_sym
+      end
+
+      def validate
+        fail Lolita::UnknownDBIError.new("DBI is not specified for column #{self}") unless dbi
+        fail ArgumentError.new('Column must have name.') unless name
+      end
+    end
+  end
+end