lolita 3.1.18 → 3.2.0.rc1

data/lib/lolita/configuration/column.rb

@@ -38,32 +38,9 @@ module Lolita
       def sortable?
         @sortable
       end
-      
-      def current_sort_state(params)
-        @sortable && sort_pairs(params).detect{|pair| pair[0]==self.name.to_s} || []
-      end
-
-      def sort_params params
-        if @sortable
-          pairs = sort_pairs(params)
-          found_pair = false
-          pairs.each_with_index{|pair,index|
-            if pair[0] == self.name.to_s
-              pairs[index][1] = pair[1] == "asc" ? "desc" : "asc"
-              found_pair = true
-            end
-          }
-          unless found_pair
-            pairs << [self.name.to_s,"asc"]
-          end
-          (pairs.map{|pair| pair.join(",")}).join("|")
-        else
-          ""
-        end
-      end
 
-      def sort_pairs params
-        (params[:s] || "").split("|").map{|pair| pair.split(",")}
+      def currently_sorting?(params)
+        @sortable && params[:sc].to_s==self.name.to_s
       end
 
       # Define format, for details see Lolita::Support::Formatter and Lolita::Support::Formater::Rails

data/lib/lolita/configuration/factory/field.rb

@@ -16,13 +16,9 @@ module Lolita
           name = args[0] || options[:name] || (dbi_field ? dbi_field.name : nil)
           dbi_field ||= dbi.field_by_name(name)
           dbi_field ||= dbi.field_by_association(name)
-          association ||= detect_association(dbi,name)
-
-          type = args[1] || options[:type] || 
-            (association ? :array : nil ) ||
-            (dbi_field ? dbi_field.type : nil) || 
-            :string
+          type = args[1] || options[:type] || (dbi_field ? dbi_field.type : nil) || :string
           options[:dbi_field] = dbi_field
+
           if !name || !type
             raise Lolita::FieldTypeError, "type not defined. Set is as second argument or as :dbi_field where value is Adapter::[ORM]::Field object."
           else
@@ -32,10 +28,6 @@ module Lolita
 
         end
 
-        def self.detect_association(dbi,name)
-          dbi.associations[name.to_sym]
-        end
-
         def self.field_class(name)
           ("Lolita::Configuration::Field::"+name.to_s.camelize).constantize
         end

data/lib/lolita/configuration/field.rb

@@ -101,7 +101,7 @@ module Lolita
 
         def find_dbi_field
           @dbi_field ||= self.dbi.fields.detect{|field|
-            field.name.to_s == @name.to_s || (field.association && field.association.name.to_s == @name.to_s)
+            field.name.to_s == self.name.to_s || (field.association && field.association.name.to_s == self.name.to_s)
           }
         end
 
@@ -114,11 +114,6 @@ module Lolita
         def set_default_values
           self.options||={}
           self.html_options ||= {}
-          @html_options[:class] = if @html_options[:class]
-            "#{@html_options[:class]} #{self.type}"
-          else
-            self.type.to_s
-          end
         end
 
         def validate

data/lib/lolita/configuration/field/array.rb

@@ -1,48 +1,25 @@
 module Lolita
   module Configuration
     module Field
-      # Fields with Array is used to 
-      # * create select for belongs_to association or 
-      # * has_and_belongs_to_many field for selecting all associated objects or
-      # * for polymorphic belongs_to associations
-      # ==Polymorphic builder (:polymorphic)
-      # Create two select boxes one of all related classes and second with related records for that class.
-      # Related classes can have <em>polymorphic_select_name</em> instance method, that is used to populate second
-      # select with visible values by default it calles <em>text_method</em>. It will fallback first content column. Class should respond to one
-      # of these. 
+      
       class Array < Lolita::Configuration::Field::Base
         lolita_accessor :conditions,:text_method,:value_method,:find_options,:association,:include_blank
-        lolita_accessor :related_classes
 
         def initialize dbi,name,*args, &block
+          self.builder="select"
           @include_blank=true
           super
           self.find_dbi_field unless self.dbi_field
