lolita 3.1.10 → 3.1.11

data/lib/lolita/controllers/internal_helpers.rb

@@ -1,110 +1,110 @@
-module Lolita
-  module Controllers
-    module InternalHelpers
-      extend ActiveSupport::Concern
-      included do
-        helper LolitaHelper
-        #TODO pārnest helperus uz lolitu vai arī uz lolita app nevis likt iekš controllers iekš lolitas
-        helpers = %w(resource resource_name
-                     resource_class lolita_mapping show_response)
-        hide_action *helpers
-       
-        helper_method *helpers
-        prepend_before_filter :is_lolita_resource?
-        prepend_around_filter :switch_locale
-      end
-
-      # Return instance variable named as resource
-      # For 'posts' instance variable will be @posts
-      def resource
-        instance_variable_get(:"@#{resource_name}")
-      end
-      
-      def resource_name
-        lolita_mapping.name
-      end
-      
-      def resource_class
-        lolita_mapping.to
-      end
-      
-      def lolita_mapping
-        @lolita_mapping||=request.env["lolita.mapping"]
-      end
-      
-      protected
-
-      def is_lolita_resource?
-        raise ActionController::UnknownAction unless lolita_mapping
-      end
-
-      def resource=(new_resource)
-        instance_variable_set(:"@#{resource_name}",new_resource)
-      end
-
-      def resource_attributes
-        fix_attributes(params[resource_name] || {})
-      end
-
-      def resource_with_attributes(current_resource,attributes={})
-        attributes||=resource_attributes
-        attributes.each{|key,value|
-          current_resource.send(:"#{key}=",value)
-        }
-        current_resource
-      end
-
-      def get_resource(id=nil)
-        self.resource=resource_class.lolita.dbi.find_by_id(id||params[:id])
-      end
-
-      def build_resource(attributes=nil)
-        self.run(:before_build_resource)
-        attributes||=resource_attributes
-        self.resource=resource_with_attributes(resource_class.new,attributes)
-        self.run(:after_build_resource)
-      end
-
-      def build_response_for(conf_part,options={})
-        # FIXME when asked for some resources that always create new object, there may
-        # not be any args, like lolita.report on something like that
-        @component_options = options
-        @component_object = resource_class.lolita.send(conf_part.to_sym)
-        @component_builder = @component_object.build(@component_options)
-      end
-      
-
-      private
-
-      def fix_attributes attributes
-        fix_rails_date_attributes attributes
-      end
-
-      def fix_rails_date_attributes attributes
-        #{"created_at(1i)"=>"2011", "created_at(2i)"=>"4", "created_at(3i)"=>"19", "created_at(4i)"=>"16", "created_at(5i)"=>"14"}
-        date_attributes = {}
-        attributes.each_pair do |k,v|
-          if k.to_s =~ /(.+)\((\d)i\)$/
-            date_attributes[$1] = {} unless date_attributes[$1]
-            date_attributes[$1][$2.to_i] = v.to_i
-            attributes.delete(k)
-          end
-        end
-        date_attributes.each_pair do |k,v|
-          unless v.detect{|index,value| value == 0}
-            attributes[k] = v.size == 3 ? Date.new(v[1],v[2],v[3]) : Time.new(v[1],v[2],v[3],v[4],v[5])
-          end
-        end
-        attributes
-      end
-
-      def switch_locale
-        old_locale=::I18n.locale
-        Lolita.locale=params[:locale]
-        ::I18n.locale=Lolita.locale
-        yield
-        ::I18n.locale=old_locale
-      end
-    end
-  end
+module Lolita
+  module Controllers
+    module InternalHelpers
+      extend ActiveSupport::Concern
+      included do
+        helper LolitaHelper
+        #TODO pārnest helperus uz lolitu vai arī uz lolita app nevis likt iekš controllers iekš lolitas
+        helpers = %w(resource resource_name
+                     resource_class lolita_mapping show_response)
+        hide_action *helpers
+       
+        helper_method *helpers
+        prepend_before_filter :is_lolita_resource?
+        prepend_around_filter :switch_locale
+      end
+
+      # Return instance variable named as resource
+      # For 'posts' instance variable will be @posts
+      def resource
+        instance_variable_get(:"@#{resource_name}")
+      end
+      
+      def resource_name
+        lolita_mapping.name
+      end
+      
+      def resource_class
+        lolita_mapping.to
+      end
+      
+      def lolita_mapping
+        @lolita_mapping||=request.env["lolita.mapping"]
+      end
+      
+      protected
+
+      def is_lolita_resource?
+        raise ActionController::UnknownAction unless lolita_mapping
+      end
+
+      def resource=(new_resource)
+        instance_variable_set(:"@#{resource_name}",new_resource)
+      end
+
+      def resource_attributes
+        fix_attributes(params[resource_name] || {})
+      end
+
+      def resource_with_attributes(current_resource,attributes={})
+        attributes||=resource_attributes
+        attributes.each{|key,value|
+          current_resource.send(:"#{key}=",value)
+        }
+        current_resource
+      end
+
+      def get_resource(id=nil)
+        self.resource=resource_class.lolita.dbi.find_by_id(id||params[:id])
+      end
+
+      def build_resource(attributes=nil)
+        self.run(:before_build_resource)
+        attributes||=resource_attributes
+        self.resource=resource_with_attributes(resource_class.new,attributes)
+        self.run(:after_build_resource)
+      end
+
+      def build_response_for(conf_part,options={})
+        # FIXME when asked for some resources that always create new object, there may
+        # not be any args, like lolita.report on something like that
+        @component_options = options
+        @component_object = resource_class.lolita.send(conf_part.to_sym)
+        @component_builder = @component_object.build(@component_options)
+      end
+      
+
+      private
+
+      def fix_attributes attributes
+        fix_rails_date_attributes attributes
+      end
+
+      def fix_rails_date_attributes attributes
+        #{"created_at(1i)"=>"2011", "created_at(2i)"=>"4", "created_at(3i)"=>"19", "created_at(4i)"=>"16", "created_at(5i)"=>"14"}
+        date_attributes = {}
+        attributes.each_pair do |k,v|
+          if k.to_s =~ /(.+)\((\d)i\)$/
+            date_attributes[$1] = {} unless date_attributes[$1]
+            date_attributes[$1][$2.to_i] = v.to_i
+            attributes.delete(k)
+          end
+        end
+        date_attributes.each_pair do |k,v|
+          unless v.detect{|index,value| value == 0}
+            attributes[k] = v.size == 3 ? Date.new(v[1],v[2],v[3]) : Time.new(v[1],v[2],v[3],v[4],v[5])
+          end
+        end
+        attributes
+      end
+
+      def switch_locale
+        old_locale=::I18n.locale
+        Lolita.locale=params[:locale]
+        ::I18n.locale=Lolita.locale
+        yield
+        ::I18n.locale=old_locale
+      end
+    end
+  end
 end

