lolita 3.4.2 → 3.4.3

data/lib/lolita/navigation/tree.rb

@@ -1,133 +1,133 @@
-module Lolita
-  module Navigation
-    class Tree
-      include Enumerable
-      include Lolita::Hooks
-
-      class<<self
-        def remember(tree)
-          @@trees||={}
-          @@trees[tree.name.to_sym]=tree
-        end
-
-        def [](name)
-          @@trees||={}
-          @@trees[name]
-        end
-      end
-
-      add_hooks :before_branch_added, :after_branch_added
-
-      attr_reader :name,:root,:default_position,:branches,:parent
-
-      def initialize(name)
-        @name=name
-        @default_possition=:append
-        @branches=[]
-      end
-
-      def each 
-        @branches.each do |branch|
-          yield branch
-          if branch.children.any?
-            branch.children.each do |child|
-              yield child
-            end
-          end
-        end
-      end
-
-      def root?
-        !parent
-      end
-
-      def visible?(view)
-        self.branches.inject([]){|result,branch| 
-          if branch.visible?(view)
-            result << true
-          else
-            result
-          end
-        }.any?
-      end
-
-      def populate_urls_in_branches(view)
-        self.each do |branch|
-          branch.populate_url(view)
-        end
-      end
-
-      def method_missing method_name, *args
-        @branches.send(method_name.to_sym,*args)
-      end
-
-
-      def append(*branch)
-        adding_branch(*branch) do |fixed_branch|
-          @branches<<fixed_branch
-        end
-      end
-
-      def prepend(*branch)
-        adding_branch(*branch) do |fixed_branch|
-          @branches.unshift(fixed_branch)
-        end
-      end
-
-      def after(given_branch,*other_branch) 
-        index=get_branch_index(given_branch)
-
-        adding_branch(*other_branch) do |fixed_branch|
-          put_in_branches(fixed_branch,index)
-        end
-      end
-
-      def before(given_branch,*other_branch)
-        index=get_branch_index(given_branch)
-
-        adding_branch(*other_branch) do |fixed_branch|
-          put_in_branches(fixed_branch,index-1)
-        end
-      end
-
-      def get_branch_index(given_branch)
-        @branches.each_with_index{|branch,index|
-          return index if given_branch==branch
-        }
-        raise ArgumentError, "Branch #{given_branch.inspect} not exists in #{self.inspect}"
-      end
-
-      def set_parent(new_parent)
-        @parent=new_parent
-      end
-      
-      private
-
-      def adding_branch *branch
-        self.run(:before_branch_added,*branch)
-        fixed_branch=fix_branch(*branch)
-        yield fixed_branch
-        @last_branch=fixed_branch
-        self.run(:after_branch_added,fixed_branch)
-        fixed_branch
-      end
-
-      def fix_branch(*branch)
-        unless branch[0].is_a?(Lolita::Navigation::Branch)
-          options=branch.extract_options!
-          Lolita::Navigation::Branch.get_or_create(*branch,options.merge(:tree=>self))
-        else
-          branch[0].tree=self
-          branch[0]
-        end
-      end
-
-      def put_in_branches branch,index
-        before_part=@branches.slice(0,index+1) || []
-        after_part=@branches.slice(index+1,@branches.size-index) || []
-        @branches=before_part+[branch]+after_part
-      end
-
-    end
-  end
+module Lolita
+  module Navigation
+    class Tree
+      include Enumerable
+      include Lolita::Hooks
+
+      class<<self
+        def remember(tree)
+          @@trees||={}
+          @@trees[tree.name.to_sym]=tree
+        end
+
+        def [](name)
+          @@trees||={}
+          @@trees[name]
+        end
+      end
+
+      add_hooks :before_branch_added, :after_branch_added
+
+      attr_reader :name,:root,:default_position,:branches,:parent
+
+      def initialize(name)
+        @name=name
+        @default_possition=:append
+        @branches=[]
+      end
+
+      def each 
+        @branches.each do |branch|
+          yield branch
+          if branch.children.any?
+            branch.children.each do |child|
+              yield child
+            end
+          end
+        end
+      end
+
+      def root?
+        !parent
+      end
+
+      def visible?(view)
+        self.branches.inject([]){|result,branch| 
+          if branch.visible?(view)
+            result << true
+          else
+            result
+          end
+        }.any?
+      end
+
+      def populate_urls_in_branches(view)
+        self.each do |branch|
+          branch.populate_url(view)
+        end
+      end
+
+      def method_missing method_name, *args
+        @branches.send(method_name.to_sym,*args)
+      end
+
+
+      def append(*branch)
+        adding_branch(*branch) do |fixed_branch|
+          @branches<<fixed_branch
+        end
+      end
+
+      def prepend(*branch)
+        adding_branch(*branch) do |fixed_branch|
+          @branches.unshift(fixed_branch)
+        end
+      end
+
+      def after(given_branch,*other_branch) 
+        index=get_branch_index(given_branch)
+
+        adding_branch(*other_branch) do |fixed_branch|
+          put_in_branches(fixed_branch,index)
+        end
+      end
+
+      def before(given_branch,*other_branch)
+        index=get_branch_index(given_branch)
+
+        adding_branch(*other_branch) do |fixed_branch|
+          put_in_branches(fixed_branch,index-1)
+        end
+      end
+
+      def get_branch_index(given_branch)
+        @branches.each_with_index{|branch,index|
+          return index if given_branch==branch
+        }
+        raise ArgumentError, "Branch #{given_branch.inspect} not exists in #{self.inspect}"
+      end
+
+      def set_parent(new_parent)
+        @parent=new_parent
+      end
+      
+      private
+
+      def adding_branch *branch
+        self.run(:before_branch_added,*branch)
+        fixed_branch=fix_branch(*branch)
+        yield fixed_branch
+        @last_branch=fixed_branch
+        self.run(:after_branch_added,fixed_branch)
+        fixed_branch
+      end
+
+      def fix_branch(*branch)
+        unless branch[0].is_a?(Lolita::Navigation::Branch)
+          options=branch.extract_options!
+          Lolita::Navigation::Branch.get_or_create(*branch,options.merge(:tree=>self))
+        else
+          branch[0].tree=self
+          branch[0]
+        end
+      end
+
+      def put_in_branches branch,index
+        before_part=@branches.slice(0,index+1) || []
+        after_part=@branches.slice(index+1,@branches.size-index) || []
+        @branches=before_part+[branch]+after_part
+      end
+
+    end
+  end
 end

