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

data/lib/lolita/adapter/common_helper.rb

@@ -0,0 +1,252 @@
+module Lolita
+  module Adapter
+    module CommonHelper
+
+      class Record
+        def initialize(adapter,orm_record)
+          @adapter = adapter
+          @record = orm_record
+        end
+
+        def title
+          if @record.respond_to?(:title)
+            @record.title
+          elsif @record.respond_to?(:name)
+            @record.name
+          elsif content_field = @adapter.fields.detect{|f| f.type.to_s=="string"}
+            @record.send(content_field.name)
+          else
+            "#{@record.class.lolita_model_name.human} #{@record.id}"
+          end
+        end
+      end
+
+      class PaginationBuilder
+        def initialize adapter,page,per,options
+          @adapter = adapter
+          @page = page
+          @per = per
+          @options = options || {}
+        end
+
+        def params
+          request.respond_to?(:params) && request.params || {}
+        end
+
+        def request
+          @options[:request]
+        end
+
+        def set_nested_criteria
+          nested_hsh = params[:nested]
+          if params[:nested] && !params[:nested][:association]
+            nested_hsh = nested_hsh.reject{|k,v| [:parent,:path].include?(k.to_sym)}
+            @nested_criteria = @adapter.klass.where(nested_hsh)
+          end
+        end
+
+        def set_relation
+          @relation = if params[:nested] && params[:nested][:association]
+            @adapter.find_by_id(hsh[:nested][:id]).send(hsh[:nested][:association])
+          else
+            @adapter.klass.unscoped
+          end
+        end
+
+        def set_custom_criteria
+          if @options[:pagination_method]
+            if @options[:pagination_method].respond_to?(:each)
+              @options[:pagination_method].each do |method_name|
+                @options[:previous_scope] = scope
+                if new_criteria = pagination_criteria_for_klass(method_name,@page,@per,@options)
+                  @custom_criteria = @custom_criteria ? @custom_criteria.merge(new_criteria) : new_criteria
+                end
+              end
+            else
+              @custom_criteria = pagination_scope_for_klass(@options[:pagination_method],@page,@per,@options)
+            end
+            raise ArgumentError, "Didn't generate any scope from #{@options} page:{page} per:#{@per}" unless @custom_criteria
+          end
+        end
+
+        def pagination_scope_for_klass(method_name,page,per,options)
+          if @adapter.klass.respond_to?(method_name)
+            @adapter.klass.send(method_name,page,per,options)
+          end
+        end
+
+        def create_page
+          set_nested_criteria
+          set_relation
+          set_custom_criteria
+
+          page_criteria = if @nested_criteria
+            @relation.merge(@nested_criteria)
+          else
+            @relation
+          end
+          if @custom_criteria
+            page_criteria = @custom_criteria.merge(page_criteria)
+          end
+          unless page_criteria.respond_to?(:current_page)
+            page_criteria = page_criteria.page(@page).per(@per)
+          end
+          page_criteria
+        end
+      end
+
+      def record(orm_record)
+        Record.new(self,orm_record)
+      end
+
+      # Return all association class names
+      def associations_class_names
+        self.associations.map{|name,association|
+          association.class_name
+        }
+      end
+
+      def association_by_klass(given_klass)
+        associations.select{|name,association|
+          association.klass == given_klass
+        }.values.first
+      end
+
+      def filter attributes={}
+        klass.where(attributes.reject{|k,v| v.blank? })
+      end
+
+      # Detect if class reflect on association by name
+      def reflect_on_association(name)
+        if orm_association = klass.reflect_on_association(name)
+          self.class.const_get(:Association).new(orm_association,self)
+        end
+      end
+
+      def by_id(id)
+        klass.where(klass.primary_key => id)
+      end
+
+      def find_by_id(id)
+        self.klass.unscoped.merge(by_id(id)).first
+      end
+
+      # def nested_scope_from_hash(hsh)
+      #   nested_hsh ||= (hsh[:nested] || {})
+      #   unless nested_hsh[:association]
+      #     nested_hsh = nested_hsh.reject{|k,v| [:parent,:path].include?(k.to_sym)}
+      #     criteria = klass.where(nested_hsh)
+      #     criteria
+      #   end
+      # end
+
+      # def scope_from_hash(hsh)
+      #   if hsh[:nested] && hsh[:nested][:association]
+      #     klass.find_by_id(hsh[:nested][:id]).send(hsh[:nested][:association])
+      #   end
+      # end
+
+      # This method is used to paginate, main reason is for list and for index action. 
+      # Method accepts three arguments
+      # <tt>page</tt> - page that should be shown (integer)
+      # <tt>per</tt> - how many records there should be in page
+      # <tt>options</tt> - Hash with optional information. 
+      # By default, Lolita::Configuration::List passes request, with current request information.
+      # Also it passes <i>:pagination_method</i> that is used to detect if there is special method(-s) in model
+      # that should be used for creating page.
+      def paginate(page,per,options ={})
+
+        pagination_builder = PaginationBuilder.new(self,page,per,options)
+        pagination_builder.create_page
+        
+        # criteria = options[:request].respond_to?(:params) && nested_scope_from_hash(options[:request].params) || {}
+        # scope = options[:request].respond_to?(:params) && scope_from_hash(options[:request].params) || klass.unscoped
+       
+        # if options[:pagination_method]
+        #   if options[:pagination_method].respond_to?(:each)
+        #     options[:pagination_method].each do |method_name|
+        #       options[:previous_scope] = scope
+        #       if new_criteria = pagination_criteria_for_klass(method_name,page,per,options)
+        #         criteria = criteria ? criteria.merge(new_criteria) : new_criteria
+        #       end
+        #     end
+        #   else
+        #     new_criteria = pagination_scope_for_klass(options[:pagination_method],page,per,options)
+        #     criteria = if new_criteria.respond_to?(:current_page) #already have per and page
+        #       new_criteria
+        #     else
+        #       criteria && criteria.merge(new_criteria) || new_criteria
+        #     end
+        #   end
+        #   raise ArgumentError, "Didn't generate any scope from #{options} page:{page} per:#{per}" unless criteria
+        #   criteria
+        # else
+        #   scope.merge(criteria).page(page).per(per)
+        # end
+      end
+
+     
+
+      def switch_record_state(record, state = nil)
+        set_state_for(record)
+        if state
+          record.send(:"#{state}_state!") 
+        elsif !record.have_state?
+          if record.new_record?
+            record.create_state!
+          else 
+            record.update_state!
+          end
+        end
+        record
+      end
+      
+      def set_state_for(record)
+        unless record.respond_to?(:read_state!)
+          class << record
+
+            def set_state(new_state)
+              @state_set = true
+              @state = new_state
+            end
+
+            def have_state?
+              @state_set
+            end
+
+            def read_state!
+              set_state :read
+            end
+
+            def create_state!
+              set_state :create
+            end
+
+            def update_state!
+              set_state :update
+            end
+
+            def state
+              set_state(:read) unless @state
+              @state
+            end
+
+            def in_read_state?
+              state == :read
+            end
+
+            def in_create_state?
+              state == :create
+            end
+
+            def in_update_state?
+              state == :update
+            end
+          end
+        end
+        record
+      end
+
+    end
+  end
+end

