mack-data_mapper 0.8.1 → 0.8.2

data/lib/gems/addressable-2.0.0/lib/addressable/version.rb

@@ -0,0 +1,35 @@
+#--
+# Addressable, Copyright (c) 2006-2008 Bob Aman
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+# Used to prevent the class/module from being loaded more than once
+if !defined?(Addressable::VERSION)
+  module Addressable
+    module VERSION #:nodoc:
+      MAJOR = 2
+      MINOR = 0
+      TINY  = 0
+
+      STRING = [MAJOR, MINOR, TINY].join('.')
+    end
+  end
+end

data/lib/gems/dm-aggregates-0.9.7/lib/dm-aggregates/adapters/data_objects_adapter.rb

@@ -0,0 +1,85 @@
+module DataMapper
+  module Adapters
+    class DataObjectsAdapter
+      def aggregate(query)
+        with_reader(read_statement(query), query.bind_values) do |reader|
+          results = []
+
+          while(reader.next!) do
+            row = query.fields.zip(reader.values).map do |field,value|
+              if field.respond_to?(:operator)
+                send(field.operator, field.target, value)
+              else
+                field.typecast(value)
+              end
+            end
+
+            results << (query.fields.size > 1 ? row : row[0])
+          end
+
+          results
+        end
+      end
+
+      private
+
+      def count(property, value)
+        value.to_i
+      end
+
+      def min(property, value)
+        property.typecast(value)
+      end
+
+      def max(property, value)
+        property.typecast(value)
+      end
+
+      def avg(property, value)
+        property.type == Integer ? value.to_f : property.typecast(value)
+      end
+
+      def sum(property, value)
+        property.typecast(value)
+      end
+
+      module SQL
+        private
+
+        alias original_property_to_column_name property_to_column_name
+
+        def property_to_column_name(repository, property, qualify)
+          case property
+            when Query::Operator
+              aggregate_field_statement(repository, property.operator, property.target, qualify)
+            when Property, Query::Path
+              original_property_to_column_name(repository, property, qualify)
+            else
+              raise ArgumentError, "+property+ must be a DataMapper::Query::Operator, a DataMapper::Property or a Query::Path, but was a #{property.class} (#{property.inspect})"
+          end
+        end
+
+        def aggregate_field_statement(repository, aggregate_function, property, qualify)
+          column_name = if aggregate_function == :count && property == :all
+            '*'
+          else
+            property_to_column_name(repository, property, qualify)
+          end
+
+          function_name = case aggregate_function
+            when :count then 'COUNT'
+            when :min   then 'MIN'
+            when :max   then 'MAX'
+            when :avg   then 'AVG'
+            when :sum   then 'SUM'
+            else raise "Invalid aggregate function: #{aggregate_function.inspect}"
+          end
+
+          "#{function_name}(#{column_name})"
+        end
+      end # module SQL
+
+      include SQL
+    end # class DataObjectsAdapter
+  end # module Adapters
+end # module DataMapper

data/lib/gems/dm-aggregates-0.9.7/lib/dm-aggregates/aggregate_functions.rb