data/lib/lolita/rails/engine.rb

@@ -1,24 +1,24 @@
-require 'lolita/controllers'
-
-ActiveSupport.on_load(:action_controller) {
-  include Lolita::Controllers::UrlHelpers
-  include Lolita::Controllers::ComponentHelpers
-  include Lolita::Extensions
-}
-ActiveSupport.on_load(:action_view) {
-  include Lolita::Controllers::UrlHelpers
-  include Lolita::Controllers::ComponentHelpers
-  include Lolita::Controllers::RailsHelpers
-  include Lolita::Extensions
-}
-
-module Lolita
-  class Engine < Rails::Engine
-    config.lolita=Lolita
-    config.i18n.load_path += Dir[File.join(Lolita.root,'config', 'locales','default', '*.{yml}')]
-    config.before_initialize do
-      Haml.init_rails(binding)
-      Haml::Template.options[:format] = :html5
-    end
-  end
+require 'lolita/controllers'
+
+ActiveSupport.on_load(:action_controller) {
+  include Lolita::Controllers::UrlHelpers
+  include Lolita::Controllers::ComponentHelpers
+  include Lolita::Extensions
+}
+ActiveSupport.on_load(:action_view) {
+  include Lolita::Controllers::UrlHelpers
+  include Lolita::Controllers::ComponentHelpers
+  include Lolita::Controllers::RailsHelpers
+  include Lolita::Extensions
+}
+
+module Lolita
+  class Engine < Rails::Engine
+    config.lolita=Lolita
+    config.i18n.load_path += Dir[File.join(Lolita.root,'config', 'locales','default', '*.{yml}')]
+    config.before_initialize do
+      Haml.init_rails(binding)
+      Haml::Template.options[:format] = :html5
+    end
+  end
 end

data/lib/lolita/rails/routes.rb

