lolita 3.1.17 → 3.1.18

data/lib/lolita/configuration/search.rb

@@ -0,0 +1,91 @@
+module Lolita
+  module Configuration
+    # Proxy class for search. It supports two methods #with and #run.
+    # By default with method accepts method name or nothing and creates Lolita::Search::Simple instance
+    # that will be used to run search on current dbi. 
+    # By default search run against all content fields, but when _:fields_ options is passed it search in
+    # those fields only. 
+    # ==== Example
+    #     class Post < ActiveRecord::Base
+    #       include Lolita::Configuration
+    #       lolita do
+    #         list do
+    #           search :fields => [:name]
+    #         end
+    #       end
+    #     end
+    # #with method also accepts class or instance of some class, that will be used to run search.
+    # That class should have #run method that accepts query and request. 
+    # ====Example
+    #     class MyCustomSearch
+    #       def initialize(dbi)
+    #         @dbi = dbi
+    #       end
+    #   
+    #       def run(query,request = nil)
+    #         @dbi.klass.where(:my_field => query)
+    #       end
+    #     end
+    # Also you can put your search method in model. For more see Lolita::Search::Simple
+    # ====Example
+    #     class Post < ActiveRecord::Base
+    #       include Lolita::Configuration
+    #       lolita do
+    #         list do
+    #           search :my_custom_search
+    #         end
+    #       end
+    #       
+    #       def self.my_custom_search(query,request)
+    #         self.where(:title => query, :user_id => request.params[:user_id])
+    #       end
+    #     end    
+    class Search
+      include Lolita::Builder
+      attr_reader :dbi
+      attr_writer :with, :fields
+
+      def initialize dbi, *args, &block
+        @dbi = dbi
+        set_attributes(args ? args.extract_options! : {})
+        instance_eval(&block) if block_given?
+        @with ||= args[0]!=true && args[0] ? args[0] : nil 
+      end
+
+      def with(value = nil)
+        @with = value if value
+        if !@with || [String,Symbol].include?(@with.class)
+          @with = Lolita::Search::Simple.new(dbi,@with, :fields => @fields)
+        elsif @with.class == Class
+          initialize_arity = @with.instance_method(:initialize).arity
+          @with = if initialize_arity < 0 || initialize_arity > 1
+            @with.new(dbi,:fields => @fields)
+          else
+            @with.new(dbi)
+          end
+        end
+        @with
+      end
+
+      def run(query,request = nil)
+        if self.with.method(:run).arity < 0 || self.with.method(:run).arity > 1
+          self.with.run(query,request)
+        else
+          self.with.run(query)
+        end
+      end
+
+      private
+
+      def set_attributes options
+        if options.respond_to?(:each)
+          options.each do |method_name, value| 
+            self.send(:"#{method_name}=",value)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/lolita/configuration/tab.rb

@@ -22,7 +22,6 @@ module Lolita
         include Lolita::Builder
 
         # For different types there are different builders(cells)
-        @@default_tab_type=:default
         @@available_types=[:content]
      
         lolita_accessor :title,:name,:type
@@ -33,10 +32,11 @@ module Lolita
         # * <tt>dbi</tt> Lolita::DBI::Base object, that represents database.
         # * <tt>*args</tt> See #set_attributes, for how these args are processed.
         # * <tt>&block</tt> Block can be passed, anything in block will be evaled for current instance.
-        def initialize dbi,*args,&block
-          @fields=Lolita::Configuration::Fields.new
+        def initialize dbi,type,*args,&block
+          @fields = Lolita::Configuration::Fields.new
           @field_sets = []
           @nested_forms = []
+          @type = type
           self.dbi=dbi
           self.current_dbi=dbi
           self.set_attributes(*args)
@@ -49,7 +49,7 @@ module Lolita
         # For details how to pass args and block see Lolita::Configuration::Field.
         # Return field itself.
         def field *args, &block
-          field=Lolita::Configuration::Field.add(self.current_dbi,*args,&block)
+          field=Lolita::Configuration::Factory::Field.add(self.current_dbi,*args,&block)
           field.field_set = current_fieldset
           if self.current_dbi!=self.dbi
             field.nested_in=self.dbi
@@ -61,7 +61,7 @@ module Lolita
 
         # Return all fields in tab.
         def fields
-          @fields
+          @fields 
         end
 
         # Set all fields in tab. Accept <code>fields</code> as Array.
@@ -84,7 +84,7 @@ module Lolita
         # See Lolita::Adapter classes for use of DB field method.
         def default_fields
           self.current_dbi.fields.each{|db_field|
-            self.field(db_field) unless Lolita::Configuration::Helper.tehnical_field?(db_field,self.current_dbi)
+            self.field(:name => db_field.name, :type => db_field.type, :dbi_field => db_field) if db_field.content?
           }
         end
 