@@ -0,0 +1,201 @@
+module DataMapper
+  module AggregateFunctions
+    # Count results (given the conditions)
+    #
+    # @example the count of all friends
+    #   Friend.count
+    #
+    # @example the count of all friends older then 18
+    #   Friend.count(:age.gt => 18)
+    #
+    # @example the count of all your female friends
+    #   Friend.count(:conditions => [ 'gender = ?', 'female' ])
+    #
+    # @example the count of all friends with an address (NULL values are not included)
+    #   Friend.count(:address)
+    #
+    # @example the count of all friends with an address that are older then 18
+    #   Friend.count(:address, :age.gt => 18)
+    #
+    # @example the count of all your female friends with an address
+    #   Friend.count(:address, :conditions => [ 'gender = ?', 'female' ])
+    #
+    # @param property [Symbol] of the property you with to count (optional)
+    # @param  opts [Hash, Symbol] the conditions
+    #
+    # @return [Integer] return the count given the conditions
+    #
+    # @api public
+    def count(*args)
+      query         = args.last.kind_of?(Hash) ? args.pop : {}
+      property_name = args.first
+
+      if property_name
+        assert_kind_of 'property', property_by_name(property_name), Property
+      end
+
+      aggregate(query.merge(:fields => [ property_name ? property_name.count : :all.count ]))
+    end
+
+    # Get the lowest value of a property
+    #
+    # @example the age of the youngest friend
+    #   Friend.min(:age)
+    #
+    # @example  the age of the youngest female friend
+    #   Friend.min(:age, :conditions => [ 'gender = ?', 'female' ])
+    #
+    # @param property [Symbol] the property you wish to get the lowest value of
+    # @param  opts [Hash, Symbol] the conditions
+    #
+    # @return [Integer] return the lowest value of a property given the conditions
+    #
+    # @api public
+    def min(*args)
+      query         = args.last.kind_of?(Hash) ? args.pop : {}
+      property_name = args.first
+
+      assert_property_type property_name, Integer, Float, BigDecimal, DateTime, Date, Time
+
+      aggregate(query.merge(:fields => [ property_name.min ]))
+    end
+
+    # Get the highest value of a property
+    #
+    # @example the age of the oldest friend
+    #   Friend.max(:age)
+    #
+    # @example the age of the oldest female friend
+    #   Friend.max(:age, :conditions => [ 'gender = ?', 'female' ])
+    #
+    # @param property [Symbol] the property you wish to get the highest value of
+    # @param  opts [Hash, Symbol] the conditions
+    #
+    # @return [Integer] return the highest value of a property given the conditions
+    #
+    # @api public
+    def max(*args)
+      query         = args.last.kind_of?(Hash) ? args.pop : {}
+      property_name = args.first
+
+      assert_property_type property_name, Integer, Float, BigDecimal, DateTime, Date, Time
+
+      aggregate(query.merge(:fields => [ property_name.max ]))
+    end
+
+    # Get the average value of a property
+    #
+    # @example the average age of all friends
+    #   Friend.avg(:age)
+    #
+    # @example the average age of all female friends
+    #   Friend.avg(:age, :conditions => [ 'gender = ?', 'female' ])
+    #
+    # @param property [Symbol] the property you wish to get the average value of
+    # @param  opts [Hash, Symbol] the conditions
+    #
+    # @return [Integer] return the average value of a property given the conditions
+    #
+    # @api public
+    def avg(*args)
+      query         = args.last.kind_of?(Hash) ? args.pop : {}
+      property_name = args.first
+
+      assert_property_type property_name, Integer, Float, BigDecimal
+
+      aggregate(query.merge(:fields => [ property_name.avg ]))
+    end
+
+    # Get the total value of a property
+    #
+    # @example the total age of all friends
+    #   Friend.sum(:age)
+    #
+    # @example the total age of all female friends
+    #   Friend.max(:age, :conditions => [ 'gender = ?', 'female' ])
+    #
+    # @param property [Symbol] the property you wish to get the total value of
+    # @param  opts [Hash, Symbol] the conditions
+    #
+    # @return [Integer] return the total value of a property given the conditions
+    #
+    # @api public
+    def sum(*args)
+      query         = args.last.kind_of?(Hash) ? args.pop : {}
+      property_name = args.first
+
+      assert_property_type property_name, Integer, Float, BigDecimal
+
+      aggregate(query.merge(:fields => [ property_name.sum ]))
+    end
+
+    # Perform aggregate queries
+    #
+    # @example the count of friends
+    #   Friend.aggregate(:all.count)
+    #
+    # @example the minimum age, the maximum age and the total age of friends
+    #   Friend.aggregate(:age.min, :age.max, :age.sum)
+    #
+    # @example the average age, grouped by gender
+    #   Friend.aggregate(:age.avg, :fields => [ :gender ])
+    #
+    # @param aggregates [Symbol, ...] operators to aggregate with
+    # @params query [Hash] the conditions
+    #
+    # @return [Array,Numeric,DateTime,Date,Time] the results of the
+    #   aggregate query
+    #
+    # @api public
+    def aggregate(*args)
+      query = args.last.kind_of?(Hash) ? args.pop : {}
+
+      query[:fields] ||= []
+      query[:fields]  |= args
+      query[:fields].map! { |f| normalize_field(f) }
+      query[:order]  ||= query[:fields].select { |p| p.kind_of?(Property) }
+
+      raise ArgumentError, 'query[:fields] must not be empty' if query[:fields].empty?
+
+      query = scoped_query(query)
+
+      if query.fields.any? { |p| p.kind_of?(Property) }
+        # explicitly specify the fields to circumvent a bug in Query#update
+        query.repository.aggregate(query.update(:fields => query.fields, :unique => true))
+      else
+        query.repository.aggregate(query).first  # only return one row
+      end
+    end
+
+    private
+
+    def assert_property_type(name, *types)
+      if name.nil?
+        raise ArgumentError, 'property name must not be nil'
+      end
+
+      type = property_by_name(name).type
+
+      unless types.include?(type)
+        raise ArgumentError, "#{name} must be #{types * ' or '}, but was #{type}"
+      end
+    end
+
+    def normalize_field(field)
+      assert_kind_of 'field', field, Query::Operator, Symbol, Property
+
+      case field
+        when Query::Operator
+          if field.target == :all
+            field
+          else
+            field.class.new(property_by_name(field.target), field.operator)
+          end
+        when Symbol
+          property_by_name(field)
+        when Property
+          field
+      end
+    end
+  end
+end

