lolita 3.4.3 → 4.0.0

data/lib/lolita/adapter/abstract_adapter.rb

@@ -1,16 +1,17 @@
-module Lolita
-  module Adapter
-    module AbstractAdapter
-      abstract_method '',:fields,:db, :db_name,:collection,:collection_name,:collections,:collection_names
-      abstract_method '',:associations,:associations_class_names
-      abstract_method "value",:collection_name=
-      abstract_method 'page,per,options ={}',:paginate
-      abstract_method 'method_name,page,per,options', :pagination_scope_from_klass
-      abstract_method 'name',:reflect_on_association,:field_by_name,:field_by_association
-      abstract_method 'id',:find_by_id
-      abstract_method 'query', :search
-      abstract_method 'access_modes_for', :record
-      abstract_method '', :nested_attributes_options
-    end
-  end
-end
+module Lolita
+  module Adapter
+    module AbstractAdapter
+      abstract_method "", :fields,:db, :db_name, :collection, :collection_name, :collections, :collection_names
+      abstract_method "", :associations, :associations_class_names
+      abstract_method "", :order_method
+      abstract_method "value", :collection_name=
+      abstract_method "page,per,options ={}", :paginate
+      abstract_method "method_name,page,per,options", :pagination_scope_from_klass
+      abstract_method "name", :reflect_on_association, :field_by_name, :field_by_association
+      abstract_method "id", :find_by_id
+      abstract_method "query", :search
+      abstract_method "access_modes_for", :record
+      abstract_method "", :nested_attributes_options
+    end
+  end
+end

data/lib/lolita/adapter/active_record.rb

