lolita 3.0.7 → 3.1.0

data/lib/lolita/configuration/tab/content.rb

@@ -1,20 +1,22 @@
 module Lolita
   module Configuration
-  	class ContentTab < Lolita::Configuration::Tab
+    module Tab
+    	class Content < Lolita::Configuration::Tab::Base
 
-  	  def initialize(dbi,*args,&block)
-        @type=:content
-  	  	super
-  	  	set_default_fields
-  	  end
+    	  def initialize(dbi,*args,&block)
+          @type=:content
+    	  	super
+    	  	set_default_fields
+    	  end
 
-  	  private 
+    	  private 
 
 
-      def set_default_fields
-        default_fields if @fields.empty? 
-      end
-      
-  	end
+        def set_default_fields
+          default_fields if @fields.empty? 
+        end
+        
+    	end
+    end
   end
 end

data/lib/lolita/configuration/tab/default.rb

@@ -1,22 +1,24 @@
 module Lolita
   module Configuration
-    class DefaultTab < Lolita::Configuration::Tab
+    module Tab
+      class Default < Lolita::Configuration::Tab::Base
 
-      def initialize *args,&block
-        self.type=:default
-        super
-      end
+        def initialize *args,&block
+          self.type=:default
+          super
+        end
 
-      private
+        private
 
-      def set_default_fields
-        warn("Default fields are not set for DefaultTab.")
-      end
+        def set_default_fields
+          warn("Default fields are not set for DefaultTab.")
+        end
 
-      def validate
-        super
-        if fields.empty?
-          raise Lolita::NoFieldsGivenError, "At least one field must be specified for default tab."
+        def validate
+          super
+          if fields.empty?
+            raise Lolita::NoFieldsGivenError, "At least one field must be specified for default tab."
+          end
         end
       end
     end

data/lib/lolita/configuration/tabs.rb

@@ -105,7 +105,7 @@ module Lolita
       end
       
       def default_tab_types
-        Lolita::Configuration::Tab.default_types
+        Lolita::Configuration::Tab::Base.default_types
       end
 
       def set_tab_attributes(tab)
@@ -120,7 +120,7 @@ module Lolita
 
       def build_element(element,&block)
         current_tab=if element.is_a?(Hash) || element.is_a?(Symbol)
-          Lolita::Configuration::Tab.new(@dbi,element,&block)
+          Lolita::Configuration::Tab.add(@dbi,element,&block)
         else
           element
         end

data/lib/lolita/controllers/component_helpers.rb

@@ -8,7 +8,7 @@ module Lolita
     # Component should have fallowing module structure Components::[NameSpace]::[Component name]Component
     #     Components::Lolita::ListComponent
     # ====Example
-    #     render_component :"lolita/list", :dispaly
+    #     render_component :"lolita/configuration/list", :dispaly
     #     # try to find /helpers/components/lolita/list_component.rb in every directory in $: that
     #     # ends with /helpers
     #     # require this file if found and extend self with Components::Lolita::ListComponent.
@@ -26,18 +26,20 @@ module Lolita
       #      render_component "lolita/list", :display
       #      render_component "lolita/list/display"
       def render_component *args
+        
         @opts=args.extract_options!
         name=args[0]
         state=args[1]
         format=@opts.delete(:format)
         raise "Can't render component without name!" unless name
         will_use_component name 
+        partial_name=File.join("/components",name.to_s,state ? state.to_s : nil)
         if format
           with_format(format) do
