lolita 3.1.9 → 3.1.10

data/lib/lolita/adapter/abstract_adapter.rb

@@ -1,14 +1,14 @@
-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 'opt={}',:paginate, :filter
-      abstract_method 'name',:reflect_on_association
-      abstract_method 'association',:association_macro,:association_class_name
-      abstract_method 'id',:find_by_id
-      abstract_method '*args', :find
-    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 'opt={}',:paginate, :filter
+      abstract_method 'name',:reflect_on_association
+      abstract_method 'association',:association_macro,:association_class_name
+      abstract_method 'id',:find_by_id
+      abstract_method '*args', :find
+    end
+  end
 end

data/lib/lolita/adapter/active_record.rb

@@ -1,148 +1,148 @@
-module Lolita
-  module Adapter
-    class ActiveRecord
-      include Lolita::Adapter::AbstractAdapter
-      
-      attr_reader :dbi, :klass
-      def initialize(dbi)
-        @dbi=dbi
-        @klass=dbi.klass
-      end
-
-      def associations
-        klass.reflections
-      end
-
-      # Same as in mongoid
-      def associations_klass_names
-        names=[]
-        associations.each{|name,association|
-          names << association.class_name
-        }
-        names
-      end
-
-      def reflect_on_association(name)
-        klass.reflect_on_association(name)
-      end
-
-      def association_macro(association)
-        type=association.macro
-        case type
-        when :has_many
-          :many
-        when :has_one
-          :one
-        when :belongs_to
-          :one
-        when :has_and_belongs_to_many
-          :many
-        end
-      end
-
-      def association_class_name(association)
-        association.class_name
-      end
-
-      def fields
-        @fields||=self.klass.columns.collect{|column|
-          field_to_hash(column)
-        }.reject{|column|
-          column[:options][:primary]
-        }
-        @fields
-      end
-
-      def find_by_id(id)
-        self.klass.unscoped.where(:id=>id).first
-      end
-      
-      def find(*args)
-        self.klass.unscoped.find(*args)
-      end
-
-      def paginate(opt={})
-        if order=opt.delete(:sort)
-          order=order.map{|c| c.join(" ")}.join(", ")
-          opt[:order]=order
-        end
-        self.klass.unscoped.page(opt[:page]).per(opt[:per_page]).order(opt[:order])
-      end
-
-      def filter(opt={})
-        conditions = {}
-        joins = []
-        unless opt.empty?
-          opt.each_pair do |k,v|
-            field = klass.columns.detect{|f| f.name == k.to_s}
-            if field
-              conditions[k] = v
-            elsif association = associations[k.to_sym]
-              case association_macro(association)
-              when :many
-                conditions[association.name] = {:id => v}
-                joins << association.name
-              when :one
-                conditions[association.primary_key_name] = v
-              end
-            end
-          end
-          unless conditions.empty?
-            rs = self.klass.unscoped.where(conditions)
-            joins.each { |join| rs = rs.joins(join) }
-            return rs
-          end
-        end
-        self
-      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 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
-
-      private
-
-      def field_to_hash(column)
-        {
-          :name=>column.name,
-          :type=>type_cast(column.type.to_s),
-          :title=>self.klass.human_attribute_name(column.name),
-          :options=>{
-            :primary=>column.primary,
-            :native_type=>column.type.to_s
-          }
-        }
-      end
-
-      # Converts SQL types to normal ruby types
-      def type_cast name
-        types = {
-          'decimal' => 'big_decimal',
-          'datetime' => 'date_time',
-          'text' => 'string'
-        }
-        types[name.to_s] || name
-      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
+
+      def associations
+        klass.reflections
+      end
+
+      # Same as in mongoid
+      def associations_klass_names
+        names=[]
+        associations.each{|name,association|
+          names << association.class_name
+        }
+        names
+      end
+
+      def reflect_on_association(name)
+        klass.reflect_on_association(name)
+      end
+
+      def association_macro(association)
+        type=association.macro
+        case type
+        when :has_many
+          :many
+        when :has_one
+          :one
+        when :belongs_to
+          :one
+        when :has_and_belongs_to_many
+          :many
+        end
+      end
+
+      def association_class_name(association)
+        association.class_name
+      end
+
+      def fields
+        @fields||=self.klass.columns.collect{|column|
+          field_to_hash(column)
+        }.reject{|column|
+          column[:options][:primary]
+        }
+        @fields
+      end
+
+      def find_by_id(id)
+        self.klass.unscoped.where(:id=>id).first
+      end
+      
+      def find(*args)
+        self.klass.unscoped.find(*args)
+      end
+
+      def paginate(opt={})
+        if order=opt.delete(:sort)
+          order=order.map{|c| c.join(" ")}.join(", ")
+          opt[:order]=order
+        end
+        self.klass.unscoped.page(opt[:page]).per(opt[:per_page]).order(opt[:order])
+      end
+
+      def filter(opt={})
+        conditions = {}
+        joins = []
+        unless opt.empty?
+          opt.each_pair do |k,v|
+            field = klass.columns.detect{|f| f.name == k.to_s}
+            if field
+              conditions[k] = v
+            elsif association = associations[k.to_sym]
+              case association_macro(association)
+              when :many
+                conditions[association.name] = {:id => v}
+                joins << association.name
+              when :one
+                conditions[association.primary_key_name] = v
+              end
+            end
+          end
+          unless conditions.empty?
+            rs = self.klass.unscoped.where(conditions)
+            joins.each { |join| rs = rs.joins(join) }
+            return rs
+          end
+        end
+        self
+      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 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
+
+      private
+
+      def field_to_hash(column)
+        {
+          :name=>column.name,
+          :type=>type_cast(column.type.to_s),
+          :title=>self.klass.human_attribute_name(column.name),
+          :options=>{
+            :primary=>column.primary,
+            :native_type=>column.type.to_s
+          }
+        }
+      end
+
+      # Converts SQL types to normal ruby types
+      def type_cast name
+        types = {
+          'decimal' => 'big_decimal',
+          'datetime' => 'date_time',
+          'text' => 'string'
+        }
+        types[name.to_s] || name
+      end
+    end
+  end
+end