@@ -1,227 +1,229 @@
-module Lolita
-  module Adapter
-    class ActiveRecord
-
-      include Lolita::Adapter::AbstractAdapter
-
-      attr_reader :dbi, :klass
-      def initialize(dbi)
-        @dbi=dbi
-        @klass=dbi.klass
-      end
-
-      # Association adapter
-      class Association
-        attr_reader :association, :adapter
-
-        def initialize(assoc_object,adapter)
-          @association = assoc_object
-          @adapter = adapter
-        end
-
-        def method_missing(method, *args, &block)
-          @association.send(method,*args,&block)
-        end
-
-        def key # maybe this isn't neccessery any more
-          if @association.macro == :has_and_belongs_to_many || through?
-            association_key
-          else
-            @association.foreign_key
-          end
-        end
-
-        def association_key
-          @association.association_foreign_key
-        end
-
-        def foreign_key
-          @association.foreign_key
-        end
-
-        def through
-          @association.options[:through]
-        end
-
-        def through?
-          @association.options.has_key?(:through)
-        end
-
-        def polymorphic?
-          @association.options[:polymorphic]
-        end
-
-        def native_macro
-          @association.macro
-        end
-
-        def macro
-          convertator = {
-            :has_many => :many, :has_one => :one, :belongs_to => :one,
-            :has_and_belongs_to_many => :many_to_many
-          }
-          convertator[@association.macro]
-        end
-      end
-
-
-      # Return all class associations
-      def associations
-        # is caching ok?
-        unless @associations
-          @associations = {}
-          klass.reflections.each{|name,association|
-            @associations[name] = Association.new(association,self)
-          }
-        end
-        @associations
-      end
-
-      # Each field from ORM is changed to this class instance.
-      class Field
-        include Lolita::Adapter::FieldHelper
-
-        attr_reader :field, :name,:options, :type, :adapter
-        def initialize(column,adapter)
-          @field = column
-          raise ArgumentError, "Cannot initialize adapter field for nil" unless @field
-          @adapter = adapter
-          set_attributes
-        end
-
-        def association
-          if @association.nil?
-            possible_association = @adapter.associations.detect{|name,association|
-              [association.key.to_s].include?(@name.to_s)
-            }
-            @association = if possible_association
-              possible_association.last
-            else
-              false
-            end
-          end
-          @association
-        end
-
-        def key
-          @association.foreign_association_key
-        end
-
-        def method_missing(method,*args,&block)
-          @field.send(method,*args,&block)
-        end
-
-        def primary?
-          !!self.options[:primary]
-        end
-
-        def self.types
-          {
-            'decimal' => 'big_decimal',
-            'datetime' => 'date_time',
-            'text' => 'string'
-          }
-        end
-
-        private
-
-        def set_attributes
-          @name = @field.name
-          @type = type_cast(@field.type)
-          @options = {
-            :primary => @field.primary,
-            :native_type => @field.type.to_s
-          }
-        end
-
-        def type_cast type_name
-          type = self.class.types[type_name.to_s] || type_name.to_s
-          if self.association
-            type = "array"
-          end
-          type
-        end
-      end # end of field
-
-      include Lolita::Adapter::CommonHelper
-
-      def fields
-        @fields||=self.klass.columns.collect{|column|
-          Field.new(column,self)
-        }
-        @fields
-      end
-
-      def field_by_name(name)
-        self.fields.detect{|field|
-          field.name.to_s == name.to_s
-        }
-      end
-
-      def field_by_association(name)
-        possible_association = self.associations.detect{|assoc_name,association|
-          name.to_s == assoc_name.to_s
-        }
-        if possible_association
-          self.field_by_name(possible_association.last.key)
-        end
-      end
-
-      def search(query, options = {})
-        #TODO raise error or warn when there are lot of records and no index on field
-        unless query.blank?
-          resources = self.klass.arel_table
-          content_fields = @dbi.fields.map{|field| field.type!="string" ? nil : field.name.to_sym}.compact
-          if options[:fields] && options[:fields].any?
-            content_fields = content_fields & options[:fields]
-          end
-          scope = nil
-          content_fields.each_with_index do |field,index|
-            new_scope = resources[field].matches("%#{query}%")
-            unless index == 0
-              scope = scope.or(new_scope)
-            else
-              scope = new_scope
-            end
-          end
-          self.klass.where(scope)
-        else
-          self.klass.where(nil)
-        end
-      end
-
-      def db
-        self.klass.connection
-      end
-
-      def db_name
-        db.current_database
-      end
-
-      def collection
-        self.klass #FIXME not realy same as in mongoid
-      end
-
-      def collection_name
-        self.klass.table_name
-      end
-
-      def collection_name=(value)
-        self.klass.table_name = value
-      end
-
-      def collections
-        self.klass #FIXME not  realy same as in mongoid
-      end
-
-      def collection_names
-        self.klass.connection.select_all("show tables from #{db_name}").map{|r| r.values.first}
-      end
-
-      def nested_attributes_options
-        self.klass.nested_attributes_options
-      end
-
-    end
-  end
-end
+module Lolita
+  module Adapter
+    class ActiveRecord
+
+      include Lolita::Adapter::AbstractAdapter
+
+      attr_reader :dbi, :klass
+      def initialize(dbi)
+        @dbi=dbi
+        @klass=dbi.klass
+      end
+
+      # Association adapter
+      class Association
+        attr_reader :association, :adapter
+
+        def initialize(assoc_object,adapter)
+          @association = assoc_object
+          @adapter = adapter
+        end
+
+        def method_missing(method, *args, &block)
+          @association.send(method,*args,&block)
+        end
+
+        def key # maybe this isn't neccessery any more
+          if @association.macro == :has_and_belongs_to_many || through?
+            association_key
+          else
+            @association.foreign_key
+          end
+        end
+
+        def association_key
+          @association.association_foreign_key
+        end
+
+        def foreign_key
+          @association.foreign_key
+        end
+
+        def through
+          @association.options[:through]
+        end
+
+        def through?
+          @association.options.has_key?(:through)
+        end
+
+        def polymorphic?
+          @association.options[:polymorphic]
+        end
+
+        def native_macro
+          @association.macro
+        end
+
+        def macro
+          convertator = {
+            :has_many => :many, :has_one => :one, :belongs_to => :one,
+            :has_and_belongs_to_many => :many_to_many
+          }
+          convertator[@association.macro]
+        end
+      end
+
+      # Return all class associations
+      def associations
+        # is caching ok?
+        unless @associations
+          @associations = {}
+          klass.reflections.each{|name,association|
+            @associations[name] = Association.new(association,self)
+          }
+        end
+        @associations
+      end
+
+      # Each field from ORM is changed to this class instance.
+      class Field
+        include Lolita::Adapter::FieldHelper
+
+        attr_reader :field, :name, :options, :type, :adapter
+        def initialize(column,adapter)
+          @field = column
+          raise ArgumentError, "Cannot initialize adapter field for nil" unless @field
+          @adapter = adapter
+          set_attributes
+        end
+
+        def association
+          if @association.nil?
+            possible_association = @adapter.associations.detect{|name,association|
+              [association.key.to_s].include?(@name.to_s)
+            }
+            @association = if possible_association
+              possible_association.last
+            else
+              false
+            end
+          end
+          @association
+        end
+
+        def key
+          @association.foreign_association_key
+        end
+
+        def method_missing(method,*args,&block)
+          @field.send(method,*args,&block)
+        end
+
+        def primary?
+          !!self.options[:primary]
+        end
+
+        def self.types
+          {
+            'decimal' => 'big_decimal',
+            'datetime' => 'date_time',
+            'text' => 'string'
+          }
+        end
+
+        private
+
+        def set_attributes
+          @name = @field.name
+          @type = type_cast(@field.type)
+          @options = {
+            :primary => @field.primary,
+            :native_type => @field.type.to_s
+          }
+        end
+
+        def type_cast type_name
+          type = self.class.types[type_name.to_s] || type_name.to_s
+          if self.association
+            type = "array"
+          end
+          type
+        end
+      end # end of field
+
+      include Lolita::Adapter::CommonHelper
+
+      def fields
+        @fields||=self.klass.columns.collect{|column|
+          Field.new(column,self)
+        }
+        @fields
+      end
+
+      def field_by_name(name)
+        self.fields.detect{|field|
+          field.name.to_s == name.to_s
+        }
+      end
+
+      def field_by_association(name)
+        possible_association = self.associations.detect{|assoc_name,association|
+          name.to_s == assoc_name.to_s
+        }
+        if possible_association
+          self.field_by_name(possible_association.last.key)
+        end
+      end
+
+      def search(query, options = {})
+        #TODO raise error or warn when there are lot of records and no index on field
+        unless query.blank?
+          resources = self.klass.arel_table
+          content_fields = @dbi.fields.map{|field| field.type!="string" ? nil : field.name.to_sym}.compact
+          if options[:fields] && options[:fields].any?
+            content_fields = content_fields & options[:fields]
+          end
+          scope = nil
+          content_fields.each_with_index do |field,index|
+            new_scope = resources[field].matches("%#{query}%")
+            unless index == 0
+              scope = scope.or(new_scope)
+            else
+              scope = new_scope
+            end
+          end
+          self.klass.where(scope)
+        else
+          self.klass.where(nil)
+        end
+      end
+
+      def db
+        self.klass.connection
+      end
+
+      def db_name
+        db.current_database
+      end
+
+      def collection
+        self.klass #FIXME not realy same as in mongoid
+      end
+
+      def collection_name
+        self.klass.table_name
+      end
+
+      def collection_name=(value)
+        self.klass.table_name = value
+      end
+
+      def collections
+        self.klass #FIXME not  realy same as in mongoid
+      end
+
+      def collection_names
+        self.klass.connection.select_all("show tables from #{db_name}").map{|r| r.values.first}
+      end
+
+      def nested_attributes_options
+        self.klass.nested_attributes_options
+      end
+
+      def order_method
+        :order
+      end
+    end
+  end
+end