lolita 3.2.0.rc.17 → 3.2.1

data/lib/lolita/rails/engine.rb

@@ -8,7 +8,7 @@ ActiveSupport.on_load(:action_controller) {
 ActiveSupport.on_load(:action_view) {
   include Lolita::Controllers::UrlHelpers
   include Lolita::Controllers::ComponentHelpers
-  include Lolita::Controllers::RailsHelpers 
+  include Lolita::Controllers::RailsHelpers
   include Lolita::Extensions
 }
 
@@ -19,6 +19,6 @@ module Lolita
     config.before_initialize do
       Haml.init_rails(binding)
       Haml::Template.options[:format] = :html5
-    end   
+    end
   end
 end

data/lib/lolita/rails/routes.rb

@@ -1,5 +1,5 @@
 module ActionDispatch::Routing
-  
+
   class RouteSet
 
     # Each time when #draw method is called this is called as well.
@@ -34,7 +34,7 @@ module ActionDispatch::Routing
     #     lolita_for :galleries
     #     # lolita_for try to call :lolita_gallery in Mapper class
     def lolita_for *resources
-  
+
       return if migrating? || generating?
       options = resources.extract_options!
 
@@ -47,7 +47,7 @@ module ActionDispatch::Routing
         mapping = Lolita.add_mapping(resource,options)
         Lolita.resources[mapping.name] = mapping
         target_class = mapping.to
-        
+
   #TODO refactor all these variables
         all_resource_classes<<target_class
 
@@ -55,9 +55,9 @@ module ActionDispatch::Routing
           yield if block_given?
 
           with_lolita_exclusive_scope mapping.fullpath,mapping.path do
-            
+
             # if not defined lolita default configuration in model, than can't use :rest
-            
+
             # if !target_class.respond_to?(:lolita) && !Lolita::routes[mapping.name]
             #    raise Lolita::NotFound, "Lolita not found in #{target_class}. Include Lolita::Configuration"
             # elsif target_class.respond_to?(:lolita) && target_class.instance_variable_get(:@lolita).nil?
@@ -72,14 +72,14 @@ module ActionDispatch::Routing
               raise Lolita::ModuleNotFound, "Module #{mapping.name.to_s.capitalize} not found!"
             end
             send(:"lolita_#{route}_route",mapping,mapping.controllers)
-            
+
             Lolita.conditional_routes(target_class).each do |route_name|
               send(:"lolita_#{route_name}_route",mapping,mapping.controllers)
             end
           end
 
         end
-       
+
         mapping.add_to_navigation_tree
       }
       Lolita.common_routes(all_resource_classes).each do |route_name|
@@ -88,7 +88,7 @@ module ActionDispatch::Routing
     end
 
     protected
-    
+
     def lolita_scope scope
       constraint = lambda do |request|
         request.env["lolita.mapping"] = Lolita.mappings[scope]
@@ -99,7 +99,7 @@ module ActionDispatch::Routing
         yield
       end
     end
-    
+
     def with_lolita_exclusive_scope new_path,new_as
       old_as, old_path, old_module = @scope[:as], @scope[:path], @scope[:module]
       @scope[:as], @scope[:path], @scope[:module] = new_as, new_path, nil

data/lib/lolita/ruby_ext/accessors.rb

@@ -1,27 +1,27 @@
-class Object
-  # Works similar as <code>attr_accessor</code> only reader method is changed
-  # to allow to set value (used for Lolita blocks in different classes).
-  # ====Example
-  #     class Klass
-  #       lolita_accessor :my_method
-  #     end
-  #     k=Klass.new
-  #     k.my_method("it's me")
-  #     puts k.my_method #=> it's me
-  def lolita_accessor *methods
-    if [Class,Module].include?(self.class)
-      methods.each do |method|
-        class_eval <<-ACCESSORS,__FILE__,__LINE__+1
-        def #{method}(value=nil)
-          @#{method}=value if value
-          @#{method}
-        end
-
-        def #{method}=(value)
-          @#{method}=value
-        end
-        ACCESSORS
-      end
-    end
-  end
+class Object
+  # Works similar as <code>attr_accessor</code> only reader method is changed
+  # to allow to set value (used for Lolita blocks in different classes).
+  # ====Example
+  #     class Klass
+  #       lolita_accessor :my_method
+  #     end
+  #     k=Klass.new
+  #     k.my_method("it's me")
+  #     puts k.my_method #=> it's me
+  def lolita_accessor *methods
+    if [Class,Module].include?(self.class)
+      methods.each do |method|
+        class_eval <<-ACCESSORS,__FILE__,__LINE__+1
+        def #{method}(value=nil)
+          @#{method}=value if value
+          @#{method}
+        end
+
+        def #{method}=(value)
+          @#{method}=value
+        end
+        ACCESSORS
+      end
+    end
+  end
 end

