lolita 3.0.3

data/lib/lolita/configuration/tabs.rb

@@ -0,0 +1,120 @@
+module Lolita
+  module Configuration
+    class Tabs
+      include Enumerable
+      include Lolita::ObservedArray
+      include Lolita::Builder
+
+      attr_reader :dbi,:excluded
+      def initialize dbi,*args,&block
+        @dbi=dbi
+        @tabs=[]
+        @excluded=[]
+        self.set_attributes(*args)
+        self.instance_eval(&block) if block_given?
+      end
+
+      def each
+        if @tabs.empty?
+          create_content_tab
+        end
+        
+        @tabs.each{|tab|
+          yield tab
+        }
+      end
+
+      def tabs=(values)
+        if values.is_a?(Array)
+          values.each{|tab|
+            self<<tab
+          }
+        else
+          raise ArgumentError, "Tabs must be specified as Array."
+        end
+      end
+
+      def tab *args,&block
+        self<<Lolita::Configuration::Tab.new(@dbi,*args,&block)
+      end
+
+      def exclude=(values)
+        exclude(values)
+      end
+
+      def default=(values)
+        default(values)
+      end
+      
+      def default *args
+        tab_types=if args
+          args
+        else
+          default_tab_types
+        end
+        tab_types.each{|type|
+          self<<Lolita::Configuration::Tab.new(@dbi,type.to_sym)
+        }
+      end
+
+      def exclude *args
+        @excluded=if args && args.include?(:all)
+          default_tab_types
+        else
+          args
+        end
+      end
+
+      def names
+        @tabs.map(&:name)
+      end
+      
+      def set_attributes *args
+        if args
+          attributes=args.extract_options!
+          attributes.each{|attribute,values|
+            self.send(:"#{attribute}=",values)
+          }
+        end
+      end
+      private
+
+      def create_content_tab
+        tab(:content)
+      end
+      
+      def validate_type(tab)
+        if tab && tab.type!=:default
+          if @tabs.detect{|c_tab| c_tab.type==tab.type}
+            raise Lolita::SameTabTypeError, "Same type tabs was detected (#{tab.type})."
+          end
+        end
+      end
+      
+      def default_tab_types
+        Lolita::Configuration::Tab.default_types
+      end
+
+      def set_tab_attributes(tab)
+        if tab
+          tab.name="tab_#{@tabs.size}" unless tab.name
+        end
+      end
+
+      def collection_variable
+        @tabs
+      end
+
+      def build_element(element,&block)
+        current_tab=if element.is_a?(Hash) || element.is_a?(Symbol)
+          Lolita::Configuration::Tab.new(@dbi,element,&block)
+        else
+          element
+        end
+        set_tab_attributes(current_tab)
+        validate_type(current_tab)
+        current_tab
+      end
+    end
+  end
+end

data/lib/lolita/controllers/component_helpers.rb

@@ -0,0 +1,76 @@
+module Lolita
+  module Controllers
+  	# Helper that add #render_component method. That is shortstand for render :partial for lolita
+  	# partial files. Also it provide view hooks for Lolita.
+	  # For any component there may be helper module. Modules are include in current view or 
+    # controller instance when component is rendered.
+    # All components ar placed in "app/helpers/components/[your component path]".
+    # Component should have fallowing module structure Components::[NameSpace]::[Component name]Component
+    #     Components::Lolita::ListComponent
+    # ====Example
+    #     render_component :"lolita/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.
+    # Component helpers is loaded in same order as views or controller.
+    module ComponentHelpers
+      # Render partial template.
+      # Accept:
+      # <tt>name</tt> - name for component in '/components' directory,
+      #  can be full name too.
+      #  Example 'lolita/list'
+      # <tt>state</tt> - name for partial. Example 'row'.
+      # <tt>options</tt> - any options to pass as <code>:locals</code> to partial,
+      #  also available through <code>@opts</code> variable.
+      # =====Example
+      #      render_component "lolita/list", :display
+      #      render_component "lolita/list/display"
+      def render_component *args
+        @opts=args.extract_options!
+        name=args[0]
+        state=args[1]
+        raise "Can't render component without name!" unless name
+        will_use_component name 
+        return render(:partial=>"/components/#{name}#{state ? "/#{state}" : nil}",:locals=>@opts)
+      end
+      
+      # Require component helper file and extend current instance with component helper module.
+      # ====Example
+      #     will_use_component :"lolita/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
+            end
+            class_name=component_name.to_s.camelize
+            self.extend("Components::#{class_name}Component".constantize)
+          end
+          @used_component_helpers<<component_name
+        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$/)}
+         get_path=lambda{|paths|
+          extra_path=component_name.to_s.split("/")
+          component=extra_path.pop
+          paths.each do |path|
+            new_path=File.join(path,"components",*extra_path,"#{component}_component.rb")
+               if File.exist?(new_path) 
+                 return new_path
+               end
+            end  
+          nil
+        }
+        path=get_path.call(helper_paths)
+        path
+      end
+      
+    end
+  end
+end

data/lib/lolita/controllers/internal_helpers.rb

