lolita 4.0.2 → 4.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9ecde238f39add82144a021f79e9fe92c67f85b7
-  data.tar.gz: 7cfc0a8722cd3707f8870979a3e3bbefb20ca478
+  metadata.gz: 9fc5f5493358ac19cab98481772713454a697efa
+  data.tar.gz: 4ce3c24b5ee5141170446006d1e8eea17c940733
 SHA512:
-  metadata.gz: 74a47007e7e24320173ae6ddc85275fe569cc49d3a7cb5241be0a91f9bb1ea5dc227acc83a6e0461f74a95dc5d3f29d550fc028459c3e3c65df770c4508c5028
-  data.tar.gz: 4deae66dae75aa62e668f2ce1b4d8438a8c533fbab0a8a77013a4a2498da1a1feb49d4afa2990ccccc506fd1094d0ce5c6b4c6446e9231bf15e0a8c3b9a1a431
+  metadata.gz: 39029642a07f3ef333f82e940046f184a6fe28d6bff0233cea828a08d7d4da9a9d1d2f5a838e841313a656176a8f790aed0393a734aa66b9b2428a5c2798965f
+  data.tar.gz: a2aeecba8f7e0fe7d2d183ffcefdd9dd061016e9b3b2b5f6437d8b3b536bb4a0eab18fa8277a070b003f1dc8fc2c637433bd70f9ef22ccbb65ac140171f3b98e

data/app/assets/stylesheets/lolita/default.css.erb

@@ -48,6 +48,7 @@ pre, code, kbd, samp { font-family: monospace, sans-serif; }
 
 
 a:hover, a:active { outline: none; }
+a.pointer { cursor: pointer; }
 
 ul, ol { margin-left: 2em; }
 ol { list-style-type: decimal; }

data/app/helpers/components/lolita/configuration_component.rb

@@ -2,20 +2,19 @@ module Components
   module Lolita
     module ConfigurationComponent
       def link_to_remove_fields(name, f)
-        f.hidden_field(:_destroy) + link_to(name, "#", onclick: "remove_fields(this)")
+        f.hidden_field(:_destroy) + link_to(name, '#', onclick: 'remove_fields(this); return false;')
       end
 
       def link_to_add_fields(name, f, nested_form)
         new_object = nested_form.klass.new
-        fields_content = ""
+        fields_content = ''
         f.fields_for(nested_form.name, new_object, child_index: "new_#{nested_form.name}") do |builder|
-          self.current_form(builder) do
+          current_form(builder) do
             fields_content = render_component(nested_form, :"fields")
           end
         end
-        link_to(name, "#", onclick: "add_fields(this, \"#{nested_form.name}\", \"#{escape_javascript(fields_content)}\")")
+        link_to(name, '', class: 'pointer', onclick: "add_fields(this, \"#{nested_form.name}\", \"#{escape_javascript(fields_content)}\"); return false;")
       end
-
     end
   end
 end

data/app/views/components/lolita/configuration/column/_first.html.haml

@@ -1,2 +1,2 @@
-%td{:class => "first-column cell"}
+%td{:class => "first-column cell"}
   = check_box_tag "#{resource_name}[id]", record.id

data/app/views/components/lolita/configuration/column/header/_sort.html.haml

@@ -1,6 +1,6 @@
-- sort_mapping = {"desc" => '⇓', "asc" => '⇑'}
-- new_params = params.reject{|k,v| ["controller","action"].include?(k.to_s)}
-- direction_indicator = raw(sort_mapping[column.current_sort_state(new_params)[1]])
-- new_params[:s] = column.sort_params(new_params)
-
-= link_to raw("#{column.title.to_s.capitalize} #{direction_indicator}"), lolita_resources_path(new_params)
+- sort_mapping = {"desc" => '⇓', "asc" => '⇑'}
+- new_params = params.reject{|k,v| ["controller","action"].include?(k.to_s)}
+- direction_indicator = raw(sort_mapping[column.current_sort_state(new_params)[1]])
+- new_params[:s] = column.sort_params(new_params)
+
+= link_to raw("#{column.title.to_s.capitalize} #{direction_indicator}"), lolita_resources_path(new_params)

data/app/views/components/lolita/configuration/nested_form/_display.html.haml

@@ -9,4 +9,4 @@
     - self.current_form = old_form
   - if nested_form.expandable? && !nested_form.update_only?
     %p
-      =link_to_add_fields ::I18n.t("lolita.nested_form.add", :resource_name => nested_form.klass.lolita_model_name.human.downcase), current_form, nested_form 
+      =link_to_add_fields ::I18n.t("lolita.nested_form.add", :resource_name => nested_form.klass.lolita_model_name.human.underscore), current_form, nested_form 

data/lib/lolita/configuration/column.rb

@@ -25,12 +25,11 @@ module Lolita
     #   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)
         set_attributes(*args)
         instance_eval(&block) if block_given?
@@ -39,14 +38,14 @@ module Lolita
         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)
           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
@@ -55,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)
@@ -65,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?
@@ -87,40 +86,52 @@ 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 do|pair, index|
+            if pair[0] == sort_by_name
+              pairs[index][1] = pair[1] == 'asc' ? 'desc' : 'asc'
               found_pair = true
             end
-          }
+          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)
+          if value.is_a?(Lolita::Support::Formatter)
             @formatter = value
           else
             @formatter = Lolita::Support::Formatter::Rails.new(value)
@@ -130,7 +141,7 @@ module Lolita
       end
 
       def formatter=(value)
-        if value.kind_of?(Lolita::Support::Formatter)
+        if value.is_a?(Lolita::Support::Formatter)
           @formatter = value
         else
           @formatter = Lolita::Support::Formatter::Rails.new(value)
@@ -140,21 +151,21 @@ module Lolita
       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))
+          [: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)
+        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
@@ -162,8 +173,8 @@ module Lolita
       end
 
       def validate
-        fail Lolita::UnknownDBIError.new("DBI is not specified for column #{self}") unless self.dbi
-        fail 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/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lolita
 version: !ruby/object:Gem::Version
-  version: 4.0.2
+  version: 4.0.3
 platform: ruby
 authors:
 - ITHouse (Latvia) and Arturs Meisters