veneer 0.2.0 → 0.4.0

data/lib/veneer/adapters/activerecord/property.rb

@@ -0,0 +1,22 @@
+module ActiveRecord
+  class Base
+    module VeneerInterface
+      class Property < Veneer::Base::Property
+        def normalize(type)
+          case type
+          when :serial, :integer then Integer
+          when :string, :text then String
+          when :float then Float
+          when :decimal then BigDecimal
+          when :datetime then DateTime
+          when :time then Time
+          when :date then Date
+          when :binary then StringIO
+          when :boolean then TrueClass
+          else type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/veneer/adapters/datamapper.rb

@@ -1,2 +1,3 @@
+require 'veneer/adapters/datamapper/property'
 require 'veneer/adapters/datamapper/class_wrapper'
 require 'veneer/adapters/datamapper/instance_wrapper'

data/lib/veneer/adapters/datamapper/class_wrapper.rb

@@ -2,10 +2,69 @@ module DataMapper
   module Resource
     module VeneerInterface
       class ClassWrapper < ::Veneer::Base::ClassWrapper
+        def self.model_classes
+          ::DataMapper::Model.descendants
+        end
+
         def new(opts = {})
           ::Kernel.Veneer(klass.new(opts))
         end
 
+        def collection_associations
+          @collection_associations ||= begin
+            result = klass.relationships.inject([]) do |ary, rel|
+              if rel.max > 1
+                ary << {
+                  :name  => rel.name,
+                  :class => rel.child_model
+                }
+              end
+              ary
+            end
+            result
+          end
+        end
+
+        def member_associations
+          @member_associations ||= begin
+            result = klass.relationships.inject([]) do |ary, rel|
+              if rel.max == 1
+                ary << {
+                  :name  => rel.name,
+                  :class => rel.parent_model
+                }
+              end
+              ary
+            end
+            result
+          end
+        end
+
+        def properties
+          @properties ||= begin
+            klass.properties.map do |property|
+              ::DataMapper::Resource::VeneerInterface::Property.new(
+                self,
+                {
+                  :name => property.name,
+                  :type => property,
+                  :constraints => {
+                    :length => property.options[:length],
+                    :nullable? => property.options[:allow_nil],
+                    :precision => property.options[:precision],
+                    :scale => property.options[:scale],
+                  },
+                  :primary => primary_keys.include?(property.name),
+                }
+              )
+            end
+          end
+        end
+        
+        def primary_keys
+          @primary_keys ||= klass.key.map { |key| key.name }
+        end
+
         def destroy_all
           klass.all.destroy
         end
@@ -15,7 +74,32 @@ module DataMapper
         end
 
         def find_many(opts)
-          klass.all(dm_conditions_from_opts(opts))
+          klass.all(dm_conditions_from_opts(opts)).to_a
+        end
+
+        def count(opts={})
+          opts[:conditions].nil? ? klass.count : klass.count(opts[:conditions])
+        end
+
+        def sum(field, opts={})
+          opts = ::Hashie::Mash.new(opts)
+          klass.all(dm_conditions_from_opts(opts)).sum(field)
+        end
+
+        def min(field, opts={})
+          opts = ::Hashie::Mash.new(opts)
+          klass.all(dm_conditions_from_opts(opts)).min(field)
+        end
+
+        def max(field, opts={})
+          opts = ::Hashie::Mash.new(opts)
+          klass.all(dm_conditions_from_opts(opts)).max(field)
+        end
+
+        # Delegate to validators_on if ActiveModel::Validations has been
+        # included in the model
+        def validators_on(name)
+          klass <=> ::ActiveModel::Validations ? klass.validators_on(name) : []
         end
 
         private
@@ -38,20 +122,20 @@ module DataMapper
 
           if raw.order.present?
             opts[:order] = case raw.order
-            when Array
+            when ::Array
               raw.order.inject([]) do |ary, str|
                 ary << order_from_string(str)
               end.compact
-            when String
+            when ::String
               order_from_string(raw.order)
-            when Symbol
+            when ::Symbol
               raw.order
             end
           end
 
           if raw.conditions.present?