-          
-          @association ||= self.dbi_field ? self.dbi_field.association : detect_association
-          self.builder = detect_builder unless @builder
-          self.name = recognize_real_name
+          @association = self.dbi_field ? self.dbi_field.association : nil
         end
 
-        # For details see Lolita::Configuration::Search
-        def search *args, &block
-          if (args && args.any?) || block_given?
-            @search = create_search(*args,&block)
-          end
-          @search
-        end
-
-        def create_search *args, &block
-          Lolita::Configuration::Search.new(Lolita::DBI::Base.create(@association.klass),*args,&block)
-        end
-
-        def values=(value=nil)
-          @values=value
+        def options_for_select=(value=nil)
+          @options_for_select=value
         end
 
-        def values value=nil, &block
-          @values=value || block if value || block_given?
-          @values
+        def options_for_select value=nil, &block
+          @options_for_select=value || block if value || block_given?
+          @options_for_select
         end
 
         # Collect values for array type field.
@@ -51,120 +28,50 @@ module Lolita
         # by default it it is <code>id</code>. Use <code>conditions</code> or
         # <code>find_options</code> for advanced search. When <code>find_options</code>
         # is used, than <code>conditions</code> is ignored.
-        def association_values(record = nil) #TODO test
-          @association_values=if values
-            values
-          elsif search
-            search.run("")
-          elsif @association && @association.polymorphic?
-            polymorphic_association_values(record)
+        def association_values() #TODO test
+          @association_values=if options_for_select
+            options_for_select
           elsif @association
             klass=@association.klass
+            current_text_method=@text_method || default_text_method(klass)
+            current_value_method=@value_method || :id
             options=@find_options || {}
             options[:conditions]||=@conditions
-            options_array(klass.find(:all,options))
-          else
-            []
-          end
-          @association_values
-        end
 
-        # Collect values for polymorphic association, you may pass 
-        # * <tt>:klass</tt> - class that's records are used
-        # * <tt>:record</tt> - record class that has polymorphic association. It is used to call to detect related object class.
-        def polymorphic_association_values(options={})
-          options ||= {}
-          options[:klass] ||= options[:record] && options[:record].send(self.name) ? options[:record].send(self.name).class : nil
-          if options[:klass]
-            options_array(options[:klass].all)
+            klass.find(:all,options).map{|r|
+              [r.send(current_text_method),r.send(current_value_method)]
+            }
           else
             []
           end
-        end
-
-        def options_array(collection)
-          klass = collection.last ? collection.last.class : nil
-          collection.map{|r|
-            [r.send(current_text_method(klass)),r.send(current_value_method)]
-          }
-        end
-
-        def current_text_method(klass)
-          @text_method || default_text_method(klass)
-        end
-
-        def current_value_method
-          @value_method || :id
+          @association_values
         end
 
         # used in views for shorter accessing to values
         def view_values(view)
-          record = view.send(:tab_form).object
-          values = association_values(record)
+          values = association_values
           if values.respond_to?(:call)
             values.call(view)
           else
-            association_values(record)
+            association_values
           end
         end
 
-        def detect_builder
-          if @association
-            if @association.polymorphic?
-              "polymorphic"
-            elsif @association.macro == :many_to_many
-              "autocomplete"
-            else
-              "select"
-            end
-          else
-            "select"
-          end
-        end
+      private
 
-        def detect_association
-          unless @association
-            dbi.associations[self.name.to_sym]
-          else
-            @association
-          end
-        end
-
-        def polymorphic_classes
-          if @related_classes
-            @related_classes.map do |klass|
-              [klass.constantize.model_name.human, klass.to_s]
-            end
-          end
-        end
-
-        def recognize_real_name
-          if @association && !@association.polymorphic? && @association.macro == :one
-            self.name = @association.key
-          else
-            @name
-          end
-        end
-
-        private
-
-        def default_text_method(klass)
-          assoc_dbi=Lolita::DBI::Base.create(klass) rescue nil
-          if assoc_dbi
-            field=assoc_dbi.fields.detect{|f| f.type.to_s=="string"}
-            if field
-              field.name
-            else
-              raise Lolita::FieldTypeError, %^
-              Can't find any content field in #{assoc_dbi.klass}.
-              Use text_method in #{klass} to set one.
-              ^
-            end
-          else
-            warn("Not a ORM class (#{klass.inspect})")
-          end
+      def default_text_method(klass)
+        assoc_dbi=Lolita::DBI::Base.create(klass)
+        field=assoc_dbi.fields.detect{|f| f.type.to_s=="string"}
+        if field
+          field.name
+        else
+          raise Lolita::FieldTypeError, %^
+          Can't find any content field in #{assoc_dbi.klass}.
+          Use text_method in #{klass} to set one.
+          ^
         end
       end
     end
   end
 end
