lolita 3.4.2 → 3.4.3

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/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

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/system_configuration/base.rb

@@ -1,178 +1,178 @@
-module Lolita
-  module SystemConfiguration
-    class Base
-      attr_reader :scope, :modules, :routes, :controllers,:resources
-      attr_accessor :mappings,:default_route,:user_classes,:authentication,:authorization
-      attr_writer :default_locale, :ability_class, :policy_class
-
-      def initialize(scope)
-        @scope=scope
-        @mappings={}
-        @resources={}
-        @default_module=nil
-        @user_classes=[]
-        @modules=[]
-        @routes={}
-        @controllers={}
-      end
-
-      def application &block
-        @application ||= Lolita::SystemConfiguration::Application.new
-        if block_given?
-          yield @application
-        end
-        @application
-      end
-
-      def navigation
-        unless Lolita::Navigation::Tree[:"left_side_navigation"]
-          tree = Lolita::Navigation::Tree.new(:"left_side_navigation")
-          Lolita::Navigation::Tree.remember(tree)
-        end
-        Lolita::Navigation::Tree[:"left_side_navigation"]
-      end
-
-      # ability class for CanCan
-      def ability_class
-        @ability_class || (::Ability rescue nil) || raise("No ability class found.")
-      end
-
-      # policy class for Pundit
-      def policy_class
-        @policy_class || (::LolitaPolicy rescue nil) || raise("No policy class found.")
-      end
-
-      def locales=(value)
-        unless value.is_a?(Array)
-          @locales=[value]
-        else
-          @locales=value
-        end
-      end
-
-      def locales
-        @locales || []
-      end
-
-      def locale()
-        @locale || default_locale
-      end
-
-      def locale=given_locale
-        @locale=if locales.include?(given_locale.to_s.to_sym)
-          given_locale.to_s.to_sym
-        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
-      # look for I18n and take default locale from there or if there is no I18n than take :en
-      def default_locale
-        @default_locale || self.locales.first || (defined?(::I18n) ? ::I18n.default_locale : :en)
-      end
-      # Call (with #call) to route klass
-      # And return all names of routes that are needed for resource.
-      # When with #add_module routes are defined like 
-      #     Lolita.add_module MyModule, :route=>:my_module
-      # then this will be passed to the method that creates routes, but 
-      # when Proc is passed to <i>:route</i> then this Proc should return
-      # name of route or nil.
-      # These names then are used for methods like <em>lolita_[route_name]_route</em>
-      # that should be required somewhere in you module.
-      def conditional_routes(klass=nil)
-        @routes.map{|name,route|
-          if route.first
-            if route.last.respond_to?(:call)
-              route.last.call(klass)
-            else
-              route.last
-            end
-          end
-        }.compact
-      end
-
-      # Find all routes that is needed for defined classes
-      # And return only one for each different route.
-      def common_routes(klasses)
-        @routes.map{|name,route|
-          unless route.first
-            klasses.map{|klass| route.last.respond_to?(:call) ? route.last.call(klass) : route.last}
-          end
-        }.flatten.compact.uniq
-      end
-
-      # Include module in Lolita, don't know why i need this
-      def use(module_name)
-        Lolita.send(:include,module_name)
-      end
-
-      def add_mapping(resource,options={})
-        mapping = Lolita::Mapping.new(resource, options)
-        self.mappings[mapping.name] = mapping
-        mapping
-      end
-
-      # Add new module to Lolita
-      # Accpted options
-      # * <tt>controller</tt> - not in use
-      # * <tt>nested</tt> - is route stands itsefl or is used in combination with resource
-      # * <tt>route</tt> - Symbol of route name or lambad, that return route name based on resource.
-      # Route name is used to call method lolita_[route_name] in Mapper class, and that should draw route.
-      # * <tt>:name</tt> - name of module, underscored symbol. Used to draw default route, by default always
-      # lolita_rest is called, but if route with resource name is found, than by default this route will be drawn.
-      # Like lolita_for :posts, can go to different controller than rest and do other things.
-      # * <tt>:path</tt> - some file that will be included. Deprecated will be removed
-      # ====Example
-      #     Lolita.add_module Lolita::Posts, :route=>:post, :name=>:post
-      #     lolita_for :posts #=> create url whatever is defined in lolita_post method, and goes to :controller=>"lolita/posts"
-      #     Lolita.add_module Lolita::FileUpload, :route=>lambda{|resource| resource.lolita.tabs.by_type(:file) ? :file_upload : nil}
-      #     lolita_for :users #=> creat default rest urls and also call method lolita_file_upload if user lolita define :file tab.
-      # To add route for public interface that goes to added module, than use 
-      #    Lolita.add_module Post, :name=>:posts
-      # And then when in routes.rb will be defined lolita_for(:posts) it will call method <i>lolita_posts_route</i>
-      # and that method should define resource. 
-      # ====Example
-      #     # require this in your gem or lib
-      #     module ActionDispatch::Routing
-      #        class Mapper
-      #          protected
-      #          def lolita_posts_route mapping, controllers
-      #            resources mapping.plural,:only=>[:index,:new,:create],
-      #              :controller=>controllers[:posts],:module=>mapping.module
-      #          end
-      #        end
-      #      end
-      # You open Mapper class and add your method that call #resources or #match or other method that define route
-      # For common route for all lolita resources your method should look like this
-      # ====Example
-      #     def lolita_files_route 
-      #        mapping=Lolita.add_mapping(:files,:class_name=>"Lolita::Multimedia::File",:module=>"file_upload")
-      #        scope :module=>mapping.module do
-      #            resources mapping.name
-      #        end
-      #     end
-      def add_module module_container, options={}
-        raise ArgumentError, "Can't add module without module container!" unless module_container
-        options.assert_valid_keys(:controller,:route,:model,:path,:name,:nested)
-        name=options[:name]||module_container.to_s.to_sym
-        self.modules<<module_container
-
-        if options.has_key?(:route)
-          self.routes[name]=[options.has_key?(:nested) ? options[:nested] : true,options[:route]]
-        end
-        self.controllers[name]=options[:controller] if options.has_key?(:controller)
-
-        if options[:path]
-          require File.join(options[:path],name.to_s)
-        end
-    
-      end
-      
-    end
-  end
-end
+module Lolita
+  module SystemConfiguration
+    class Base
+      attr_reader :scope, :modules, :routes, :controllers,:resources
+      attr_accessor :mappings,:default_route,:user_classes,:authentication,:authorization
+      attr_writer :default_locale, :ability_class, :policy_class
+
+      def initialize(scope)
+        @scope=scope
+        @mappings={}
+        @resources={}
+        @default_module=nil
+        @user_classes=[]
+        @modules=[]
+        @routes={}
+        @controllers={}
+      end
+
+      def application &block
+        @application ||= Lolita::SystemConfiguration::Application.new
+        if block_given?
+          yield @application
+        end
+        @application
+      end
+
+      def navigation
+        unless Lolita::Navigation::Tree[:"left_side_navigation"]
+          tree = Lolita::Navigation::Tree.new(:"left_side_navigation")
+          Lolita::Navigation::Tree.remember(tree)
+        end
+        Lolita::Navigation::Tree[:"left_side_navigation"]
+      end
+
+      # ability class for CanCan
+      def ability_class
+        @ability_class || (::Ability rescue nil) || raise("No ability class found.")
+      end
+
+      # policy class for Pundit
+      def policy_class
+        @policy_class || (::LolitaPolicy rescue nil) || raise("No policy class found.")
+      end
+
+      def locales=(value)
+        unless value.is_a?(Array)
+          @locales=[value]
+        else
+          @locales=value
+        end
+      end
+
+      def locales
+        @locales || []
+      end
+
+      def locale()
+        @locale || default_locale
+      end
+
+      def locale=given_locale
+        @locale=if locales.include?(given_locale.to_s.to_sym)
+          given_locale.to_s.to_sym
+        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
+      # look for I18n and take default locale from there or if there is no I18n than take :en
+      def default_locale
+        @default_locale || self.locales.first || (defined?(::I18n) ? ::I18n.default_locale : :en)
+      end
+      # Call (with #call) to route klass
+      # And return all names of routes that are needed for resource.
+      # When with #add_module routes are defined like 
+      #     Lolita.add_module MyModule, :route=>:my_module
+      # then this will be passed to the method that creates routes, but 
+      # when Proc is passed to <i>:route</i> then this Proc should return
+      # name of route or nil.
+      # These names then are used for methods like <em>lolita_[route_name]_route</em>
+      # that should be required somewhere in you module.
+      def conditional_routes(klass=nil)
+        @routes.map{|name,route|
+          if route.first
+            if route.last.respond_to?(:call)
+              route.last.call(klass)
+            else
+              route.last
+            end
+          end
+        }.compact
+      end
+
+      # Find all routes that is needed for defined classes
+      # And return only one for each different route.
+      def common_routes(klasses)
+        @routes.map{|name,route|
+          unless route.first
+            klasses.map{|klass| route.last.respond_to?(:call) ? route.last.call(klass) : route.last}
+          end
+        }.flatten.compact.uniq
+      end
+
+      # Include module in Lolita, don't know why i need this
+      def use(module_name)
+        Lolita.send(:include,module_name)
+      end
+
+      def add_mapping(resource,options={})
+        mapping = Lolita::Mapping.new(resource, options)
+        self.mappings[mapping.name] = mapping
+        mapping
+      end
+
+      # Add new module to Lolita
+      # Accpted options
+      # * <tt>controller</tt> - not in use
+      # * <tt>nested</tt> - is route stands itsefl or is used in combination with resource
+      # * <tt>route</tt> - Symbol of route name or lambad, that return route name based on resource.
+      # Route name is used to call method lolita_[route_name] in Mapper class, and that should draw route.
+      # * <tt>:name</tt> - name of module, underscored symbol. Used to draw default route, by default always
+      # lolita_rest is called, but if route with resource name is found, than by default this route will be drawn.
+      # Like lolita_for :posts, can go to different controller than rest and do other things.
+      # * <tt>:path</tt> - some file that will be included. Deprecated will be removed
+      # ====Example
+      #     Lolita.add_module Lolita::Posts, :route=>:post, :name=>:post
+      #     lolita_for :posts #=> create url whatever is defined in lolita_post method, and goes to :controller=>"lolita/posts"
+      #     Lolita.add_module Lolita::FileUpload, :route=>lambda{|resource| resource.lolita.tabs.by_type(:file) ? :file_upload : nil}
+      #     lolita_for :users #=> creat default rest urls and also call method lolita_file_upload if user lolita define :file tab.
+      # To add route for public interface that goes to added module, than use 
+      #    Lolita.add_module Post, :name=>:posts
+      # And then when in routes.rb will be defined lolita_for(:posts) it will call method <i>lolita_posts_route</i>
+      # and that method should define resource. 
+      # ====Example
+      #     # require this in your gem or lib
+      #     module ActionDispatch::Routing
+      #        class Mapper
+      #          protected
+      #          def lolita_posts_route mapping, controllers
+      #            resources mapping.plural,:only=>[:index,:new,:create],
+      #              :controller=>controllers[:posts],:module=>mapping.module
+      #          end
+      #        end
+      #      end
+      # You open Mapper class and add your method that call #resources or #match or other method that define route
+      # For common route for all lolita resources your method should look like this
+      # ====Example
+      #     def lolita_files_route 
+      #        mapping=Lolita.add_mapping(:files,:class_name=>"Lolita::Multimedia::File",:module=>"file_upload")
+      #        scope :module=>mapping.module do
+      #            resources mapping.name
+      #        end
+      #     end
+      def add_module module_container, options={}
+        raise ArgumentError, "Can't add module without module container!" unless module_container
+        options.assert_valid_keys(:controller,:route,:model,:path,:name,:nested)
+        name=options[:name]||module_container.to_s.to_sym
+        self.modules<<module_container
+
+        if options.has_key?(:route)
+          self.routes[name]=[options.has_key?(:nested) ? options[:nested] : true,options[:route]]
+        end
+        self.controllers[name]=options[:controller] if options.has_key?(:controller)
+
+        if options[:path]
+          require File.join(options[:path],name.to_s)
+        end
+    
+      end
+      
+    end
+  end
+end