-            render(:partial=>"/components/#{name}#{state ? "/#{state}" : nil}",:locals=>@opts)
+            render(:partial=>partial_name,:locals=>@opts)
           end
         else
-          render(:partial=>"/components/#{name}#{state ? "/#{state}" : nil}",:locals=>@opts)
+          render(:partial=>partial_name,:locals=>@opts)
         end
       end
       
@@ -51,26 +53,36 @@ module Lolita
 
       # Require component helper file and extend current instance with component helper module.
       # ====Example
-      #     will_use_component :"lolita/list"
+      #     will_use_component :"lolita/configuration/list"
       def will_use_component component_name
-        @used_component_helpers||=[]
-        unless @used_component_helpers.include?(component_name)
-          if path=component_helper_path(component_name)
-            self.class.class_eval do
-              require path
+        helpers_for_component(component_name) do |possible_component_name|
+          @used_component_helpers||=[]
+          unless @used_component_helpers.include?(possible_component_name)
+            if path=component_helper_path(possible_component_name)
+              self.class.class_eval do
+                require path
+              end
+              class_name=possible_component_name.to_s.camelize
+              self.extend("Components::#{class_name}Component".constantize) rescue nil #FIXME too slow
             end
-            class_name=component_name.to_s.camelize
-            self.extend("Components::#{class_name}Component".constantize)
+            @used_component_helpers<<possible_component_name
           end
-          @used_component_helpers<<component_name
         end
       end
       
+      def helpers_for_component component_name
+        names=component_name.to_s.split("/")
+        start_index=1 # first is lolita
+        start_index.upto(names.size) do |index|
+          yield names.slice(0..index).join("/")
+        end
+      end
+
       # Find path for given component.
       # 
       #    component_helper_path :"lolita/list" #=> [path_to_lolita]/app/helpers/components/lolita/list_component.rb
       def component_helper_path component_name
-         helper_paths=$:.reject{|p| !p.match(/\/helpers$/)}
+         @helper_paths||=$:.reject{|p| !p.match(/\/helpers$/)}
          get_path=lambda{|paths|
           extra_path=component_name.to_s.split("/")
           component=extra_path.pop
@@ -82,7 +94,7 @@ module Lolita
             end  
           nil
         }
-        path=get_path.call(helper_paths)
+        path=get_path.call(@helper_paths)
         path
       end
       

data/lib/lolita/controllers/internal_helpers.rb

@@ -11,6 +11,7 @@ module Lolita
        
         helper_method *helpers
         prepend_before_filter :is_lolita_resource?
+        prepend_around_filter :switch_locale
       end
 
       # Return instance variable named as resource
@@ -63,11 +64,24 @@ module Lolita
       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 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

@@ -2,24 +2,60 @@ module Lolita
   module Controllers
     module UrlHelpers
 
-      protected
+      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
+      
       def lolita_resources_path(*args)
         options=args.extract_options!
         mapping=args[0]
-        send(lolita_resource_name(mapping,nil,true),options)
+        send(lolita_resource_name(:mapping=>mapping,:plural=>true),options)
       end
-      
+
       def lolita_resource_path(*args) # TODO test
         options=args.extract_options!
         mapping=args[0]
-        send(lolita_resource_name(mapping),options)
+        send(lolita_resource_name(:mapping=>mapping),options)
       end
 
       def new_lolita_resource_path(*args)
         options=args.extract_options!
         mapping=args[0]
-        send(lolita_resource_name(mapping,:new),options)
+        send(lolita_resource_name(:mapping=>mapping,:action=>:new),options)
       end
 
       def edit_lolita_resource_path(*args)
@@ -27,14 +63,15 @@ module Lolita
         options[:id]||=resource.id if resource
         raise "Can edit resource without id." unless options[:id]
         mapping=args[0]
-        send(lolita_resource_name(mapping,:edit),options)
+        send(lolita_resource_name(:mapping=>mapping,:action=>:edit),options)
       end
 
-      def lolita_resource_name(mapping=nil,action=nil,plural=nil) #TODO test if path is right
-        mapping=(mapping||lolita_mapping)
-        name=!plural ? mapping.name : mapping.plural
+      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}"
-        :"#{action}#{action ? "_" : ""}#{name}_path"
+        :"#{options[:action]}#{options[:action] ? "_" : ""}#{name}_path"
       end
     end
   end

data/lib/lolita/dbi/base.rb

@@ -1,50 +1,50 @@
-module Lolita
-  module DBI
-    # Lolita::DBI::Base is DataBase Interface class, that handle the request to ORM classes.
-    # Depending on given class DBI::Base detect which ORM class is used and include right adapter
-    # for that class. Other Lolita classes that need to manipulate with data need to have dbi object
-    # or it can be created in that class.
-    # Lolita::DBI::Base support Mongoid and ActiveRecord::Base, or details see Lolita::Adapter.
-    class Base
-
-      attr_reader :adapter_name #return connected adapter name
-      attr_reader :klass # return related orm class object
-      attr_reader :adapter # connected Adaptee for adapter
-      # Expect ORM class that is supported by Lolita. See Adapter for available adapters.
-      def initialize(class_object) 
-        @klass=class_object
-        detect_adapter
-        connect_adapter
-      end
-
-      # Detect which ORM class is given and based on it connect Adapter.
-      def detect_adapter
-        if defined?(Mongoid) && defined?(Mongoid::Document) && self.klass.ancestors.include?(Mongoid::Document)
-          @adapter_name=:mongoid
-        elsif defined?(ActiveRecord) && defined?(ActiveRecord::Base) && self.klass.ancestors.include?(ActiveRecord::Base)
-          @adapter_name=:active_record
-        else
-          raise NotORMClassError.new("Lolita::DBI::Base can not find appropriate #{self.klass} class adapter.")
-        end
-      end
-
-      # Connect Adapter by including adapter module into DBI::Base class.
-      def connect_adapter()
-        @adapter="Lolita::Adapter::#{self.adapter_name.to_s.camelize}".constantize.new(self)
-      end
-
-      def method_missing(metod,*args,&block)
-        @adapter.send(metod,*args,&block)
-      end
-
-      class << self
-        # Return Array of available adapters.
-        def adapters
-          Dir[File.expand_path(File.join(File.dirname(__FILE__),'..','adapter','**','*.rb'))].map {|f|
-            File.basename(f,".rb").to_sym
-          }.reject{|el| el==:abstract_adapter}
-        end
-      end
-    end
-  end
-end
+module Lolita
+  module DBI
+    # Lolita::DBI::Base is DataBase Interface class, that handle the request to ORM classes.
+    # Depending on given class DBI::Base detect which ORM class is used and include right adapter
+    # for that class. Other Lolita classes that need to manipulate with data need to have dbi object
+    # or it can be created in that class.
+    # Lolita::DBI::Base support Mongoid and ActiveRecord::Base, or details see Lolita::Adapter.
+    class Base
+
+      attr_reader :adapter_name #return connected adapter name
+      attr_reader :klass # return related orm class object
+      attr_reader :adapter # connected Adaptee for adapter
+      # Expect ORM class that is supported by Lolita. See Adapter for available adapters.
+      def initialize(class_object) 
+        @klass=class_object
+        detect_adapter
+        connect_adapter
+      end
+
+      # Detect which ORM class is given and based on it connect Adapter.
+      def detect_adapter
+        if defined?(Mongoid) && defined?(Mongoid::Document) && self.klass.ancestors.include?(Mongoid::Document)
+          @adapter_name=:mongoid
+        elsif defined?(ActiveRecord) && defined?(ActiveRecord::Base) && self.klass.ancestors.include?(ActiveRecord::Base)
+          @adapter_name=:active_record
+        else
+          raise NotORMClassError.new("Lolita::DBI::Base can not find appropriate #{self.klass} class adapter.")
+        end
+      end
+
+      # Connect Adapter by including adapter module into DBI::Base class.
+      def connect_adapter()
+        @adapter="Lolita::Adapter::#{self.adapter_name.to_s.camelize}".constantize.new(self)
+      end
+
+      def method_missing(metod,*args,&block)
+        @adapter.send(metod,*args,&block)
+      end
+
+      class << self
+        # Return Array of available adapters.
+        def adapters
+          Dir[File.expand_path(File.join(File.dirname(__FILE__),'..','adapter','**','*.rb'))].map {|f|
+            File.basename(f,".rb").to_sym
+          }.reject{|el| el==:abstract_adapter}
+        end
+      end
+    end
+  end
+end

data/lib/lolita/errors.rb

@@ -7,7 +7,7 @@ module Lolita
   class FieldTypeError < ArgumentError; end
   class ModuleNotFound < ArgumentError; end
   class NotFound < ArgumentError; end
-  class TabNotFoundError < NameError; end
-  class FieldNotFoundError < NameError; end
+  class ConfigurationClassNotFound < NameError; end
   class AssociationError < ArgumentError; end
+  class HookNotFound < ArgumentError;end
 end

data/lib/lolita/hooks.rb

@@ -0,0 +1,298 @@
+module Lolita
+  # Provide hook mechanism for Lolita. To use hooks for class start with including this in your own class.
+  # Next step is hook definition. This may be done using Lolita::Hooks#add_hook method.
+  # Hooks are stored in class <i>@hooks</i> variable, that is Hash and each key is hook name
+  # and each hook also is Hash that have <em>:methods</em> and <em>:blocks</em>
+  # keys. Both of those are Array, and each time you call callback method, like <i>before_save</i> and so on, block 
+  # and/or methods is stored. <b>Each time</b> #fire is called all blocks and methods will be executed.
+  # It may look like this.
+  #    class MyClass
+  #      include Lolita::Hooks
+  #      add_hook :before_save, :after_save
+  #    end
+  #    # This will define two hooks for MyClass.
+  # To add hook callback just call hook name on class and pass method(-s) or block.
+  #    MyClass.after_save :write_log
+  #    MyClass.before_save do
+  #      validate(self)
+  #    end
+  # ==Scopes
+  # Most times hook callbacks are defined for class like in previous example, but also it's possible to do it
+  # on class instances. Difference between calling it on class or on instance is that instance callbacks will
+  # be called only when event is fired on instance. Class callbacks will be called on class and also on instance
+  # callbacks.
+  #    my_object=MyClass.new
+  #    MyClass.before_save do
+  #      puts "class callback"
+  #    end
+  #    my_object.before_save do
+  #      puts "instance callback"
+  #    end
+  #    
+  #    MyClass.fire(:before_save) #=> 
+  #      class_callback
+  #    
+  #    my_object.fire(:before_save) #=>
+  #      class_callback
+  #      instance_callback
+  #   # As you can see, first class callbacks is called and after that instance callbacks.
+  #
+  # ==Firing events
+  # To execute callbacks, events should be called on object. Event names is same hooks names. #fire can be called
+  # on class or on instance. Also it is possible to pass block to fire event, that will replace callback block
+  # or if #let_content is called than it will work like wrapper, like this
+  #    # this is continuation of previous code
+  #    MyClass.fire(:before_save) do
+  #      puts "replaced text"
+  #    end
+  #    # will produce #=> replaced text
+  #    
+  #    MyClass.fire(:before_save) do
+  #      puts "before callback"
+  #      let_content
+  #      puts "after callback"
+  #    end
+  #    # this will produce #=>
+  #    #  before callback
+  #    #  class callback
+  #    #  after callback
+  # ==Named hooks
+  # See Lolita::Hooks::NamedHook for details.
+  module Hooks
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.extend(CommonMethods)
+      base.class_eval{
+        include CommonMethods
+        include InstanceMethods
+      }
+    end
+
+    # Look for named hook with singular or plural name of method.
+    def self.method_missing method_name,*args, &block
+      if named_hook=(Lolita::Hooks::NamedHook.by_name(method_name))
+        named_hook[:_class]
+      else 
+        super
+      end
+    end
+
+    # Shared methods between class and instance.
+    module CommonMethods
+      
+      # All callbacks for class or instance.
+      def callbacks
+        var=self.instance_variable_get(:@callbacks)
+        unless var
+          var={}
+          self.instance_variable_set(:@callbacks,var)
+        end
+        instance_variable_get(:@callbacks)
+      end
+    end
+
+    module ClassMethods
+
+      # Setter for #hook_scope.
+      def hooks_scope=(object)
+        @hooks_scope=object
+      end
+
+      # Hooks scope is used to execute callbacks. By default it is class itself.
+      def hooks_scope
+        @hooks_scope||self
+      end
+
+      # Setter for #callback_content
+      def given_callback_content=(content)
+        @given_callback_content=content
+      end
+
+      # Callback content is used to let callback content executed insede of fire block.
+      def given_callback_content
+        @given_callback_content
+      end
+
+      # All hooks for class. This is Array of hook names.
+      def hooks
+        @hooks||=[]
+        @hooks
+      end
+
+      # Reset all hooks and callbacks to defaults.
+      def clear_hooks
+        @hooks=[]
+        @callbacks={}
+      end
+
+      # This method is used to add hooks for class. It accept one or more hook names.
+      # ====Example
+      #     add_hook :before_save
+      #     MyClass.add_hooks :after_save, :around_save
+      def add_hook(*names) 
+        (names||[]).each{|hook_name|
+          self.class_eval <<-HOOK,__FILE__,__LINE__+1
+            def self.#{hook_name}(*methods,&block)
+              options=methods.extract_options!
+              in_hooks_scope(options[:scope]) do
+                register_callback(:"#{hook_name}",*methods,&block)
+              end
+            end
+
+            def #{hook_name}(*method,&block)
+              self.class.#{hook_name}(*method,:scope=>self,&block)
+            end
+          HOOK
+          register_hook(hook_name)
+        }
+      end
+
+      # Fire is used to execute callback. Method accept one or more <i>hook_names</i> and optional block.
+      # It will raise error if hook don't exist for this class. Also it accept <em>:scope</em> options, that
+      # is used to #get_callbacks and #run_callbacks.
+      # ====Example
+      #     MyClass.fire(:before_save,:after_save,:scope=>MyClass.new)
+      #     # this will call callbacks in MyClass instance scope, that means that self will be MyClass instance.
+      def fire(*hook_names,&block)
+        options=hook_names.extract_options!
+        (hook_names || []).each do |hook_name|
+          raise Lolita::HookNotFound, "Hook #{hook_name} is not defined for #{self}." unless self.has_hook?(hook_name)
+          in_hooks_scope(options[:scope]) do
+            callback=get_callback(hook_name)
+            run_callback(callback,&block)
+          end
+        end
+      end
+
+      # Is hook with <em>name</em> is defined for class.
+      def has_hook?(name)
+        self.hooks.include?(name.to_sym)
+      end
+
+      # Try to recognize named fire methods like 
+      #    MyClass.fire_after_save # will call MyClass.fire(:after_save) 
+      def method_missing(*args, &block)
+        unless self.recognize_hook_methods(*args,&block)
+          super
+        end
+      end
+
+      # Call callback block inside of fire block.
+      # ====Example
+      #     MyClass.fire(:before_save) do 
+      #        do_stuff
+      #        let_content # execute callback block(-s) in same scope as fire is executed.
+      #     end
+      def let_content
+        if content=self.given_callback_content
+          run_block(self.given_callback_content)
+        end
+      end
+
+      # Set #method_missing
+      def recognize_hook_methods method_name, *args, &block
+        if method_name.to_s.match(/^fire_(\w+)/)
+          self.fire($1,&block)
+          true
+        end
+      end
+
+      protected
+
+      # Switch between self and given <em>scope</em>. Block will be executed with <em>scope</em>.
+      # And after that it will switch back to self.
+      def in_hooks_scope(scope)
+        begin
+          self.hooks_scope=scope||self
+          yield
+        ensure
+          self.hooks_scope=self
+        end
+      end
+
+      # Run callback. Each callback is Hash with <i>:methods</i> Array and </i>:blocks</i> Array
+      def run_callback(callback,&block)
+        run_methods(callback[:methods],&block)
+        run_blocks(callback[:blocks],&block)
+      end
+
+      # Run methods from <em>methods</em> Array
+      def run_methods methods, &block
+        (methods||[]).each do |method_name|
+          hooks_scope.__send__(method_name,&block)
+        end
+      end
+
+      # Run blocks from <em>blocks</em> Array. Also it set #given_callback_content if block is given, this
+      # will allow to call #let_content. Each block is runned with #run_block.
+      def run_blocks blocks,&given_block
+        (blocks||[]).each do |block|
+          begin
+            if block_given?
+              self.given_callback_content=given_block
+            end
+            run_block(block,&given_block)
+          ensure
+            self.given_callback_content=nil
+          end
+        end
+      end
+
+      # Run block in scope. 
+      def run_block block, &given_block
+        hooks_scope.instance_eval(&block)
+      end
+
+      # Return all callbacks
+      # If scope is not class then it merge class callbacks with scope callbacks. That means that
+      # class callbacks always will be called before scope callbacks.
+      def get_callback(name)
+        scope_callbacks=hooks_scope.callbacks[name.to_sym] || {}
+        unless hooks_scope==self
+          class_callbacks=self.callbacks[name.to_sym] || {}
+          [:methods,:blocks].each do |attr|
+            scope_callbacks[attr]=((class_callbacks[attr] || [])+(scope_callbacks[attr] || [])).uniq
+          end
+        end
+        scope_callbacks
+      end
+
+      # Register callback with given scope.
+      def register_callback(name,*methods,&block)
+        temp_callback=hooks_scope.callbacks[name]||{}
+        temp_callback[:methods]||=[]
+        temp_callback[:methods]+=(methods||[]).compact
+        temp_callback[:blocks]||=[]
+        temp_callback[:blocks]<< block if block_given?
+        hooks_scope.callbacks[name]=temp_callback
+      end
+
+      # Register hook for scope.
+      def register_hook(name)
+        self.hooks<<name
+      end
+    end
+
+    # Methods for instance.
+    module InstanceMethods
+
+      # See Lolita::Hooks::ClassMethods#fire
+      def fire(*hook_names)
+        self.class.fire(*hook_names,:scope=>self)
+      end
+
+      # See Lolita::Hooks::ClassMethods#let_content
+      def let_content
+        self.class.let_content
+      end
+
+      # See Lolita::Hooks::ClassMethods#method_missing
+      def method_missing(*args,&block)
+        unless self.class.recognize_hook_methods(*args,&block)
+          super
+        end
+      end
+    end
+
+  end
+end