-            raw.conditions.each do |field, value|
-              opts[field] = value if allowed_field?(field)
+            raw.conditions.each do |(field, value)|
+              opts[field.to_sym] = value if allowed_field?(field)
             end
           end
           opts

data/lib/veneer/adapters/datamapper/property.rb

@@ -0,0 +1,25 @@
+module DataMapper
+  module Resource
+    module VeneerInterface
+      class Property < Veneer::Base::Property
+        def normalize(type)
+          # Several DataMapper properties' types inherit from the Object class
+          # so DataMapper::Property::Object must be the last one i the case statement.
+          case type
+          when DataMapper::Property::Integer then Integer
+          when DataMapper::Property::String then String
+          when DataMapper::Property::Float then Float
+          when DataMapper::Property::Decimal then BigDecimal
+          when DataMapper::Property::DateTime then DateTime
+          when DataMapper::Property::Time then Time
+          when DataMapper::Property::Date then Date
+          when DataMapper::Property::Boolean then TrueClass
+          when DataMapper::Property::Discriminator then Class
+          when DataMapper::Property::Object then Object
+          else type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/veneer/adapters/mongomapper.rb

@@ -1,3 +1,4 @@
+require 'veneer/adapters/mongomapper/property'
 require 'veneer/adapters/mongomapper/class_wrapper'
 require 'veneer/adapters/mongomapper/instance_wrapper'
 

data/lib/veneer/adapters/mongomapper/class_wrapper.rb

@@ -2,14 +2,82 @@ module MongoMapper
   module Document
     module VeneerInterface
       class ClassWrapper < Veneer::Base::ClassWrapper
+        delegate :validators_on, :to => :klass
+
+        PRIMARY_KEYS = [:_id]
+        
+        def self.model_classes
+          ::MongoMapper::Document.descendants
+        end
+
         def new(opts = {})
           ::Kernel::Veneer(klass.new(opts))
         end
 
+        def collection_associations
+          @collection_associations ||= begin
+            klass.associations.inject([]) do |ary, (name, assoc)|
+              if assoc.is_a? ::MongoMapper::Plugins::Associations::ManyAssociation
+                ary << {
+                  :name => name,
+                  :class => assoc.class_name.constantize
+                }
+              end
+              ary
+            end
+          end
+        end
+
+        def member_associations
+          @member_associations ||= begin
+            types = [::MongoMapper::Plugins::Associations::BelongsToAssociation,
+                     ::MongoMapper::Plugins::Associations::ManyAssociation]
+            klass.associations.inject([]) do |ary, (name, assoc)|
+              if types.include?(assoc.class)
+                ary << {
+                  :name => name,
+                  :class => assoc.class_name.constantize
+                }
+              end
+              ary
+            end
+          end
+        end
+
+        def properties
+          @properties ||= begin
+            klass.keys.map do |property|
+              property = property[1]
+              name = property.name.to_sym
+              ::MongoMapper::Document::VeneerInterface::Property.new(
+                self,
+                {
+                  :name => name,
+                  :type => property.type,
+                  :constraints => {
+                    :length => property.options[:length],
+                    :nullable? => nil,
+                    :precision => nil,
+                  },
+                  :primary => primary_keys.include?(name),
+                }
+              )
+            end
+          end
+        end
+        
+        def primary_keys
+          ::MongoMapper::Document::VeneerInterface::ClassWrapper::PRIMARY_KEYS
+        end
+
         def destroy_all
           klass.destroy_all
         end
 
+        def count(opts={})
+          opts[:conditions].nil? ? klass.count : klass.count(opts[:conditions])
+        end
+
         def find_first(opts)
           klass.first(opts)
         end

data/lib/veneer/adapters/mongomapper/property.rb

@@ -0,0 +1,16 @@
+module MongoMapper
+  module Document
+    module VeneerInterface
+      class Property < Veneer::Base::Property
+        def normalize(type)
+          case type
+          when MongoMapper::Extensions::ObjectId then String
+          when MongoMapper::Extensions::Boolean then TrueClass
+          when MongoMapper::Extensions::Binary then StringIO
+          else type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/veneer/base/class_wrapper.rb

@@ -4,11 +4,17 @@ module Veneer
     # new
     # find_many
     # destroy_all