data/lib/gems/dm-aggregates-0.9.7/lib/dm-aggregates/collection.rb

@@ -0,0 +1,11 @@
+module DataMapper
+  class Collection
+    include AggregateFunctions
+
+    private
+
+    def property_by_name(property_name)
+      properties[property_name]
+    end
+  end
+end

data/lib/gems/dm-aggregates-0.9.7/lib/dm-aggregates/model.rb

@@ -0,0 +1,11 @@
+module DataMapper
+  module Model
+    include AggregateFunctions
+
+    private
+
+    def property_by_name(property_name)
+      properties(repository.name)[property_name]
+    end
+  end
+end

data/lib/gems/dm-aggregates-0.9.7/lib/dm-aggregates/repository.rb

@@ -0,0 +1,7 @@
+module DataMapper
+  class Repository
+    def aggregate(query)
+      adapter.aggregate(query)
+    end
+  end
+end

data/lib/gems/dm-aggregates-0.9.7/lib/dm-aggregates/support/symbol.rb

@@ -0,0 +1,21 @@
+class Symbol
+  def count
+    DataMapper::Query::Operator.new(self, :count)
+  end
+
+  def min
+    DataMapper::Query::Operator.new(self, :min)
+  end
+
+  def max
+    DataMapper::Query::Operator.new(self, :max)
+  end
+
+  def avg
+    DataMapper::Query::Operator.new(self, :avg)
+  end
+
+  def sum
+    DataMapper::Query::Operator.new(self, :sum)
+  end
+end # class Symbol

data/lib/gems/dm-aggregates-0.9.7/lib/dm-aggregates/version.rb

@@ -0,0 +1,7 @@
+module DataMapper
+  module More
+    module Aggregates
+      VERSION = "0.9.7"
+    end
+  end
+end

data/lib/gems/dm-aggregates-0.9.7/lib/dm-aggregates.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+
+dir = Pathname(__FILE__).dirname.expand_path + 'dm-aggregates'
+
+require dir + 'version'
+gem 'dm-core', DataMapper::More::Aggregates::VERSION
+require 'dm-core'
+
+
+require dir + 'aggregate_functions'
+require dir + 'model'
+require dir + 'repository'
+require dir + 'collection'
+require dir + 'adapters' + 'data_objects_adapter'
+require dir + 'support' + 'symbol'

data/lib/gems/dm-core-0.9.7/lib/dm-core/adapters/abstract_adapter.rb