data/lib/lolita/controllers/url_helpers.rb

@@ -1,111 +1,111 @@
-module Lolita
-  module Controllers
-    # This module is included in all controllers and views. UrlHelper provide methods to generate lolita
-    # resource paths. As all resources goes to one controller (by default), than it is very difficult to
-    # generate url with <em>:controller</em> and <em>:action</em>. 
-    # There are four methods for path:
-    # * lolita_resources_path - goes to index action
-    # * lolita_resource_path - goes to create, destroy or show, it depends what kind of method is used
-    # * new_lolita_resource_path - goes to new action
-    # * edit_lolita_resource_path - goes to edit action
-    # All of those methods accept <em>mapping</em> as a first argument and optional <em>options</em> that
-    # will be passed to path gererator. It is possible to pass only options, than current mapping will be used.
-    # ====Example
-    #     # lets say, that current mapping is for posts
-    #     edit_lolita_resource_path(:id=>4) #=> /lolita/posts/4/edit
-    #     edit_lolita_resource_path(comment_mapping,:id=>1,:parent_id=>2) #=> /lolita/comments/1/edit?parent_id=2
-    # For custom actions there are method #lolita_resource_name that make it easier to generate custom method.
-    # All other methods use that for real resource path method generation.
-    module UrlHelpers
-
-      def self.included(model_klass)
-        model_klass.class_eval do
-
-          # Overrides url_for when controller or view uses this helper.
-          # It catches hash options and replaces with lolita named route
-          # Without this method routes always looks like /lolita/rest/[method]
-          # ====Example
-          #     # in routes.rb
-          #     lolita_for :posts
-          #     # GET /lolita/posts
-          #     # in view
-          #     url_for #=> /lolita/posts
-          #     url_for(:controller=>"/posts",:action=>:index) #=> /posts
-          #     # GET /posts
-          #     url_for #=> /posts
-          def url_for_with_lolita options = {}
-            if options.is_a?(Hash) && !options[:use_route] && self.respond_to?(:lolita_mapping)
-              controller = options[:controller].to_s
-              if Lolita.mappings[lolita_mapping.name].controllers.values.include?(controller)
-                resource_type = {
-                  :index => :lolita_resources_path,
-                  :new => :new_lolita_resource_path,
-                  :edit => :edit_lolita_resource_path,
-                  :create => :lolita_resources_path
-                }
-                action = (options[:action] || params[:action]).to_sym
-                options = self.send(resource_type[action] || :lolita_resource_path,options)
-              end
-            end
-            url_for_without_lolita(options)
-          end
-          alias_method_chain :url_for, :lolita
-
-        end
-      end
-
-      protected
-      
-      # Path for index.
-      def lolita_resources_path(*args)
-        options=args.extract_options!
-        mapping=args[0]
-        send(lolita_resource_name(:mapping=>mapping,:plural=>true),options)
-      end
-
-      # Path for show, create and destroy
-      def lolita_resource_path(*args) 
-        options=args.extract_options!
-        mapping=args[0]
-        send(lolita_resource_name(:mapping=>mapping),options)
-      end
-
-      # Path for new.
-      def new_lolita_resource_path(*args)
-        options=args.extract_options!
-        mapping=args[0]
-        send(lolita_resource_name(:mapping=>mapping,:action=>:new),options)
-      end
-
-      # Path for edit.
-      def edit_lolita_resource_path(*args)
-        options=args.extract_options!
-        options[:id]||=resource.id if resource
-        #raise "Can edit resource without id." unless options[:id]
-        mapping=args[0]
-        send(lolita_resource_name(:mapping=>mapping,:action=>:edit),options)
-      end
-
-      # It return symbol, that represents named route method for path, like <i>lolita_posts_path</i> and so on.
-      # It accepts those options: 
-      # * <tt>:mapping</tt> - Lolita::Mapping object, that is used to detect name of named route.
-      # by default it uses Lolita::InternalHelpers#lolita_mapping.
-      # * <tt>:plural</tt> - What kind of named route should use, plural or singular.
-      # * <tt>:action</tt> - Action is used to put before named route like <i>:edit</i>.
-      # ====Example
-      #     # current mapping is for posts
-      #     lolita_resource_name(:action=>:edit) #=> :edit_lolita_post_path
-      #     lolita_resource_name(:plural=>true,:action=>:list) #=> :list_lolita_posts_path
-      #     # for different mapping 
-      #     lolita_resource_name(:mapping=>comments_mapping) #=> :lolita_comment_path
-      # This methods is very useful to create your own paths in views.
-      def lolita_resource_name(options={}) #TODO test if path is right
-        options.assert_valid_keys(:mapping,:plural,:action)
-        mapping=(options[:mapping]||lolita_mapping)
-        name=!options[:plural] ? mapping.name : mapping.plural
-        name="#{mapping.path}_#{name}"
-        :"#{options[:action]}#{options[:action] ? "_" : ""}#{name}_path"
-      end
-    end
-  end
-end
+module Lolita
+  module Controllers
+    # This module is included in all controllers and views. UrlHelper provide methods to generate lolita
+    # resource paths. As all resources goes to one controller (by default), than it is very difficult to
+    # generate url with <em>:controller</em> and <em>:action</em>. 
+    # There are four methods for path:
+    # * lolita_resources_path - goes to index action
+    # * lolita_resource_path - goes to create, destroy or show, it depends what kind of method is used
+    # * new_lolita_resource_path - goes to new action
+    # * edit_lolita_resource_path - goes to edit action
+    # All of those methods accept <em>mapping</em> as a first argument and optional <em>options</em> that
+    # will be passed to path gererator. It is possible to pass only options, than current mapping will be used.
+    # ====Example
+    #     # lets say, that current mapping is for posts
+    #     edit_lolita_resource_path(:id=>4) #=> /lolita/posts/4/edit
+    #     edit_lolita_resource_path(comment_mapping,:id=>1,:parent_id=>2) #=> /lolita/comments/1/edit?parent_id=2
+    # For custom actions there are method #lolita_resource_name that make it easier to generate custom method.
+    # All other methods use that for real resource path method generation.
+    module UrlHelpers
+
+      def self.included(model_klass)
+        model_klass.class_eval do
+
+          # Overrides url_for when controller or view uses this helper.
+          # It catches hash options and replaces with lolita named route
+          # Without this method routes always looks like /lolita/rest/[method]
+          # ====Example
+          #     # in routes.rb
+          #     lolita_for :posts
+          #     # GET /lolita/posts
+          #     # in view
+          #     url_for #=> /lolita/posts
+          #     url_for(:controller=>"/posts",:action=>:index) #=> /posts
+          #     # GET /posts
+          #     url_for #=> /posts
+          def url_for_with_lolita options = {}
+            if options.is_a?(Hash) && !options[:use_route] && self.respond_to?(:lolita_mapping)
+              controller = options[:controller].to_s
+              if Lolita.mappings[lolita_mapping.name].controllers.values.include?(controller)
+                resource_type = {
+                  :index => :lolita_resources_path,
+                  :new => :new_lolita_resource_path,
+                  :edit => :edit_lolita_resource_path,
+                  :create => :lolita_resources_path
+                }
+                action = (options[:action] || params[:action]).to_sym
+                options = self.send(resource_type[action] || :lolita_resource_path,options)
+              end
+            end
+            url_for_without_lolita(options)
+          end
+          alias_method_chain :url_for, :lolita
+
+        end
+      end
+
+      protected
+      
+      # Path for index.
+      def lolita_resources_path(*args)
+        options=args.extract_options!
+        mapping=args[0]
+        send(lolita_resource_name(:mapping=>mapping,:plural=>true),options)
+      end
+
+      # Path for show, create and destroy
+      def lolita_resource_path(*args) 
+        options=args.extract_options!
+        mapping=args[0]
+        send(lolita_resource_name(:mapping=>mapping),options)
+      end
+
+      # Path for new.
+      def new_lolita_resource_path(*args)
+        options=args.extract_options!
+        mapping=args[0]
+        send(lolita_resource_name(:mapping=>mapping,:action=>:new),options)
+      end
+
+      # Path for edit.
+      def edit_lolita_resource_path(*args)
+        options=args.extract_options!
+        options[:id]||=resource.id if resource
+        #raise "Can edit resource without id." unless options[:id]
+        mapping=args[0]
+        send(lolita_resource_name(:mapping=>mapping,:action=>:edit),options)
+      end
+
+      # It return symbol, that represents named route method for path, like <i>lolita_posts_path</i> and so on.
+      # It accepts those options: 
+      # * <tt>:mapping</tt> - Lolita::Mapping object, that is used to detect name of named route.
+      # by default it uses Lolita::InternalHelpers#lolita_mapping.
+      # * <tt>:plural</tt> - What kind of named route should use, plural or singular.
+      # * <tt>:action</tt> - Action is used to put before named route like <i>:edit</i>.
+      # ====Example
+      #     # current mapping is for posts
+      #     lolita_resource_name(:action=>:edit) #=> :edit_lolita_post_path
+      #     lolita_resource_name(:plural=>true,:action=>:list) #=> :list_lolita_posts_path
+      #     # for different mapping 
+      #     lolita_resource_name(:mapping=>comments_mapping) #=> :lolita_comment_path
+      # This methods is very useful to create your own paths in views.
+      def lolita_resource_name(options={}) #TODO test if path is right
+        options.assert_valid_keys(:mapping,:plural,:action)
+        mapping=(options[:mapping]||lolita_mapping)
+        name=!options[:plural] ? mapping.name : mapping.plural
+        name="#{mapping.path}_#{name}"
+        :"#{options[:action]}#{options[:action] ? "_" : ""}#{name}_path"
+      end
+    end
+  end
+end