data/lib/lolita/ruby_ext/lolita_model_name.rb

@@ -11,11 +11,19 @@ module Lolita
       else
         "lolita.models.#{@class_name.underscore.gsub("/",".")}"
       end
-      ::I18n.t("#{name}.#{prefix(options)}")
+      ::I18n.t("#{name}.#{prefix(options)}", default: default_human_name(options))
     end
 
     private
 
+    def default_human_name options = {}
+      if prefix(options) == 'one'
+        @class_name.humanize
+      else
+        ActiveModel::Naming.plural(@klass).humanize
+      end
+    end
+
     def prefix options
       if options[:count]
         if options[:count] == 1
@@ -30,7 +38,7 @@ module Lolita
   end
 end
 
-Object.class_eval do 
+Object.class_eval do
   def lolita_model_name
     @lolita_model_name ||= Lolita::ModelName.new(self)
   end

data/lib/lolita/search/simple.rb

@@ -1,75 +1,75 @@
-module Lolita
-  module Search
-
-    # Default search class for Lolita::Search. Lolita::Configuration::Search uses this by default.
-    # It accepts method name as constructor argument, when none is given it call Lolita::DBI#search.
-    class Simple
-
-      # Method in model used to run a search.
-      attr_accessor :search_method
-      attr_reader :dbi
-
-      # Accepts search method as optional argument
-      def initialize(dbi, *args)
-        @dbi = dbi
-        @options = args.extract_options!
-        @search_method = args[0]
-      end
-
-      # Require dbi (Lolita::DBI instance), query (String) and request and dbi as optional argument.
-      # Also you can pass options.
-      # ====Example
-      #     search.run("query",:fields => [:name])
-      #     # this will search only in :name field
-      #     search.run("query",nil, Lolita::DBI::Base.create(Category))
-      #     # this will use Category dbi for search
-      # When there is search method defined, it uses that otherwise run default search.
-      def run(query,*args)
-        with_query(query,*args) do
-          if self.search_method
-            run_custom_search
-          else
-            run_default_search
-          end
-        end
-      end
-
-      private
-
-      def with_query(query,*args)
-        begin
-          options = args.extract_options!
-          @old_dbi = self.dbi
-          @old_options = @options 
-          @options = options if options.any?
-          @dbi = args[1] if args[1]
-          @query = query
-          @request = args[0]
-          yield
-        ensure
-          @dbi = @old_dbi
-          @options = @old_options
-          @query,@request = nil,nil
-        end
-      end
-
-      def run_custom_search
-        search_method_arity = @dbi.klass.method(self.search_method).arity
-        args = [@query,@request,@options]
-        if search_method_arity < 0
-          @dbi.klass.send(self.search_method.to_sym,@query,@request,@options)
-        elsif search_method_arity == 0
-          raise ArgumentError, "#{@dbi.klass.to_s} method #{search_method} must accept at least 1 argument."
-        else
-          arity_limit = search_method_arity > args.size ? args.size : search_method_arity
-          @dbi.klass.send(self.search_method.to_sym,*(args.slice(0..(arity_limit-1))))
-        end
-      end
-
-      def run_default_search
-        @dbi.search(@query,@options || {})
-      end
-    end
-
-  end
-end
+module Lolita
+  module Search
+
+    # Default search class for Lolita::Search. Lolita::Configuration::Search uses this by default.
+    # It accepts method name as constructor argument, when none is given it call Lolita::DBI#search.
+    class Simple
+
+      # Method in model used to run a search.
+      attr_accessor :search_method
+      attr_reader :dbi
+
+      # Accepts search method as optional argument
+      def initialize(dbi, *args)
+        @dbi = dbi
+        @options = args.extract_options!
+        @search_method = args[0]
+      end
+
+      # Require dbi (Lolita::DBI instance), query (String) and request and dbi as optional argument.
+      # Also you can pass options.
+      # ====Example
+      #     search.run("query",:fields => [:name])
+      #     # this will search only in :name field
+      #     search.run("query",nil, Lolita::DBI::Base.create(Category))
+      #     # this will use Category dbi for search
+      # When there is search method defined, it uses that otherwise run default search.
+      def run(query,*args)
+        with_query(query,*args) do
+          if self.search_method
+            run_custom_search
+          else
+            run_default_search
+          end
+        end
+      end
+
+      private
+
+      def with_query(query,*args)
+        begin
+          options = args.extract_options!
+          @old_dbi = self.dbi
+          @old_options = @options 
+          @options = options if options.any?
+          @dbi = args[1] if args[1]
+          @query = query
+          @request = args[0]
+          yield
+        ensure
+          @dbi = @old_dbi
+          @options = @old_options
+          @query,@request = nil,nil
+        end
+      end
+
+      def run_custom_search
+        search_method_arity = @dbi.klass.method(self.search_method).arity
+        args = [@query,@request,@options]
+        if search_method_arity < 0
+          @dbi.klass.send(self.search_method.to_sym,@query,@request,@options)
+        elsif search_method_arity == 0
+          raise ArgumentError, "#{@dbi.klass.to_s} method #{search_method} must accept at least 1 argument."
+        else
+          arity_limit = search_method_arity > args.size ? args.size : search_method_arity
+          @dbi.klass.send(self.search_method.to_sym,*(args.slice(0..(arity_limit-1))))
+        end
+      end
+
+      def run_default_search
+        @dbi.search(@query,@options || {})
+      end
+    end
+
+  end
+end

