lolita 3.3.7 → 3.3.8

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 = 7
+    PATCH = 8
     BUILD = nil
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')

data/spec/builder_spec.rb

@@ -1,121 +1,121 @@
-require File.expand_path(File.dirname(__FILE__) + '/simple_spec_helper')
-
-class SimpleObject 
-  include Lolita::Builder
-end
-
-describe Lolita::Builder::Custom do
-  let(:object){SimpleObject.new}
-  let(:builder){Lolita::Builder::Custom.new(object,{})}
-  let(:klass){Lolita::Builder::Custom}
-
-  it "should create new Custom builder" do
-    builder = Lolita::Builder::Custom.new(object,{})
-  end
-
-  it "should set name and state" do
-    builder = Lolita::Builder::Custom.new(object,{:name => "name", :state=>"state"})
-    builder.instance_variable_get(:"@name").should == "name"
-    builder.instance_variable_get(:"@state").should == "state"
-  end
-
-  it "should set default attributes" do
-    builder = Lolita::Builder::Custom.new(object,{:name => "name"})
-    builder.instance_variable_get(:"@state").should == :display
-  end
-
-  describe "build attributes" do
-    it "should set through #with" do
-      builder.with("name","state").build_attributes.should == {:name => "name", :state => "state"}
-      builder.with({:name=>"name",:state=>"state"}).build_attributes.should == {:name => "name", :state=>"state"}
-      builder.with("name",:state=>"state").build_attributes.should == {:name=>"name",:state=>"state"}
-    end
-  end
-
-  it "should return default state when no build attributes given" do
-    builder.state.should == :display
-  end
-
-  it "should return build attributes state when given" do
-    builder.with(:state=>"state").state.should == :"state"
-  end
-
-  it "should return default name when no build name given" do
-    builder.name.should == :"/simple_object"
-  end
-
-  it "should return build name when given" do
-    builder.with(:name => "name").name.should == :"/simple_object/name"
-    builder.with(:name => "/name").name.should == :"/name"
-  end
-
-  describe "#build" do
-    it "should return array with name,state and options" do
-      builder.build.should == [:"/simple_object",:"display",{}]
-      builder.with({:display_value => 1}).build.should == [:"/simple_object",:display,{:display_value=>1}]
-    end
-  end
-
-  describe "conditions" do
-    it "should use given over default when there's no conditions" do
-      builder = klass.new(object,:name => "/custom", :state => "special")
-      builder.build.should == [:"/custom",:"special",{}]
-    end
-
-    it "should use given over default when conditions met" do
-      builder = klass.new(object, :name => "/custom", :state=>"special", :unless=>{:state=>"display"})
-      builder.build.should == [:"/simple_object",:"display",{}]
-      builder.class_eval do
-        def default_state
-          :other
-        end
-      end
-      builder.build.should == [:"/custom",:special,{}]
-    end
-
-    it "should use given over build given when conditions met" do
-      builder = klass.new(object,:name => "/custom", :"state" => "special", :if=>{:state=>"default"})
-      builder.with(:state => "other").build.should == [:"/simple_object",:other,{}]
-      builder.with(:state => :default).build.should == [:"/custom",:special,{}]
-    end
-  end
-end
-
-describe Lolita::Builder do
-
-  let(:object){SimpleObject.new}
-
-  describe "#build" do
-
-    describe "default path" do
-
-      it "should be /:class_name/display" do
-        info=object.build
-        info.first.should == :"/simple_object"
-        info[1].should == :display
-      end
-
-      it "should use given name when it starts with /" do
-        object.builder = {:name =>"/custom"}
-        info = object.build
-        info.first.should == :"/custom"
-        info[1].should == :display
-      end
-
-      it "should make name /:class_name/:custom_name when it doesn't start with /" do
-        object.builder = {:name => "custom"}
-        info = object.build
-        info.first.should == :"/simple_object/custom"
-        info[1].should == :display
-      end
-    
-    end
-
-    it "should use received name" do
-      object.builder = {:name=>"/custom"}
-      info = object.build("/other_custom")
-      info.first.should == :"/other_custom"
-    end
-
-  end
+require File.expand_path(File.dirname(__FILE__) + '/simple_spec_helper')
+
+class SimpleObject 
+  include Lolita::Builder
+end
+
+describe Lolita::Builder::Custom do
+  let(:object){SimpleObject.new}
+  let(:builder){Lolita::Builder::Custom.new(object,{})}
+  let(:klass){Lolita::Builder::Custom}
+
+  it "should create new Custom builder" do
+    builder = Lolita::Builder::Custom.new(object,{})
+  end
+
+  it "should set name and state" do
+    builder = Lolita::Builder::Custom.new(object,{:name => "name", :state=>"state"})
+    builder.instance_variable_get(:"@name").should == "name"
+    builder.instance_variable_get(:"@state").should == "state"
+  end
+
+  it "should set default attributes" do
+    builder = Lolita::Builder::Custom.new(object,{:name => "name"})
+    builder.instance_variable_get(:"@state").should == :display
+  end
+
+  describe "build attributes" do
+    it "should set through #with" do
+      builder.with("name","state").build_attributes.should == {:name => "name", :state => "state"}
+      builder.with({:name=>"name",:state=>"state"}).build_attributes.should == {:name => "name", :state=>"state"}
+      builder.with("name",:state=>"state").build_attributes.should == {:name=>"name",:state=>"state"}
+    end
+  end
+
+  it "should return default state when no build attributes given" do
+    builder.state.should == :display
+  end
+
+  it "should return build attributes state when given" do
+    builder.with(:state=>"state").state.should == :"state"
+  end
+
+  it "should return default name when no build name given" do
+    builder.name.should == :"/simple_object"
+  end
+
+  it "should return build name when given" do
+    builder.with(:name => "name").name.should == :"/simple_object/name"
+    builder.with(:name => "/name").name.should == :"/name"
+  end
+
+  describe "#build" do
+    it "should return array with name,state and options" do
+      builder.build.should == [:"/simple_object",:"display",{}]
+      builder.with({:display_value => 1}).build.should == [:"/simple_object",:display,{:display_value=>1}]
+    end
+  end
+
+  describe "conditions" do
+    it "should use given over default when there's no conditions" do
+      builder = klass.new(object,:name => "/custom", :state => "special")
+      builder.build.should == [:"/custom",:"special",{}]
+    end
+
+    it "should use given over default when conditions met" do
+      builder = klass.new(object, :name => "/custom", :state=>"special", :unless=>{:state=>"display"})
+      builder.build.should == [:"/simple_object",:"display",{}]
+      builder.class_eval do
+        def default_state
+          :other
+        end
+      end
+      builder.build.should == [:"/custom",:special,{}]
+    end
+
+    it "should use given over build given when conditions met" do
+      builder = klass.new(object,:name => "/custom", :"state" => "special", :if=>{:state=>"default"})
+      builder.with(:state => "other").build.should == [:"/simple_object",:other,{}]
+      builder.with(:state => :default).build.should == [:"/custom",:special,{}]
+    end
+  end
+end
+
+describe Lolita::Builder do
+
+  let(:object){SimpleObject.new}
+
+  describe "#build" do
+
+    describe "default path" do
+
+      it "should be /:class_name/display" do
+        info=object.build
+        info.first.should == :"/simple_object"
+        info[1].should == :display
+      end
+
+      it "should use given name when it starts with /" do
+        object.builder = {:name =>"/custom"}
+        info = object.build
+        info.first.should == :"/custom"
+        info[1].should == :display
+      end
+
+      it "should make name /:class_name/:custom_name when it doesn't start with /" do
+        object.builder = {:name => "custom"}
+        info = object.build
+        info.first.should == :"/simple_object/custom"
+        info[1].should == :display
+      end
+    
+    end
+
+    it "should use received name" do
+      object.builder = {:name=>"/custom"}
+      info = object.build("/other_custom")
+      info.first.should == :"/other_custom"
+    end
+
+  end
 end

data/spec/rails_app/app/controllers/application_controller.rb

@@ -1,3 +1,3 @@
-class ApplicationController < ActionController::Base
-  protect_from_forgery
-end
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+end

data/spec/rails_app/app/helpers/application_helper.rb

@@ -1,3 +1,3 @@
-# Methods added to this helper will be available to all templates in the application.
-module ApplicationHelper
-end
+# Methods added to this helper will be available to all templates in the application.
+module ApplicationHelper
+end

data/spec/rails_app/app/views/components/lolita/configuration/list/_body_cell.html.erb

@@ -1 +1 @@
-<td>overwritten cell</td>
+<td>overwritten cell</td>