@@ -0,0 +1,209 @@
+module DataMapper
+  module Adapters
+    class AbstractAdapter
+      include Assertions
+
+      attr_reader :name, :uri
+      attr_accessor :resource_naming_convention, :field_naming_convention
+
+      def create(resources)
+        raise NotImplementedError
+      end
+
+      def read_many(query)
+        raise NotImplementedError
+      end
+
+      def read_one(query)
+        raise NotImplementedError
+      end
+
+      def update(attributes, query)
+        raise NotImplementedError
+      end
+
+      def delete(query)
+        raise NotImplementedError
+      end
+
+      protected
+
+      def normalize_uri(uri_or_options)
+        uri_or_options
+      end
+
+      private
+
+      # Instantiate an Adapter by passing it a DataMapper::Repository
+      # connection string for configuration.
+      def initialize(name, uri_or_options)
+        assert_kind_of 'name',           name,           Symbol
+        assert_kind_of 'uri_or_options', uri_or_options, Addressable::URI, DataObjects::URI, Hash, String
+
+        @name = name
+        @uri  = normalize_uri(uri_or_options)
+
+        @resource_naming_convention = NamingConventions::Resource::UnderscoredAndPluralized
+        @field_naming_convention    = NamingConventions::Field::Underscored
+
+        @transactions = {}
+      end
+
+      # TODO: move to dm-more/dm-migrations
+      module Migration
+        #
+        # Returns whether the storage_name exists.
+        #
+        # @param storage_name<String> a String defining the name of a storage,
+        #   for example a table name.
+        #
+        # @return <Boolean> true if the storage exists
+        #
+        # TODO: move to dm-more/dm-migrations (if possible)
+        def storage_exists?(storage_name)
+          raise NotImplementedError
+        end
+
+        #
+        # Returns whether the field exists.
+        #
+        # @param storage_name<String> a String defining the name of a storage, for example a table name.
+        # @param field_name<String> a String defining the name of a field, for example a column name.
+        #
+        # @return <Boolean> true if the field exists.
+        #
+        # TODO: move to dm-more/dm-migrations (if possible)
+        def field_exists?(storage_name, field_name)
+          raise NotImplementedError
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def upgrade_model_storage(repository, model)
+          raise NotImplementedError
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def create_model_storage(repository, model)
+          raise NotImplementedError
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def destroy_model_storage(repository, model)
+          raise NotImplementedError
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def alter_model_storage(repository, *args)
+          raise NotImplementedError
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def create_property_storage(repository, property)
+          raise NotImplementedError
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def destroy_property_storage(repository, property)
+          raise NotImplementedError
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def alter_property_storage(repository, *args)
+          raise NotImplementedError
+        end
+
+        module ClassMethods
+          # Default TypeMap for all adapters.
+          #
+          # @return <DataMapper::TypeMap> default TypeMap
+          #
+          # TODO: move to dm-more/dm-migrations
+          def type_map
+            @type_map ||= TypeMap.new
+          end
+        end
+      end
+
+      include Migration
+      extend Migration::ClassMethods
+
+      # TODO: move to dm-more/dm-transaction
+      module Transaction
+        #
+        # Pushes the given Transaction onto the per thread Transaction stack so
+        # that everything done by this Adapter is done within the context of said
+        # Transaction.
+        #
+        # @param transaction<DataMapper::Transaction> a Transaction to be the
+        #   'current' transaction until popped.
+        #
+        # TODO: move to dm-more/dm-transaction
+        def push_transaction(transaction)
+          transactions(Thread.current) << transaction
+        end
+
+        #
+        # Pop the 'current' Transaction from the per thread Transaction stack so
+        # that everything done by this Adapter is no longer necessarily within the
+        # context of said Transaction.
+        #
+        # @return <DataMapper::Transaction> the former 'current' transaction.
+        #
+        # TODO: move to dm-more/dm-transaction
+        def pop_transaction
+          transactions(Thread.current).pop
+        end
+
+        #
+        # Retrieve the current transaction for this Adapter.
+        #
+        # Everything done by this Adapter is done within the context of this
+        # Transaction.
+        #
+        # @return <DataMapper::Transaction> the 'current' transaction for this Adapter.
+        #
+        # TODO: move to dm-more/dm-transaction
+        def current_transaction
+          transactions(Thread.current).last
+        end
+
+        #
+        # Returns whether we are within a Transaction.
+        #
+        # @return <Boolean> whether we are within a Transaction.
+        #
+        # TODO: move to dm-more/dm-transaction
+        def within_transaction?
+          !current_transaction.nil?
+        end
+
+        #
+        # Produces a fresh transaction primitive for this Adapter
+        #
+        # Used by DataMapper::Transaction to perform its various tasks.
+        #
+        # @return <Object> a new Object that responds to :close, :begin, :commit,
+        #   :rollback, :rollback_prepared and :prepare
+        #
+        # TODO: move to dm-more/dm-transaction (if possible)
+        def transaction_primitive
+          raise NotImplementedError
+        end
+
+        private
+        def transactions(thread)
+          unless @transactions[thread]
+            @transactions.delete_if do |key, value|
+              !key.respond_to?(:alive?) || !key.alive?
+            end
+            @transactions[thread] = []
+          end
+          @transactions[thread]
+        end
+
+      end
+
+      include Transaction
+    end # class AbstractAdapter
+  end # module Adapters
+end # module DataMapper