data/lib/lolita/adapter/mongoid.rb

@@ -27,6 +27,14 @@ module Lolita
           @association.foreign_key
         end
 
+        def through?
+          false
+        end
+
+        def through
+          nil
+        end
+
         def native_macro
           @association.macro
         end
@@ -53,20 +61,6 @@ module Lolita
         @associations
       end
 
-      # Return all association class names
-      def associations_class_names
-        self.associations.map{|name,association|
-          association.class_name
-        }
-      end
-
-      # Detect if class reflect on association by name
-      def reflect_on_association(name)
-        if orm_association = klass.reflect_on_association(name)
-          Association.new(orm_association,self)
-        end
-      end
-
       # Each field from ORM is changed to this class instance.
       class Field
         include Lolita::Adapter::FieldHelper
@@ -124,6 +118,8 @@ module Lolita
 
       end # end of field
 
+      include Lolita::Adapter::CommonHelper
+
       def fields
         @fields||=self.klass.fields.collect{|name,field|
           Field.new(field,self)
@@ -146,44 +142,6 @@ module Lolita
         end
       end
 
-      def find_by_id(id)
-        self.klass.unscoped.where(:_id => id).first
-      end
-
-      # This method is used to paginate, main reason is for list and for index action. 
-      # Method accepts three arguments
-      # <tt>page</tt> - page that should be shown (integer)
-      # <tt>per</tt> - how many records there should be in page
-      # <tt>options</tt> - Hash with optional information. 
-      # By default, Lolita::Configuration::List passes request, with current request information.
-      # Also it passes <i>:pagination_method</i> that is used to detect if there is special method(-s) in model
-      # that should be used for creating page.
-      def paginate(page,per,options ={})
-        scope = nil
-        if options[:pagination_method]
-          if options[:pagination_method].respond_to?(:each)
-            options[:pagination_method].each do |method_name|
-              options[:previous_scope] = scope
-              if new_scope = pagination_scope_from_klass(method_name,page,per,options)
-                scope = scope ? scope.merge(new_scope) : new_scope
-              end
-            end
-          else
-            scope = pagination_scope_from_klass(options[:pagination_method],page,per,options)
-          end
-          raise ArgumentError, "Didn't generate any scope from #{options} page:{page} per:#{per}" unless scope
-          scope
-        else
-          klass.unscoped.page(page).per(per)
-        end
-      end
-
-      def pagination_scope_from_klass(method_name,page,per,options)
-        if klass.respond_to?(method_name)
-          klass.send(method_name,page,per,options)
-        end
-      end
-
       def search(query, options = {})
         unless query.blank?
           content_fields = @dbi.fields.map{|field| 
@@ -197,9 +155,7 @@ module Lolita
             content_fields = content_fields & options[:fields]
           end
           content_fields = content_fields.slice(0..3)
-          #result = self.map_reduce_search(content_fields,query)
-          #debugger
-          #result
+       
           where_hash = {}
           content_fields.each do |field|
             where_hash[field] = /#{Regexp.escape(query.to_s)}/

data/lib/lolita/base.rb

@@ -0,0 +1,5 @@
+require 'lolita/register'
+require 'lolita/lazy_loader'
+require 'lolita/observed_array'
+require 'lolita/builder'
+require 'lolita/controller_additions'

data/lib/lolita/builder.rb

@@ -143,7 +143,7 @@ module Lolita
       end
 
       def compare(pattern,predicate)
-        result = true
+        result = pattern.has_key?(:name) ? true : pattern[:name].to_s == build_attributes[:name].to_s
         pattern.each do |key,value|
           result &&= ((value.to_sym == self.send(key)) == predicate)
         end
@@ -217,11 +217,11 @@ module Lolita
 
     def build *values
       result = builder.with(*values).build
-      result[result.size-1].merge!(default_options)
+      result[result.size-1].merge!(builder_default_options)
       result
     end
 
-    def default_options
+    def builder_default_options
       {builder_local_variable_name => self}
     end
 

data/lib/lolita/components/base.rb

@@ -0,0 +1,12 @@
+module Lolita
+  module Components
+    
+    class Base
+      attr_reader :parent
+      def initialize(parent)
+        @parent = parent
+      end
+    end
+
+  end
+end

data/lib/lolita/components/configuration/column_component.rb

@@ -0,0 +1,31 @@
+module Lolita
+  module Components
+    module Configuration
+
+# Should include routes helper and lolita urls helpers
+# - nested_list_options = column.list && {}  || {}
+# - content_text = column.formatted_value(record,self)
+# %td{{:class => column.list && "with-nested-list"}.merge(nested_list_options)}= column.list ? link_to(content_text,"#") : content_text
+
+      class ColumnComponent < Lolita::Components::Base
+
+        def td_attributes(record)
+          {
+            :class => parent.list && "with-nested-list"
+          }.merge(nested_list_options(record))
+        end
+
+        def td_value(record,view)
+          column.formatted_value(record)
+        end
+
+        def nested_list_options parent
+          parent.list && {
+            :"data-nested-list-url" => lolita_resources_path(column.list.mapping, column.list.nested_options_for(record))
+          }
+        end
+      end
+
+    end
+  end
+end

data/lib/lolita/components/configuration/list_component.rb

@@ -0,0 +1,11 @@
+module Lolita
+  module Components
+    module Configuration
+      
+      class ListComponent
+
+      end
+
+    end
+  end
+end

data/lib/lolita/configuration.rb

@@ -0,0 +1,61 @@
+module Lolita
+   # All classes that want to use lolita for configuration should include this module.
+  module Configuration
+    # When Lolita::Configuration is included, it add hook for class <em>:after_lolita_loaded</em> and define class methods
+    # <em>lolita</em> and <em>lolita=</em> and instance method <em>lolita</em> that refers to class method with same name.
+    def self.included(base)
+      base.class_eval do
+        include Lolita::Hooks
+        add_hook :after_lolita_loaded
+
+        extend ClassMethods
+        def lolita
+          self.class.lolita
+        end
+      end
+    end
+
+    module ClassMethods
+      # This is main method for configuration, it initialize new Lolita::Configuration::Core object, that have other methost to 
+      # define different parts of configuration.
+      def lolita(&block)
+        Lolita::LazyLoader.lazy_load(self,:@lolita,Lolita::Configuration::Core,self,&block)
+      end
+      
+      def lolita=(value)
+        if value.is_a?(Lolita::Configuration::Core) || value.nil?
+          @lolita = value
+        else
+          raise ArgumentError.new("Only Lolita::Configuration::Core is acceptable.")
+        end
+      end
+    end
+  end
+end
+
+require 'lolita/configuration/base'
+require 'lolita/configuration/core'
+require 'lolita/configuration/list'
+require 'lolita/configuration/nested_list'
+require 'lolita/configuration/tabs'
+require 'lolita/configuration/tab'
+require 'lolita/configuration/columns'
+require 'lolita/configuration/column'
+require 'lolita/configuration/fields'
+require 'lolita/configuration/field'
+require 'lolita/configuration/field_set'
+require 'lolita/configuration/nested_form'
+require 'lolita/configuration/search'
+require 'lolita/configuration/filter'
+require 'lolita/configuration/action'
+
+require 'lolita/configuration/factory/field'
+require 'lolita/configuration/factory/tab'
+
+# Configuration for fields and tabs
+["field","tab"].each do |type|
+  Dir["#{File.dirname(__FILE__)}/configuration/#{type}/**/*.*"].each do |path|
+    base_name=File.basename(path,".rb")
+    require "lolita/configuration/#{type}/#{base_name}"
+  end
+end