+end

data/lib/lolita/configuration/field/integer.rb

@@ -3,6 +3,7 @@ module Lolita
     module Field
       class Integer< Lolita::Configuration::Field::Base
         def initialize dbi,name,*args, &block
+          
           super
         end
       end

data/lib/lolita/configuration/list.rb

@@ -18,20 +18,6 @@ module Lolita
         set_default_attributes
       end
 
-      # For details see Lolita::Configuration::Search
-      def search *args, &block
-        if (args && args.any?) || block_given?
-          @search = Lolita::Configuration::Search.new(self.dbi,*args,&block)
-        end
-        @search
-      end
-
-      # Define or return pagination method. This method is used by DBI adapters to delegate domain specific
-      # pagination back to model.
-      # ====Example
-      #   list do 
-      #     pagination_method :paginate_with_profiles
-      #   end
       def pagination_method(value = nil)
         if value
           self.pagination_method = value
@@ -43,15 +29,8 @@ module Lolita
         @pagination_method = value
       end
 
-      # Return page for list display. Method requires two arguments:
-      # * <tt>current_page</tt> - number of current page
-      # * <tt>request (optional) </tt> - request that is passed to adapter that passes this to model when #pagination_method is defined
-      def paginate(current_page, request = nil)
-        page_criteria = dbi.paginate(current_page,@per,:request => request, :pagination_method => @pagination_method)
-        if self.search
-          page_criteria = page_criteria.merge(self.search.run(request.params[:q],request))
-        end
-        page_criteria
+      def paginate(current_page, request)
+        dbi.paginate(current_page,@per,:request => request, :pagination_method => @pagination_method)
       end
 
       # Set columns. Allowed classes are Lolita::Configuration::Columns or

data/lib/lolita/configuration/tabs.rb

@@ -48,12 +48,6 @@ module Lolita
         self<<Lolita::Configuration::Factory::Tab.add(@dbi,*args,&block)
       end
 
-      def fields
-        @tabs.collect{|tab|
-          tab.fields
-        }.flatten
-      end
-
       def by_type(type)
         @tabs.detect{|tab| tab.type==type.to_sym}
       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 use_mapping 
+        helpers = %w(resource resource_name
                      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.class_name.underscore.to_sym
+        lolita_mapping.name
       end
       
       def resource_class
         lolita_mapping.to
       end
       
-      def lolita_mapping(new_mapping = nil)
+      def lolita_mapping
         @lolita_mapping||=request.env["lolita.mapping"]
       end
 
@@ -45,19 +45,6 @@ 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
 
@@ -75,7 +62,6 @@ module Lolita
 
       def is_lolita_resource?
         raise ActionController::UnknownAction unless lolita_mapping
-        true
       end
 
       def resource=(new_resource)
@@ -95,7 +81,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/user_helpers.rb

@@ -5,40 +5,28 @@ 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
-        helpers = %w(lolita_current_user)
-       
-        helper_method *helpers
+        helper LolitaHelper
       end
-
+      
       private
-
-      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
+    # 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
-            user
+            send(auth)
           end
-        end
-      end
-
-
-      def authenticate_lolita_user!
-        if auth = Lolita.authentication
-          send(auth)
         else
-          warn("There is no authentication. See initializers/lolita.rb")
+          #TODO warning
           true
         end
       end
+
     end
   end
 end