@@ -0,0 +1,73 @@
+module Lolita
+  module Controllers
+    module InternalHelpers
+      extend ActiveSupport::Concern
+      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
+                     resource_class lolita_mapping show_response)
+        hide_action *helpers
+       
+        helper_method *helpers
+        prepend_before_filter :is_lolita_resource?
+      end
+
+      # Return instance variable named as resource
+      # For 'posts' instance variable will be @posts
+      def resource
+        instance_variable_get(:"@#{resource_name}")
+      end
+      
+      def resource_name
+        lolita_mapping.name
+      end
+      
+      def resource_class
+        lolita_mapping.to
+      end
+      
+      def lolita_mapping
+        @lolita_mapping||=request.env["lolita.mapping"]
+      end
+      
+      protected
+
+      def is_lolita_resource?
+        raise ActionController::UnknownAction unless lolita_mapping
+      end
+
+      def resource=(new_resource)
+        instance_variable_set(:"@#{resource_name}",new_resource)
+      end
+
+      def resource_attributes
+        params[resource_name] || {}
+      end
+
+      def resource_with_attributes(current_resource,attributes={})
+        attributes||=resource_attributes
+        attributes.each{|key,value|
+          current_resource.send(:"#{key}=",value)
+        }
+        current_resource
+      end
+
+      def get_resource(id=nil)
+        self.resource=resource_class.lolita.dbi.find_by_id(id||params[:id])
+      end
+
+      def build_resource(attributes=nil)
+        attributes||=resource_attributes
+        self.resource=resource_with_attributes(resource_class.new,attributes)
+      end
+
+      def build_response_for(conf_part,options={})
+        @component_options=options
+        @component_object=resource_class.lolita.send(conf_part.to_sym)
+        @component_builder=@component_object.build(@component_options)
+      end
+      
+    end
+  end
+end

data/lib/lolita/controllers/url_helpers.rb

@@ -0,0 +1,41 @@
+module Lolita
+  module Controllers
+    module UrlHelpers
+
+      protected
+
+      def lolita_resources_path(*args)
+        options=args.extract_options!
+        mapping=args[0]
+        send(lolita_resource_name(mapping,nil,true),options)
+      end
+      
+      def lolita_resource_path(*args) # TODO test
+        options=args.extract_options!
+        mapping=args[0]
+        send(lolita_resource_name(mapping),options)
+      end
+
+      def new_lolita_resource_path(*args)
+        options=args.extract_options!
+        mapping=args[0]
+        send(lolita_resource_name(mapping,:new),options)
+      end
+
+      def edit_lolita_resource_path(*args)
+        options=args.extract_options!
+        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)
+      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
+        name="#{mapping.path}_#{name}"
+        :"#{action}#{action ? "_" : ""}#{name}_path"
+      end
+    end
+  end
+end

data/lib/lolita/controllers/user_helpers.rb

@@ -0,0 +1,29 @@
+module Lolita
+  module Controllers
+    # Add method #authenticate_lolita_user!
+    # that is called before each action in Lolita controllers.
+    # 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.
+    module UserHelpers
+      extend ActiveSupport::Concern
+
+      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)
+          else
+            send(auth)
+          end
+        else
+          #TODO warning
+          true
+        end
+      end
+
+    end
+  end
+end

data/lib/lolita/dbi/base.rb

@@ -0,0 +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

data/lib/lolita/errors.rb

@@ -0,0 +1,10 @@
+module Lolita
+  class NotORMClassError < ArgumentError; end
+  class NoFieldsGivenError < ArgumentError; end
+  class SameTabTypeError < ArgumentError; end
+  class ReferenceError < ArgumentError; end
+  class FieldNameError < NoMethodError; end
+  class FieldTypeError < ArgumentError; end
+  class ModuleNotFound < ArgumentError; end
+  class NotFound < ArgumentError; end
+end

data/lib/lolita/hooks/base.rb

@@ -0,0 +1,58 @@
+module Lolita
+  module Hooks
+    class Base
+        
+      class << self
+        def get(name)
+          @collection||={}
+          @collection[name]||=self.new(name)
+          @collection[name]
+        end
+
+        def define_callback *names
+          names.each do |name|
+              self.class_eval <<-CALLBACK,__FILE__,__LINE__+1
+                def #{name}(*args,&block)
+                  @callbacks||={}
+                  @callbacs[:#{name}]||={}
+                  @callbacks[:#{name}][:methods]=args || []
+                  @callbacks[:#{name}][:block]=block if block_given?
+                end
+
+                def run_#{name} scope, &block
+                  self.run(scope,:"#{name}",&block)
+                end
+              CALLBACK
+          end
+        end
+      end
+
+      # To wrap around some content, for example, html code, 
+      # call run with block.
+      # ====Example
+      #     # in other view
+      #     Lolita::Hooks.component(:"lolita/list").replace_with do
+      #       # my new html code
+      #     end
+      #     # in view
+      #     Lolita::Hooks.component(:"lolita/list").run(self,:replace_with) do
+      #       # your old html here
+      #     end
+      #     # After this old code will be replaced with new one
+      def run scope,name, &block
+        @callbacks[name][:methods].each do |m|
+          scope.send(m)
+        end
+        if @callbacks[name][:block]
+          if block_given?
+            callback[name][:block].call()
+          else
+            scope.instance_eval(&callbacks[name][:block])
+          end
+        end
+        @callbacks[name]={}
+      end
+
+    end
+  end
+end