lolita 3.3.4 → 3.3.5

data/lib/lolita/lazy_loader.rb

@@ -1,55 +1,55 @@
-module Lolita
-  class LazyLoader
-
-    #attr_reader :lazy_class,:eval_block,:class_instance
-
-    def self.lazy_load(instance_name,var_name,lazy_class,*args,&block)
-      temp_var = instance_name.instance_variable_get(var_name)
-      is_loader = temp_var.to_s =~ /Lolita::LazyLoader/
-      if !temp_var || ((args && args.any? && is_loader && temp_var.__is_args_diff__(args)) || block_given?)
-        temp_var = instance_name.instance_variable_set(var_name,self.new(lazy_class,*args,&block))
-      end
-      if temp_var.to_s =~ /Lolita::LazyLoader/
-        temp_var = instance_name.instance_variable_set(var_name,temp_var.class_instance)
-      end
-      temp_var
-    end
-
-    def __is_args_diff__(args)
-      @args != args
-    end
-
-    def initialize(lazy_class,*args,&block)
-      @args = args || []
-      @lazy_class=lazy_class
-      @eval_block=block
-    end
-
-    def class_instance
-      @class_instance || self
-    end
-
-    def method_missing(method_name,*args,&block)
-      unless @class_instance
-        @args = @args.empty? && [nil] || @args
-        arity=@lazy_class.instance_method(:initialize).arity
-        if arity==-1 # when expectign *args
-          @class_instance=@lazy_class.new(*@args,&@eval_block)
-        elsif arity.abs>0 # when expecting specific number of arguments without any *args
-          @class_instance=@lazy_class.new(*@args.slice(0..arity.abs-1),&@eval_block)
-        else
-          @class_instance=@lazy_class.new(&@eval_block)
-        end
-      end
-      if @class_instance.respond_to?(:after_initialize,true)
-        @class_instance.__send__(:after_initialize)
-      end
-      @class_instance.__send__(method_name,*args,&block)
-    end
-
-    instance_methods.each { |method|
-      next if ["!","__is_args_diff__","hash","respond_to?","__id__","__send__","to_s","object_id","method_missing","class_instance","initialize", "__args__"].include?(method.to_s)
-      eval("undef :#{method}")
-    }
-  end
+module Lolita
+  class LazyLoader
+
+    #attr_reader :lazy_class,:eval_block,:class_instance
+
+    def self.lazy_load(instance_name,var_name,lazy_class,*args,&block)
+      temp_var = instance_name.instance_variable_get(var_name)
+      is_loader = temp_var.to_s =~ /Lolita::LazyLoader/
+      if !temp_var || ((args && args.any? && is_loader && temp_var.__is_args_diff__(args)) || block_given?)
+        temp_var = instance_name.instance_variable_set(var_name,self.new(lazy_class,*args,&block))
+      end
+      if temp_var.to_s =~ /Lolita::LazyLoader/
+        temp_var = instance_name.instance_variable_set(var_name,temp_var.class_instance)
+      end
+      temp_var
+    end
+
+    def __is_args_diff__(args)
+      @args != args
+    end
+
+    def initialize(lazy_class,*args,&block)
+      @args = args || []
+      @lazy_class=lazy_class
+      @eval_block=block
+    end
+
+    def class_instance
+      @class_instance || self
+    end
+
+    def method_missing(method_name,*args,&block)
+      unless @class_instance
+        @args = @args.empty? && [nil] || @args
+        arity=@lazy_class.instance_method(:initialize).arity
+        if arity==-1 # when expectign *args
+          @class_instance=@lazy_class.new(*@args,&@eval_block)
+        elsif arity.abs>0 # when expecting specific number of arguments without any *args
+          @class_instance=@lazy_class.new(*@args.slice(0..arity.abs-1),&@eval_block)
+        else
+          @class_instance=@lazy_class.new(&@eval_block)
+        end
+      end
+      if @class_instance.respond_to?(:after_initialize,true)
+        @class_instance.__send__(:after_initialize)
+      end
+      @class_instance.__send__(method_name,*args,&block)
+    end
+
+    instance_methods.each { |method|
+      next if ["!","__is_args_diff__","hash","respond_to?","__id__","__send__","to_s","object_id","method_missing","class_instance","initialize", "__args__"].include?(method.to_s)
+      eval("undef :#{method}")
+    }
+  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