@@ -95,7 +95,7 @@ module Lolita
           nested_form = Lolita::Configuration::NestedForm.new(self,class_or_name, options)
           self.current_nested_form = nested_form
           @nested_forms << nested_form
-          self.current_dbi = Lolita::DBI::Base.new(current_class)
+          self.current_dbi = Lolita::DBI::Base.create(current_class)
           self.instance_eval(&block)
           self.current_dbi = self.dbi
           self.current_nested_form = nil
@@ -164,7 +164,6 @@ module Lolita
         def set_attributes *args
           if args
             options=args.extract_options!
-            self.type=args.first if args.first.is_a?(Symbol)
             options.each{|method,options|
               self.send(:"#{method}=",options)
             }
@@ -174,8 +173,11 @@ module Lolita
 
         private
 
+        def my_type
+          self.class.to_s.split("::").last.downcase.to_sym
+        end
+
         def set_default_attributes
-          @type=@@default_tab_type unless @type
           @name="tab_#{self.__id__}" unless @name
           @title=set_default_title unless @title
         end
@@ -204,11 +206,6 @@ module Lolita
           :tab
         end
         
-        class << self
-          def default_types
-            @@available_types
-          end
-        end
       end
     end
   end

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

@@ -3,8 +3,7 @@ module Lolita
     module Tab
     	class Content < Lolita::Configuration::Tab::Base
 
-    	  def initialize(dbi,*args,&block)
-          @type=:content
+    	  def initialize(*args,&block)
     	  	super
     	  	set_default_fields
     	  end

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

@@ -4,7 +4,6 @@ module Lolita
       class Default < Lolita::Configuration::Tab::Base
 
         def initialize *args,&block
-          self.type=:default
           super
         end
 

data/lib/lolita/configuration/tabs.rb

@@ -3,17 +3,19 @@ module Lolita
     # Lolita::Configuration::Tabs is container class that holds all
     # tabs for each lolita instance. 
     # Also it has some useful methods.
-
     class Tabs
       include Enumerable
       include Lolita::ObservedArray
       include Lolita::Builder
 
       attr_reader :dbi,:excluded
+      attr_accessor :tab_types
+
       def initialize dbi,*args,&block
         @dbi=dbi
         @tabs=[]
         @excluded=[]
+        @tab_types = [:content]
         self.set_attributes(*args)
         self.instance_eval(&block) if block_given?
       end
@@ -43,7 +45,13 @@ module Lolita
       end
 
       def tab *args,&block
-        self<<Lolita::Configuration::Tab.add(@dbi,*args,&block)
+        self<<Lolita::Configuration::Factory::Tab.add(@dbi,*args,&block)
+      end
+
+      def fields
+        @tabs.collect{|tab|
+          tab.fields
+        }.flatten
       end
 
       def by_type(type)
@@ -62,18 +70,20 @@ module Lolita
         tab_types=if args
           args
         else
-          default_tab_types
+          @tab_types
         end
         tab_types.each{|type|
-          self<<Lolita::Configuration::Tab.add(@dbi,type.to_sym)
+          self<<Lolita::Configuration::Factory::Tab.add(@dbi,type.to_sym)
         }
       end
 
       def exclude *args
         @excluded=if args && args.include?(:all)
-          default_tab_types
-        else
+          tab_types
+        elsif args.is_a?(Array)
           args
+        else
+          []
         end
       end
 
@@ -103,10 +113,6 @@ module Lolita
           end
         end
       end
-      
-      def default_tab_types
-        Lolita::Configuration::Tab::Base.default_types
-      end
 
       def set_tab_attributes(tab)
         if tab
@@ -120,7 +126,7 @@ module Lolita
 
       def build_element(element,&block)
         current_tab=if element.is_a?(Hash) || element.is_a?(Symbol)
-          Lolita::Configuration::Tab.add(@dbi,element,&block)
+          Lolita::Configuration::Factory::Tab.add(@dbi,element,&block)
         else
           element
         end

data/lib/lolita/controller_additions.rb

@@ -0,0 +1,15 @@
+module Lolita
+  # Basic module for custom Lolita controllers. Is used in Lolita::RestController.
+  module ControllerAdditions
+    
+    def self.included(base_class)
+      base_class.class_eval do 
+        include Lolita::Controllers::UserHelpers
+        include Lolita::Controllers::InternalHelpers
+        include Lolita::Controllers::AuthorizationHelpers
+        include LolitaHelper
+      end
+    end
+
+  end
+end

data/lib/lolita/controllers/authorization_helpers.rb