+    # model_classes
+    #
     #
     # Optional Methods
     # find_first
     # create!
     # create
+    # count
+    # sum
+    # max
+    # min
     #
     class ClassWrapper < BasicObject
       attr_reader :klass, :opts
@@ -16,6 +22,45 @@ module Veneer
         @klass, @opts = klass, opts
       end
 
+      def self.inherited(klass)
+        subclasses << klass
+      end
+
+      def self.subclasses
+        @subclasses ||= []
+      end
+
+      def self.model_classes
+        raise ::Veneer::Errors::NotImplemented
+      end
+
+      # Provides an array of associations of the format
+      # [
+      #   {
+      #     :name       => :association_name,
+      #     :class_name => 'TheClass'
+      #   }
+      # ]
+      #
+      # The collection associations maps has_many, has n, embeds_many and the like.
+      # @api public
+      def collection_associations
+        []
+      end
+
+      # Provides an array of association for belongs_to type associaions
+      # of the format:
+      #
+      # [
+      #   {
+      #     :name       => :assocaition_name,
+      #     :class_name => 'TheClass'
+      #   }
+      # ]
+      def member_associations
+        []
+      end
+
       # Create an instance of the object.
       # That is, instantiate and persist it in one step.
       # Raise an error if the object is not persisted
@@ -50,7 +95,7 @@ module Veneer
       # @api public
       # @see Veneer::Base::ClassWrapper.all
       def first(opts={})
-        ::Kernel.Veneer(find_first(Hashie::Mash.new(opts)))
+        ::Kernel.Veneer(find_first(::Hashie::Mash.new(opts)))
       end
 
       # Provides an interface to query the objects
@@ -64,7 +109,58 @@ module Veneer
       #
       # @api public
       def all(opts={})
-        find_many(Hashie::Mash.new(opts)).map{|element| ::Kernel.Veneer(element)}
+        find_many(::Hashie::Mash.new(opts))
+      end
+
+      # Obtains a count of all matching records
+      # Takes the same options as all
+      #
+      # Adapter implementers should overwrite with a more
+      # efficient implementation
+      # @see all
+      def count(opts={})
+        all(opts).size
+      end
+
+      # Obtains a sum of all matching records for the given field
+      # Takes the same options as all
+      #
+      # Adapter implementers should overwrite with a more
+      # efficient implementation
+      # @see all
+      def sum(field, opts={})
+        opts = ::Hashie::Mash.new(opts)
+        all(opts).inject(0){|sum, item| (item.send(field) || 0) + sum }
+      end
+
+      # Obtains the minimum value of the given field of all matching records
+      # Takes the same options as all
+      #
+      # Adapter implementers should overwrite with a more
+      # efficient implementation
+      # @see all
+      def min(field, opts={})
+        opts = ::Hashie::Mash.new(opts)
+        all(opts).inject(nil) do |min, item|
+          val = item.send(field)
+          min = val if !val.nil? && (min.nil? || val < min)
+          min
+        end
+      end
+
+      # Obtains the maximum value of the given field of all matching records
+      # Takes the same options as all
+      #
+      # Adapter implementers should overwrite with a more
+      # efficient implementation
+      # @see all
+      def max(field, opts={})
+        opts = ::Hashie::Mash.new(opts)
+        all(opts).inject(nil) do |max, item|
+          val = item.send(field)
+          max = val if !val.nil? && (max.nil? || val > max)
+          max
+        end
       end
 
       # Should return an array or array like structure with elements matching the provided conditions hash
@@ -74,15 +170,22 @@ module Veneer
         ::Kernel.raise Errors::NotImplemented
       end
 
+      # Should return an array of primary keys
+      # @api public
+      def primary_keys
+        ::Kernel.raise Errors::NotImplemented
+      end
+
+      # Should return an array of ActiveModel::Validator class instances for given property name
+      # @api public
+      def validators_on(name)
+        ::Kernel.raise Errors::NotImplemented
+      end
+
       def find_first(opts)
         opts[:limit] = 1
         find_many(opts).first
       end
-
-      private
-      def method_missing(meth, *args, &blk)
-        @klass.__send__(meth, *args, &blk)
-      end
     end
   end
 end