data/lib/lolita/controllers/user_helpers.rb

@@ -1,32 +1,32 @@
-module Lolita
-  module Controllers
-    # Add method #authenticate_lolita_user!
-    # that is called before each action in Lolita controllers.
-    # Authentication should be defined through Lolita#setup.
-    # Method call block or send given method name to current controller
-    # or return True when no authentication is defined.
-    module UserHelpers
-      extend ActiveSupport::Concern
-      included do
-        helper LolitaHelper
-      end
-      
-      private
-    # FIXME what to do when block or method return false, and do not redirect
-    # need some redirect, but how to detect it?
-      def authenticate_lolita_user!
-        if auth=Lolita.authentication
-          if auth.is_a?(Proc)
-            self.instance_eval(&auth)
-          else
-            send(auth)
-          end
-        else
-          #TODO warning
-          true
-        end
-      end
-
-    end
-  end
-end
+module Lolita
+  module Controllers
+    # Add method #authenticate_lolita_user!
+    # that is called before each action in Lolita controllers.
+    # Authentication should be defined through Lolita#setup.
+    # Method call block or send given method name to current controller
+    # or return True when no authentication is defined.
+    module UserHelpers
+      extend ActiveSupport::Concern
+      included do
+        helper LolitaHelper
+      end
+      
+      private
+    # FIXME what to do when block or method return false, and do not redirect
+    # need some redirect, but how to detect it?
+      def authenticate_lolita_user!
+        if auth=Lolita.authentication
+          if auth.is_a?(Proc)
+            self.instance_eval(&auth)
+          else
+            send(auth)
+          end
+        else
+          #TODO warning
+          true
+        end
+      end
+
+    end
+  end
+end