lolita 3.2.0.rc.7 → 3.2.0.rc.9

data/lib/lolita/extensions/authorization/cancan_adapter.rb

@@ -0,0 +1,45 @@
+module Lolita
+  module Extensions
+    module Authorization
+      
+      class CanCanAdapter
+        
+        def initialize context, options={}
+          raise NameError, "CanCan is not defined" unless defined?(CanCan)
+          raise Lolita::NoAuthorizationDefinedError, "Lolita.authorization is not defined" unless Lolita.authorization
+          @context = context
+          @options = options
+          set_default_options
+          current_ability
+        end
+
+        def can? *args
+          current_ability.can?(*args)
+        end
+
+        def cannot? *args
+          current_ability.cannot?(*args)
+        end
+
+        def current_ability *args
+          unless @current_ability 
+            @current_ability = Lolita.ability_class.new(@options[:current_user])
+            @context && @context.instance_variable_set(:"@current_ability",@current_ability)
+          end
+          @current_ability
+        end
+
+        def authorize! *args
+          current_ability && @context && @context.authorize!(*args) || current_ability.authorize!(*args)
+        end
+        
+        private
+
+        def set_default_options
+          @options[:current_user] ||= @context && @context.authentication_proxy.current_user
+        end
+      end
+
+    end
+  end
+end

data/lib/lolita/extensions/authorization/default_adapter.rb

@@ -0,0 +1,29 @@
+module Lolita
+  module Extensions
+    module Authorization
+      
+      class DefaultAdapter
+        
+        def initialize *args
+        end
+        
+        def can? *args
+          true
+        end
+
+        def cannot? *args
+          false
+        end
+
+        def current_ability *args
+        end
+
+        def authorize! *args
+          true
+        end
+
+      end
+
+    end
+  end
+end

data/lib/lolita/extensions/authorization/proxy.rb

@@ -0,0 +1,48 @@
+require "#{File.dirname(__FILE__)}/default_adapter"
+require "#{File.dirname(__FILE__)}/cancan_adapter"
+
+module Lolita
+  class NoAuthorizationDefinedError < ArgumentError ; end
+  
+  module Extensions
+    module Authorization
+
+      class Proxy
+        attr_accessor :adapter
+
+        def initialize context,options={}
+          @context = context
+          @options = options
+          @adapter = get_adapter()
+        end
+
+        def can? *args
+          @adapter.can? *args
+        end
+
+        def cannot? *args
+          @adapter.cannot? *args
+        end
+
+        def authorize! *args
+          @adapter.authorize! *args
+        end
+
+        def current_ability *args
+          @adapter.current_ability *args
+        end
+        
+        private
+
+        def get_adapter
+          if Lolita.authorization
+            "Lolita::Extensions::Authorization::#{Lolita.authorization}Adapter".constantize.new @context, @options
+          else
+            Lolita::Extensions::Authorization::DefaultAdapter.new @context, @options
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/lolita/extensions/extensions.rb

