lolita 4.0.5 → 4.0.6

data/lib/lolita/mapping.rb

@@ -17,7 +17,7 @@ module Lolita
   # what controller to use, what model is related with it and so on. This is used to generate urls and paths.
   # Also eahc request containers information with mapping related to it.
   class Mapping
-    attr_reader :class_name,:path,:singular,:plural,:path_prefix,:module,:as,:controllers
+    attr_reader :class_name,:path,:singular,:plural,:path_prefix,:module,:as,:controllers,:ref
     attr_reader :visible, :only, :append_to, :title
     alias :name :singular
     
@@ -74,7 +74,7 @@ module Lolita
           end
           tree = parent_branch.children
         end
-        unless tree.branches.detect{|b| b.object.is_a?(Lolita::Mapping) && b.object.to==self.to}
+        unless tree.branches.detect{|b| b.object.is_a?(Lolita::Mapping) && b.object.ref == self.ref}
           tree.append(self, :title => @title)
         end
       end

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