lolita 3.4.0 → 3.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4b73d7232b6d16a4d0b0b0c0c35a1928fe316390
-  data.tar.gz: 8f0f31e08f83abff1884b007b8559fa96c25108c
+  metadata.gz: 7f81d378fd85598e5de4c672cb470af30b6cb90f
+  data.tar.gz: 33b6055aaa7dbee4965baddd4c6a46e2c72fb192
 SHA512:
-  metadata.gz: 25028f189a32ad2a665b3f4cbfff3002e5517845d6c1e84a2d2d329cd0f18fd1e0a8ebec07d8118cb2471260fb263b632667b9065fd506cebe493d669d8baaf9
-  data.tar.gz: 502fd36b78421dcb183bf3c9a03ac535653f257773a3742065bf1b3197948648e0fc37fa9c3057f3fd974ef71fcca2431896ae0d38b5cde59e8d6fa07a3b6c6c
+  metadata.gz: 769ab380f0638ea6f64cf9a39bc1e11bcd1be74dc1762952cc6135e8fd1c1111aef963c17f033d3a475dd4a60bdebfb9d9442ab0ec7b8318d2379f7084e306c5
+  data.tar.gz: a7c55aa4efa03cc50f5c77bada37f27ac01dd6a21e4852f1aaf843e6a0b105dbdb6397f59a9bcebe2a3b6f72644f2cae93278bd120e073398dc26d1e2db771ed

data/lib/lolita/configuration/column.rb

@@ -1,28 +1,51 @@
 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
+      MAX_TEXT_SIZE = 20
       attr_reader :list_association_name
-      lolita_accessor :name,:title,:type,:options,:sortable, :association
-      
-      def initialize(dbi,*args,&block)
+      lolita_accessor :name, :title, :type, :options, :sortable, :association
+
+      def initialize(dbi, *args, &block)
         set_and_validate_dbi(dbi)
-        self.set_attributes(*args)
-        self.instance_eval(&block) if block_given?
+        set_attributes(*args)
+        instance_eval(&block) if block_given?
         validate
         normalize_attributes
         detect_association
       end
 
-      def list *args, &block
+      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_association = args[0] && @dbi.associations[args[0].to_s.to_sym] || 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
+          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)
+          Lolita::LazyLoader.lazy_load(self, :@list, Lolita::Configuration::NestedList, list_dbi, self, association_name: list_association.name, &block)
         else
           @list
         end
@@ -31,8 +54,8 @@ module Lolita
       # 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.association
-          if self.association.macro == :one &&  dbi.klass.respond_to?(:human_attribute_name)
+        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)
@@ -41,20 +64,20 @@ module Lolita
             "#{association.name} (#{record.send(association.name).count})"
           end
         else
-          record.send(self.name)
+          record.send(name)
         end
       end
 
-      def formatted_value(record,view)
-        self.formatter.with(self.value(record), record, view)
+      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)
+      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))
+        Lolita::Utils.dynamic_string(@title, default: @name && @dbi.klass.human_attribute_name(@name))
       end
 
       def sortable?
@@ -63,43 +86,55 @@ module Lolita
 
       # 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} || []
+        @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
+      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"
+          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 << [self.name.to_s,"asc"]
+            pairs << [sort_by_name, 'asc']
           end
-          (pairs.map{|pair| pair.join(",")}).join("|")
+          (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(",")}
+      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)
+      def formatter(value = nil, &block)
         if block_given?
-          @formatter=Lolita::Support::Formatter.new(value,&block) 
+          @formatter = Lolita::Support::Formatter.new(value, &block)
         elsif value || !@formatter
           if value.kind_of?(Lolita::Support::Formatter)
-            @formatter=value
+            @formatter = value
           else
-            @formatter=Lolita::Support::Formatter::Rails.new(value)
+            @formatter = Lolita::Support::Formatter::Rails.new(value)
           end
         end
         @formatter
@@ -107,30 +142,30 @@ module Lolita
 
       def formatter=(value)
         if value.kind_of?(Lolita::Support::Formatter)
-          @formatter=value
+          @formatter = value
         else
-          @formatter=Lolita::Support::Formatter::Rails.new(value)
+          @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|
-            self.send(:"#{attr}=",args[0].send(attr))
+          [: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|
-          self.send(:"#{attr_name}=",value)
+        options.each do |attr_name, value|
+          send(:"#{attr_name}=", value)
         end
       end
-      
+
       private
 
       def detect_association
-        @association ||= dbi.associations[self.name]
+        @association ||= dbi.associations[name]
       end
 
       def normalize_attributes
@@ -138,8 +173,8 @@ module Lolita
       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
+        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

data/lib/lolita/system_configuration/base.rb

@@ -64,6 +64,10 @@ module Lolita
         else
           Lolita.default_locale
         end
+        if defined?(::I18n)
+          ::I18n.locale = @locale
+        end
+        @locale
       end
       # Return default locale. First looks for defined default locale for Lolita, when not found than
       # take first of defined #locales for Lolita, if there no defined locales for Lolita, than

data/lib/lolita/version.rb

@@ -2,7 +2,7 @@ module Lolita
   module Version
     MAJOR = 3
     MINOR = 4
-    PATCH = 0
+    PATCH = 1
     BUILD = nil
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lolita
 version: !ruby/object:Gem::Version
-  version: 3.4.0
+  version: 3.4.1
 platform: ruby
 authors:
 - ITHouse (Latvia) and Arturs Meisters
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-24 00:00:00.000000000 Z
+date: 2014-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kaminari