data/lib/lolita/adapter/mongoid.rb

@@ -1,128 +1,128 @@
-module Lolita
-  module Adapter
-    class Mongoid
-      include Lolita::Adapter::AbstractAdapter
-
-      attr_reader :dbi, :klass
-      def initialize(dbi)
-        @dbi=dbi
-        @klass=dbi.klass
-      end
-
-      def associations
-        klass.relations
-      end
-
-      def associations_class_names
-        names=[]
-        associations.each{|name,association|
-          names<<association.class_name
-        }
-        names
-      end
-
-      def reflect_on_association(name)
-        klass.reflect_on_association(name)
-      end
-
-      def association_macro(association)
-        macro=association.macro
-        case macro
-        when :references_many
-          :many
-        when :references_and_referenced_in_many
-          :many
-        when :referenced_in
-          :one
-        when :references_one
-          :one
-        when :embeds_one
-          :one
-        when :embeds_many
-          :many
-        end
-      end
-
-      def association_class_name(association)
-        association.class_name
-      end
-
-      def fields
-        @fields||=self.klass.fields.collect{|name,field|
-          name[0] == '_' ? nil : field_to_hash(name,field)
-        }.compact
-        @fields
-      end
-
-      def find_by_id(id)
-        self.klass.unscoped.where(:_id=>id).first
-      end
-
-      def find *args
-        self.klass.unscoped.find(*args)
-      end
-
-      def paginate(opt={})
-        self.klass.unscoped.order_by(opt[:sort]).page(opt[:page]).per(opt[:per_page])
-      end
-
-      def filter(opt={})
-        conditions = {}
-        unless opt.empty?
-          opt.each_pair do |k,v|
-            field = klass.fields.detect{|name,f| name == k.to_s}
-            if field
-              conditions[k] = v
-            elsif association = associations[k.to_s]
-              case association_macro(association)
-              when :many
-                conditions[:"#{klass.reflect_on_association(k).key}".in] = [v]
-              when :one
-                conditions[klass.reflect_on_association(k).foreign_key] = v
-              end
-            end
-          end
-          return self.klass.unscoped.where(conditions)
-        end
-        self
-      end
-      
-      def db
-        self.klass.db
-      end
-
-      def db_name
-        self.klass.db.name
-      end
-
-      def collection
-        self.klass.collection
-      end
-
-      def collection_name
-        collection.name
-      end
-
-      def collections
-        db.collections
-      end
-
-      def collection_names
-        db.collection_names
-      end
-
-      private
-
-      def field_to_hash(name,field)
-        {
-          :name=>name,
-          :type=>field.type.to_s,
-          :title=>self.klass.human_attribute_name(name.to_s),
-          :options=>field.options.merge({
-            :primary=>name.to_s=="_id"
-          })
-        }
-      end
-    end
-  end
+module Lolita
+  module Adapter
+    class Mongoid
+      include Lolita::Adapter::AbstractAdapter
+
+      attr_reader :dbi, :klass
+      def initialize(dbi)
+        @dbi=dbi
+        @klass=dbi.klass
+      end
+
+      def associations
+        klass.relations
+      end
+
+      def associations_class_names
+        names=[]
+        associations.each{|name,association|
+          names<<association.class_name
+        }
+        names
+      end
+
+      def reflect_on_association(name)
+        klass.reflect_on_association(name)
+      end
+
+      def association_macro(association)
+        macro=association.macro
+        case macro
+        when :references_many
+          :many
+        when :references_and_referenced_in_many
+          :many
+        when :referenced_in
+          :one
+        when :references_one
+          :one
+        when :embeds_one
+          :one
+        when :embeds_many
+          :many
+        end
+      end
+
+      def association_class_name(association)
+        association.class_name
+      end
+
+      def fields
+        @fields||=self.klass.fields.collect{|name,field|
+          name[0] == '_' ? nil : field_to_hash(name,field)
+        }.compact
+        @fields
+      end
+
+      def find_by_id(id)
+        self.klass.unscoped.where(:_id=>id).first
+      end
+
+      def find *args
+        self.klass.unscoped.find(*args)
+      end
+
+      def paginate(opt={})
+        self.klass.unscoped.order_by(opt[:sort]).page(opt[:page]).per(opt[:per_page])
+      end
+
+      def filter(opt={})
+        conditions = {}
+        unless opt.empty?
+          opt.each_pair do |k,v|
+            field = klass.fields.detect{|name,f| name == k.to_s}
+            if field
+              conditions[k] = v
+            elsif association = associations[k.to_s]
+              case association_macro(association)
+              when :many
+                conditions[:"#{klass.reflect_on_association(k).key}".in] = [v]
+              when :one
+                conditions[klass.reflect_on_association(k).foreign_key] = v
+              end
+            end
+          end
+          return self.klass.unscoped.where(conditions)
+        end
+        self
+      end
+      
+      def db
+        self.klass.db
+      end
+
+      def db_name
+        self.klass.db.name
+      end
+
+      def collection
+        self.klass.collection
+      end
+
+      def collection_name
+        collection.name
+      end
+
+      def collections
+        db.collections
+      end
+
+      def collection_names
+        db.collection_names
+      end
+
+      private
+
+      def field_to_hash(name,field)
+        {
+          :name=>name,
+          :type=>field.type.to_s,
+          :title=>self.klass.human_attribute_name(name.to_s),
+          :options=>field.options.merge({
+            :primary=>name.to_s=="_id"
+          })
+        }
+      end
+    end
+  end
 end