@@ -0,0 +1,66 @@
+module Lolita
+  # This module provides functionality for extension machinery in Lolita. It loads proxies on demand.
+  module Extensions
+    EXTENSIONS = []
+    
+    def method_missing method_name, *args, &block
+      if method_name[/_proxy$/]
+        type = method_name.to_s.sub(/_proxy$/,"")
+        self.class_eval <<-EXTENSION,__FILE__,__LINE__+1
+          def #{method_name}(*args,&block)
+            unless __extensions_proxies[:#{type}]
+              load_extension_proxy(:#{type},self,__proxy_options_from_context)
+            end
+            __extensions_proxies[:#{type}]
+          end
+        EXTENSION
+        send(method_name)
+      else
+        super
+      end
+    end
+
+    def load_extensions_proxies(context=self, options={})
+      EXTENSIONS.each do |type|
+        load_extension_proxy(type,context,options)
+      end
+    end
+    
+    def load_extension_proxy type,context=self,options={}
+      proxy_class = "Lolita::Extensions::#{type.to_s.camelize}::Proxy".constantize
+      initialize_arity = proxy_class.instance_method(:initialize).arity
+      __extensions_proxies[type] = if initialize_arity < 0 || initialize_arity > 1
+        proxy_class.new(context,options)
+      elsif initialize_arity == 0
+        proxy_class.new
+      else
+        proxy_class.new(context)
+      end
+    end
+
+    def self.add type
+      EXTENSIONS << type unless EXTENSIONS.include?(type)
+    end
+
+    private
+
+    def __proxy_options_from_context
+      if defined?(::ActionController::Base) && self.is_a?(::ActionController::Base)
+        {:controller => self, :request => request}
+      elsif defined?(::ActionView::Base) && self.is_a?(::ActionView::Base)
+        {:request => request}
+      end
+    end
+
+    def __extensions_proxies 
+      @proxies ||= {}
+    end
+
+  end
+end
+
+Lolita::Extensions.add :authentication
+Lolita::Extensions.add :authorization
+
+require 'lolita/extensions/authorization/proxy'
+require 'lolita/extensions/authentication/proxy'

data/lib/lolita/helpers.rb

@@ -0,0 +1,12 @@
+module Lolita
+  module Helpers
+
+    def self.included(base)
+      base.class_eval do 
+        include Lolita::Extensions
+        include Lolita::Controllers::ComponentHelpers
+        include Lolita::Controllers::AuthenticationHelpers
+      end
+    end
+  end
+end

data/lib/lolita/lazy_loader.rb

@@ -4,19 +4,23 @@ module Lolita
     #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)
-      unless temp_var
-        temp_var=instance_name.instance_variable_set(var_name,self.new(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.class_instance
-        instance_name.instance_variable_set(var_name,temp_var.class_instance)
-      else
-        temp_var
+      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
+      @args = args || []
       @lazy_class=lazy_class
       @eval_block=block
     end
@@ -27,6 +31,7 @@ module Lolita
 
     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)
@@ -37,13 +42,13 @@ module Lolita
         end
       end
       if @class_instance.respond_to?(:after_initialize,true)
-        @class_instance.send(:after_initialize)
+        @class_instance.__send__(:after_initialize)
       end
       @class_instance.__send__(method_name,*args,&block)
     end
 
     instance_methods.each { |method|
-      next if ["hash","respond_to?","__id__","__send__","to_s","object_id","method_missing","class_instance","initialize"].include?(method.to_s)
+      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

data/lib/lolita/mapping.rb

@@ -17,33 +17,39 @@ 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,:controllers,:as
-    attr_reader :visible, :only, :append_to
+    attr_reader :class_name,:path,:singular,:plural,:path_prefix,:module,:as,:controllers
+    attr_reader :visible, :only, :append_to, :title
     alias :name :singular
     
     
     def initialize(name,options={})
       # TODO how it is when lolita plugin extend default path and there is module is this not break the logic?
-      @as=options[:as]
-      @visible = options.keys.include?(:visible) ? options[:visible] : true
-      @append_to = options[:append_to]
-      @only = options[:only] || nil
-      @plural=(options[:as] ? options[:as] : name).to_sym
-      @singular=(options[:singular] || @plural.to_s.singularize).to_sym
-      @class_name=(options[:class_name] || name.to_s.classify).to_s
-      @ref = @class_name.to_s.camelize
-      @path_prefix=options[:path_prefix]
-      @path=(options[:path] || "lolita").to_s
-      @module=options[:module] 
-      mod=@module ? nil :  "lolita/"
-      @controllers=Hash.new{|h,k|
-        h[k]=options[:controller] || "#{mod}#{k}" 
+      @as           = options[:as]
+      @title        = options[:title]
+      @to           = options[:to].is_a?(String) ? options[:to].constantize : options[:to]
+      @visible      = options.keys.include?(:visible) ? options[:visible] : true
+      @append_to    = options[:append_to]
+      @only         = options[:only] || nil
+      @plural       = (options[:as] ? options[:as] : name).to_sym
+      @singular     = (options[:singular] || @plural.to_s.singularize).to_sym
+      @class_name   = (options[:class_name] || name.to_s.classify).to_s
+      @ref          = @class_name.to_s.camelize
+      @path_prefix  = options[:path_prefix]
+      @path         = (options[:path] || "lolita").to_s
+      @module       = options[:module] 
+      @default_mod  = @module || "lolita"
+      @controllers  = Hash.new{|h,k|
+        h[k]=options[:controller] || "#{!@module && "lolita/"}#{k}" 
       }
     end
   
+    def controller
+      "#{@default_mod}#{@default_mod && "/"}#{@plural}"
+    end
+
     # Return class that is related with mapping.
     def to
-      @ref.constantize
+      @to || (@ref.constantize rescue nil)
     end
     
     # full path of current mapping
@@ -56,7 +62,7 @@ module Lolita
     end
 
     def add_to_navigation_tree
-      tree = Lolita::Navigation::Tree[:"left_side_navigation"]
+      tree = Lolita.navigation
       if self.visible
         if self.append_to
           parent_branch = tree.branches.detect{|b| b.options[:system_name] == self.append_to}
@@ -69,7 +75,7 @@ module Lolita
           tree = parent_branch.children
         end
         unless tree.branches.detect{|b| b.object.is_a?(Lolita::Mapping) && b.object.to==self.to}
-          tree.append(self)
+          tree.append(self, :title => @title)
         end
       end
     end

data/lib/lolita/navigation/branch.rb

@@ -26,7 +26,9 @@ module Lolita
         if @title && @title.respond_to?(:call)
           @title.call(self)
         else
-          @title || self.object.to.model_name.human(:count=>2)
+          @title || 
+          (self.object.to && (self.object.to.lolita_model_name.human(:count=>2)) || self.object.to.to_s) ||
+          ::I18n.t("lolita.navigation.#{object.name}")
         end
       end
 
@@ -63,6 +65,31 @@ module Lolita
         self.children.branches.any?
       end
 
+      def populate_url(view)
+        self.options[:url] = calculate_url(view)
+      end
+
+      def calculate_url(view)
+        if self.options[:url].respond_to?(:call)
+          self.options[:url].call(view,self)
+        elsif self.options[:url]
+          self.options[:url]
+        elsif self.object.is_a?(Lolita::Mapping)
+          view.send(:lolita_resources_path, self.object) 
+        else
+          self.first_url_in_subtree(view)
+        end
+      end
+
+      def first_url_in_subtree(view)
+        if self.subtree?
+          subtree_branch = self.children.branches.detect{|branch|
+            branch.visible?(view)
+          }
+          subtree_branch.calculate_url(view) if subtree_branch
+        end
+      end
+
       def siblings
         index=self.index
         {
@@ -102,7 +129,7 @@ module Lolita
 
       def visible?(view)
         self_visible = if self.object && self.object.respond_to?(:to)
-          view.send(:can?,:read,self.object.to)
+          view.send(:authorization_proxy).send(:can?,:read,self.object.to)
         elsif self.options[:visible]
           if self.options[:visible].respond_to?(:call)
             self.options[:visible].call(view,self,branch)

data/lib/lolita/navigation/tree.rb

@@ -51,6 +51,12 @@ module Lolita
         }.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

data/lib/lolita/observed_array.rb

@@ -33,6 +33,7 @@ module Lolita
   module ObservedArray
 
     def method_missing(method,*args,&block)
+      generate_collection_elements! if self.respond_to?(:generate_collection_elements!)
       collection_variable.__send__(method,*args,&block)
     end
     
@@ -61,7 +62,6 @@ module Lolita
       collection_variable.each{|collection_element| yield collection_element}
     end
 
-
     private
 
     def collection_variable

data/lib/lolita/orm.rb

@@ -0,0 +1,7 @@
+require 'lolita/adapter/field_helper'
+require 'lolita/adapter/common_helper'
+require 'lolita/adapter/abstract_adapter'
+require 'lolita/adapter/active_record'
+require 'lolita/adapter/mongoid'
+
+require 'lolita/dbi/base'

data/lib/lolita/processors/request_processor.rb

@@ -0,0 +1,38 @@
+module Lolita
+  module Processors
+    class RequestProcessor
+
+      attr_accessor :scope
+
+      def self.respond_to(mapping,scope,action) 
+        action_processor = "Lolita::Processors::RequestProcessor::#{action.to_s.camelize}ActionProcessor".constantize.new(mapping,scope)
+        action_processor.respond
+      end
+
+      def initialize(mapping,scope)
+        @mapping = mapping
+        @scope = scope
+      end
+
+      def resource_class
+        @scope.resource_class
+      end
+
+      class IndexActionProcessor < self
+
+        def respond
+          build_response = resource_class.lolita.list.build(:page => page)
+          scope.instance_variable_set(:"@component_builder",build_response)
+          scope.haml :"lolita/rest/index.html", :layout => :"layouts/lolita/application.html"
+        end
+
+        def page
+          resource_class.lolita.list.paginate(1)
+        end
+
+      end
+
+    end
+
+  end
+end