lolita 3.3.5 → 3.3.6

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/rails.rb

@@ -1,57 +1,57 @@
-module Lolita
-  module Support
-    class Formatter
-
-      # Formater for work with rails, it localize Date and Time.
-      # Also
-      class Rails < Lolita::Support::Formatter
-
-
-        private
-
-        def use_format_for(value,*optional_values)
-          if @format && (value.is_a?(Time) || value.is_a?(Date))
-            localize_time_with_format(value,*optional_values)
-          else
-            use_default_format(value,*optional_values)
-          end
-        end
-
-        def localize_time_with_format(value,*optional_values)
-          if defined?(::I18n)
-            ::I18n.localize(value, :format => @format)
-          else
-            use_default_format(value,*optional_values)
-          end
-        end
-
-        def use_default_format(value,*optional_values)
-          if value
-            if value.is_a?(String)
-              @format ? (@format % value) : value
-            elsif value.is_a?(Numeric)
-              @format ? (@format % value) : value
-            elsif value.is_a?(Date)
-              if defined?(::I18n)
-                ::I18n.localize(value, :format => :long)
-              else
-                value.strftime("%Y/%m%/%d")
-              end
-            elsif value.is_a?(Time)
-              if defined?(::I18n)
-                ::I18n.localize(value, :format => :long)
-              else
-                value.strftime("%Y/%m/%d %H:%M:%S")
-              end
-            else
-              value.to_s
-            end
-          else
-            ""
-          end
-        end
-      end
-
-    end
-  end
+module Lolita
+  module Support
+    class Formatter
+
+      # Formater for work with rails, it localize Date and Time.
+      # Also
+      class Rails < Lolita::Support::Formatter
+
+
+        private
+
+        def use_format_for(value,*optional_values)
+          if @format && (value.is_a?(Time) || value.is_a?(Date))
+            localize_time_with_format(value,*optional_values)
+          else
+            use_default_format(value,*optional_values)
+          end
+        end
+
+        def localize_time_with_format(value,*optional_values)
+          if defined?(::I18n)
+            ::I18n.localize(value, :format => @format)
+          else
+            use_default_format(value,*optional_values)
+          end
+        end
+
+        def use_default_format(value,*optional_values)
+          if value
+            if value.is_a?(String)
+              @format ? (@format % value) : value
+            elsif value.is_a?(Numeric)
+              @format ? (@format % value) : value
+            elsif value.is_a?(Date)
+              if defined?(::I18n)
+                ::I18n.localize(value, :format => :long)
+              else
+                value.strftime("%Y/%m%/%d")
+              end
+            elsif value.is_a?(Time)
+              if defined?(::I18n)
+                ::I18n.localize(value, :format => :long)
+              else
+                value.strftime("%Y/%m/%d %H:%M:%S")
+              end
+            else
+              value.to_s
+            end
+          else
+            ""
+          end
+        end
+      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

data/lib/lolita/test/matchers.rb

@@ -1,77 +1,77 @@
-module Lolita
-  module Test
-    # Matchers that make easier to test Lolita and Lolita addons
-    module Matchers
-
-      class BeRoutable
-      
-        def matches?(actual)
-          @actual=actual
-          collect_routes
-          set_method_and_url
-          result=@routes.detect{|route| 
-            method_match(route) && @url.to_s.match(route[:path_info])
-          }
-          !!result
-        end
-
-        def failure_message
-          "expected #{@url.inspect}#{@method ? " with method #{@method.inspect}" : ""} to be routable"
-        end
-        def negative_failure_message
-          "expected #{@url.inspect}#{@method ? " with method #{@method.inspect}" : ""}  to not be routable"
-        end
-
-        private
-
-        def method_match(route)
-          if route[:request_method]
-            if @method
-              @method.to_s.upcase.match(route[:request_method])
-            else
-              false
-            end
-          else
-            true
-          end
-        end
-
-        def set_method_and_url
-          if @actual.is_a?(Hash)
-            @method,@url=@actual.keys.first,@actual.values.first
-          elsif @actual.is_a?(Array)
-            if @actual.size>=2
-              @method,@url=@actual[0],@actual[1]
-            elsif
-              @url=@actual.first
-            end
-          else
-            @url=@actual.to_s
-          end
-        end
-
-        def collect_routes
-          @routes=[]
-          all_applications.each do |application|
-            @routes+=application.routes.routes.map(&:conditions)
-          end
-        end
-
-        def all_applications
-          if defined?(Rails) && defined?(Rails::Application)
-            ObjectSpace.each_object(Rails::Application).select { |klass|
-             klass.class < Rails::Application 
-            }.map(&:class)
-          else
-            []
-          end
-        end
-      end
-
-       def be_routable
-        BeRoutable.new
-      end
-    end
-  end
-end
-
+module Lolita
+  module Test
+    # Matchers that make easier to test Lolita and Lolita addons
+    module Matchers
+
+      class BeRoutable
+      
+        def matches?(actual)
+          @actual=actual
+          collect_routes
+          set_method_and_url
+          result=@routes.detect{|route| 
+            method_match(route) && @url.to_s.match(route[:path_info])
+          }
+          !!result
+        end
+
+        def failure_message
+          "expected #{@url.inspect}#{@method ? " with method #{@method.inspect}" : ""} to be routable"
+        end
+        def negative_failure_message
+          "expected #{@url.inspect}#{@method ? " with method #{@method.inspect}" : ""}  to not be routable"
+        end
+
+        private
+
+        def method_match(route)
+          if route[:request_method]
+            if @method
+              @method.to_s.upcase.match(route[:request_method])
+            else
+              false
+            end
+          else
+            true
+          end
+        end
+
+        def set_method_and_url
+          if @actual.is_a?(Hash)
+            @method,@url=@actual.keys.first,@actual.values.first
+          elsif @actual.is_a?(Array)
+            if @actual.size>=2
+              @method,@url=@actual[0],@actual[1]
+            elsif
+              @url=@actual.first
+            end
+          else
+            @url=@actual.to_s
+          end
+        end
+
+        def collect_routes
+          @routes=[]
+          all_applications.each do |application|
+            @routes+=application.routes.routes.map(&:conditions)
+          end
+        end
+
+        def all_applications
+          if defined?(Rails) && defined?(Rails::Application)
+            ObjectSpace.each_object(Rails::Application).select { |klass|
+             klass.class < Rails::Application 
+            }.map(&:class)
+          else
+            []
+          end
+        end
+      end
+
+       def be_routable
+        BeRoutable.new
+      end
+    end
+  end
+end
+

data/lib/lolita/version.rb

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

data/lib/lolita.rb

@@ -130,11 +130,11 @@ module Lolita
   end
 
   def self.rails?
-    defined?(::Rails)
+    !!defined?(::Rails)
   end
 
   def self.rails3?
-    defined?(::Rails) && ::Rails::VERSION::MAJOR == 3
+    !!defined?(::Rails) && ::Rails::VERSION::MAJOR == 3
   end
 end