data/lib/lolita/support/formatter.rb

@@ -1,63 +1,63 @@
-module Lolita
-  module Support
-    # Containes different kind of formaters.
-    # Change output format of different input types.
-    # To define, pass block, or String.
-    # ====Exmaple
-    #     Lolita::Support::Formatter.new do |value|
-    #       value.to_i**2
-    #     end
-    #     # or as String
-    #     Lolita::Support::Formatter.new("%U")
-    # To format any value with defined formater call #with
-    # ====Example
-    #     # Previous examples may be called like this
-    #     formatter.with(1)
-    #     formatter.with(Date.today)
-    class Formatter
-
-      def initialize(format=nil,&block)
-        @format=format
-        @block=block if block_given?
-      end
-
-      def format
-        @format
-      end
-
-      def block
-        @block
-      end
-
-      def with(value,*optional_values)
-        if @block
-          @block.call(value,*optional_values)
-        elsif @format
-          use_format_for(value,*optional_values)
-        else
-          use_default_format(value,*optional_values)
-        end
-      end
-
-      private
-
-      def use_default_format(value,*optional_values)
-        value
-      end
-
-      def use_format_for(value, *optional_values)
-        if value.respond_to?(:format)
-          call_block(value,*optional_values)
-        else
-          @format ? (@format % value) : value
-        end
-      end
-
-      def call_block(value,*optional_values)
-        value.send(:format,value,*optional_values)
-      end
-
-    end
-    
-  end
+module Lolita
+  module Support
+    # Containes different kind of formaters.
+    # Change output format of different input types.
+    # To define, pass block, or String.
+    # ====Exmaple
+    #     Lolita::Support::Formatter.new do |value|
+    #       value.to_i**2
+    #     end
+    #     # or as String
+    #     Lolita::Support::Formatter.new("%U")
+    # To format any value with defined formater call #with
+    # ====Example
+    #     # Previous examples may be called like this
+    #     formatter.with(1)
+    #     formatter.with(Date.today)
+    class Formatter
+
+      def initialize(format=nil,&block)
+        @format=format
+        @block=block if block_given?
+      end
+
+      def format
+        @format
+      end
+
+      def block
+        @block
+      end
+
+      def with(value,*optional_values)
+        if @block
+          @block.call(value,*optional_values)
+        elsif @format
+          use_format_for(value,*optional_values)
+        else
+          use_default_format(value,*optional_values)
+        end
+      end
+
+      private
+
+      def use_default_format(value,*optional_values)
+        value
+      end
+
+      def use_format_for(value, *optional_values)
+        if value.respond_to?(:format)
+          call_block(value,*optional_values)
+        else
+          @format ? (@format % value) : value
+        end
+      end
+
+      def call_block(value,*optional_values)
+        value.send(:format,value,*optional_values)
+      end
+
+    end
+    
+  end
 end