@@ -0,0 +1,56 @@
+module Lolita
+  module Controllers
+    # Helper and controller methods that are used to authorize access to resource. Include this when auhtorization for lolita resources are needed.
+    module AuthorizationHelpers
+
+      extend ActiveSupport::Concern
+      included do
+        helpers = %w(current_ability can? cannot? authorize!)
+       
+        helper_method *helpers
+      end
+
+      private 
+
+      # Proxy method for current_abi, it gives control back to superclass when method is called in
+      # other controller than Lolita's (it responds to #lolita_mapping) otherwise it creates or return existing ability with #lolita_current_user.
+      def current_ability
+        if self.respond_to?(:is_lolita_resource?) && self.is_lolita_resource? && lolita_current_user
+          if defined?(::CanCan)
+            @current_ability||= ::Ability.new(lolita_current_user)
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
+      def can? *args
+        if defined?(::CanCan)
+          super
+        else
+          true
+        end
+      end
+
+      def cannot? *args
+        if defined?(::CanCan)
+          super
+        else
+          true
+        end
+      end
+
+      def authorize! *args
+        
+        if defined?(::CanCan)
+          super
+        else
+          true
+        end
+      end
+
+    end
+  end
+end

data/lib/lolita/controllers/component_helpers.rb

@@ -70,7 +70,7 @@ module Lolita
       def output_with_callbacks(partial_name,name,locals)
         @component_locals ||={}
         @component_locals[name] = locals
-        
+ 
         output = Lolita::Hooks.component(name).run(:before,:run_scope => self).to_s
         block_output = Lolita::Hooks.component(name).run(:around, :run_scope => self) do
           render(:partial => partial_name,:locals=>locals)

data/lib/lolita/controllers/internal_helpers.rb

@@ -5,7 +5,7 @@ module Lolita
       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
+        helpers = %w(resource resource_name use_mapping 
                      resource_class lolita_mapping show_response tab_form tab_form=)
         hide_action *helpers
        
@@ -21,14 +21,14 @@ module Lolita
       end
       
       def resource_name
-        lolita_mapping.name
+        lolita_mapping.class_name.underscore.to_sym
       end
       
       def resource_class
         lolita_mapping.to
       end
       
-      def lolita_mapping
+      def lolita_mapping(new_mapping = nil)
         @lolita_mapping||=request.env["lolita.mapping"]
       end
 
@@ -45,6 +45,19 @@ module Lolita
         end
         @tab_form
       end
+
+      def use_mapping(new_mapping)
+        if block_given? 
+          begin
+            @old_mapping = lolita_mapping
+            @lolita_mapping = new_mapping
+            yield
+          ensure
+            @lolita_mapping = @old_mapping
+            @old_mapping = nil
+          end
+        end
+      end
       
       protected
 
@@ -62,6 +75,7 @@ module Lolita
 
       def is_lolita_resource?
         raise ActionController::UnknownAction unless lolita_mapping
+        true
       end
 
       def resource=(new_resource)
@@ -81,7 +95,7 @@ module Lolita
       end
 
       def get_resource(id=nil)
-        self.resource=resource_class.lolita.dbi.find_by_id(id||params[:id])
+        self.resource = resource_class.lolita.dbi.find_by_id(id || params[:id])
       end
 
       def build_resource(attributes=nil)

data/lib/lolita/controllers/url_helpers.rb

@@ -47,6 +47,7 @@ module Lolita
                 options = self.send(resource_type[action] || :lolita_resource_path,options)
               end
             end
+            
             url_for_without_lolita(options)
           end
           alias_method_chain :url_for, :lolita
@@ -104,7 +105,10 @@ module Lolita
         mapping=(options[:mapping]||lolita_mapping)
         name=!options[:plural] ? mapping.name : mapping.plural
         name="#{mapping.path}_#{name}"
-        :"#{options[:action]}#{options[:action] ? "_" : ""}#{name}_path"
+        addon = if mapping.plural == mapping.singular && options[:plural]
+          "_index"
+        end
+        :"#{options[:action]}#{options[:action] ? "_" : ""}#{name}#{addon}_path"
       end
     end
   end

data/lib/lolita/controllers/user_helpers.rb

@@ -5,28 +5,40 @@ module Lolita
     # 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.
+    # Include this if authentication is neccessary for controller.
     module UserHelpers
       extend ActiveSupport::Concern
       included do
-        helper LolitaHelper
+        helpers = %w(lolita_current_user)
+       
+        helper_method *helpers
       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)
+
+      def lolita_current_user
+        @lolita_current_user ||= Lolita.user_classes.inject(nil) do |user,user_class|
+          unless user
+            if self.respond_to?(:"current_#{user_class.to_s.downcase}")
+              self.send(:"current_#{user_class.to_s.downcase}")
+            else
+              false
+            end
           else
-            send(auth)
+            user
           end
+        end
+      end
+
+
+      def authenticate_lolita_user!
+        if auth = Lolita.authentication
+          send(auth)
         else
-          #TODO warning
+          warn("There is no authentication. See initializers/lolita.rb")
           true
         end
       end
-
     end
   end
 end