@@ -1,129 +1,129 @@
-module ActionDispatch::Routing
-
-  class RouteSet
-
-    # Each time when #draw method is called this is called as well.
-    # It creates :left_side_navigation tree and call callbacks
-    # Lolita#before_routes_loaded and Lolita#after_routes_loaded
-    def draw_with_lolita  *args,&block
-      Lolita.run(:before_routes_loaded)
-      draw_without_lolita *args,&block
-      Lolita.run(:after_routes_loaded)
-    end
-
-    alias_method_chain :draw, :lolita
-  end
-
-  class Mapper
-
-    # Every module, that is used with lolita and has routes, need to have
-    # <code>resource method</code>, for example, lolita_rest, that should be added
-    # to ActionDispatch::Routing::Mapper class, as a *protected* method.
-    # Module can automaticliy add resource route or allow user to do it.
-    # It accepts some useful options
-    # * <tt>:module</tt>
-    # * <tt>:path</tt>
-    # * <tt>:as</tt>
-    # * <tt>:path_prefix</tt>
-    # * <tt>:controller</tt>
-    # * <tt>:class_name</tt>
-    # * <tt>:singular</tt>
-    # ====Example
-    #     Lolita.add_module Lolita::Gallery,:route=>:gallery
-    #     # in route.rb
-    #     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!
-
-      options[:as]          ||= @scope[:as]     if @scope[:as].present?
-      options[:module]      ||= @scope[:module] if @scope[:module].present?
-      options[:path_prefix] ||= @scope[:path]   if @scope[:path].present?
-      resources.map!(&:to_sym)
-      all_resource_classes=[]
-      resources.each{|resource|
-        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
-
-        lolita_scope mapping.name do
-          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?
-            #   warn("Lolita is not initialized, call `lolita` in #{target_class}")
-            #   route = Lolita.routes[mapping.name] || Lolita.default_route
-            #   #raise Lolita::NotInitialized, "Call lolita method in #{target_class}."
-            # else
-            #   route=Lolita.routes[mapping.name] || Lolita.default_route
-            # end
-            route = Lolita.routes[mapping.name] || Lolita.default_route
-            unless route
-              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|
-        send(:"lolita_#{route_name}_route")
-      end
-    end
-
-    protected
-
-    def lolita_scope scope
-      constraint = lambda do |request|
-        request.env["lolita.mapping"] = Lolita.mappings[scope]
-        true
-      end
-
-      constraints(constraint) do
-        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
-      yield
-    ensure
-      @scope[:as], @scope[:path], @scope[:module] = old_as, old_path, old_module
-    end
-
-    private
-
-    def migrating?
-      if Lolita.application.skip_routes.respond_to?(:call)
-        Lolita.application.skip_routes.call
-      else
-        File.basename($0).match(/^rake/) && (ARGV.detect{|arg| arg.to_s.match(/db|apartment/)})
-      end
-    end
-
-    def generating?
-      if Lolita.application.skip_routes.respond_to?(:call)
-        Lolita.application.skip_routes.call
-      else
-        Lolita.application.skip_routes || File.basename($0).match(/^rails/) && !caller.detect{|line| line.match(/commands\/(server|console)\.rb/)}
-      end
-    end
-  end
-end
+module ActionDispatch::Routing
+
+  class RouteSet
+
+    # Each time when #draw method is called this is called as well.
+    # It creates :left_side_navigation tree and call callbacks
+    # Lolita#before_routes_loaded and Lolita#after_routes_loaded
+    def draw_with_lolita  *args,&block
+      Lolita.run(:before_routes_loaded)
+      draw_without_lolita *args,&block
+      Lolita.run(:after_routes_loaded)
+    end
+
+    alias_method_chain :draw, :lolita
+  end
+
+  class Mapper
+
+    # Every module, that is used with lolita and has routes, need to have
+    # <code>resource method</code>, for example, lolita_rest, that should be added
+    # to ActionDispatch::Routing::Mapper class, as a *protected* method.
+    # Module can automaticliy add resource route or allow user to do it.
+    # It accepts some useful options
+    # * <tt>:module</tt>
+    # * <tt>:path</tt>
+    # * <tt>:as</tt>
+    # * <tt>:path_prefix</tt>
+    # * <tt>:controller</tt>
+    # * <tt>:class_name</tt>
+    # * <tt>:singular</tt>
+    # ====Example
+    #     Lolita.add_module Lolita::Gallery,:route=>:gallery
+    #     # in route.rb
+    #     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!
+
+      options[:as]          ||= @scope[:as]     if @scope[:as].present?
+      options[:module]      ||= @scope[:module] if @scope[:module].present?
+      options[:path_prefix] ||= @scope[:path]   if @scope[:path].present?
+      resources.map!(&:to_sym)
+      all_resource_classes=[]
+      resources.each{|resource|
+        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
+
+        lolita_scope mapping.name do
+          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?
+            #   warn("Lolita is not initialized, call `lolita` in #{target_class}")
+            #   route = Lolita.routes[mapping.name] || Lolita.default_route
+            #   #raise Lolita::NotInitialized, "Call lolita method in #{target_class}."
+            # else
+            #   route=Lolita.routes[mapping.name] || Lolita.default_route
+            # end
+            route = Lolita.routes[mapping.name] || Lolita.default_route
+            unless route
+              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|
+        send(:"lolita_#{route_name}_route")
+      end
+    end
+
+    protected
+
+    def lolita_scope scope
+      constraint = lambda do |request|
+        request.env["lolita.mapping"] = Lolita.mappings[scope]
+        true
+      end
+
+      constraints(constraint) do
+        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
+      yield
+    ensure
+      @scope[:as], @scope[:path], @scope[:module] = old_as, old_path, old_module
+    end
+
+    private
+
+    def migrating?
+      if Lolita.application.skip_routes.respond_to?(:call)
+        Lolita.application.skip_routes.call
+      else
+        File.basename($0).match(/^rake/) && (ARGV.detect{|arg| arg.to_s.match(/db|apartment/)})
+      end
+    end
+
+    def generating?
+      if Lolita.application.skip_routes.respond_to?(:call)
+        Lolita.application.skip_routes.call
+      else
+        Lolita.application.skip_routes || File.basename($0).match(/^rails/) && !caller.detect{|line| line.match(/commands\/(server|console)\.rb/)}
+      end
+    end
+  end
+end