ardm 0.0.1

data/lib/ardm/property_set.rb

@@ -0,0 +1,152 @@
+require 'ardm/support/subject_set'
+require 'ardm/property/discriminator'
+
+module Ardm
+  # Set of Property objects, used to associate
+  # queries with set of fields it performed over,
+  # to represent composite keys (esp. for associations)
+  # and so on.
+  class PropertySet < SubjectSet
+    include Enumerable
+
+    def <<(property)
+      clear_cache
+      super
+    end
+
+    # Make sure that entry is part of this PropertySet
+    #
+    # @param [#to_s] name
+    # @param [#name] entry
+    #
+    # @return [#name]
+    #   the entry that is now part of this PropertySet
+    #
+    # @api semipublic
+    def []=(name, entry)
+      warn "#{self.class}#[]= is deprecated. Use #{self.class}#<< instead: #{caller.first}"
+      raise "#{entry.class} is not added with the correct name" unless name && name.to_s == entry.name.to_s
+      self << entry
+      entry
+    end
+
+    def |(other)
+      raise(ArgumentError, "Cannot coerce #{other.inspect} into an array") unless other.respond_to?(:to_a)
+      self.class.new(to_a | other.to_a)
+    end
+
+    def &(other)
+      raise(ArgumentError, "Cannot coerce #{other.inspect} into an array") unless other.respond_to?(:to_a)
+      self.class.new(to_a & other.to_a)
+    end
+
+    def -(other)
+      raise(ArgumentError, "Cannot coerce #{other.inspect} into an array") unless other.respond_to?(:to_a)
+      self.class.new(to_a - other.to_a)
+    end
+
+    def +(other)
+      raise(ArgumentError, "Cannot coerce #{other.inspect} into an array") unless other.respond_to?(:to_a)
+      self.class.new(to_a + other.to_a)
+    end
+
+    def ==(other)
+      other.respond_to?(:to_a) && to_a == other.to_a
+    end
+
+    # TODO: make PropertySet#reject return a PropertySet instance
+    # @api semipublic
+    def defaults
+      @defaults ||= self.class.new(key | [ discriminator ].compact | reject { |property| property.lazy? }).freeze
+    end
+
+    # @api semipublic
+    def key
+      @key ||= self.class.new(select { |property| property.key? }).freeze
+    end
+
+    # @api semipublic
+    def discriminator
+      @discriminator ||= detect { |property| property.kind_of?(Property::Discriminator) }
+    end
+
+    # @api semipublic
+    def indexes
+      index_hash = {}
+      each { |property| parse_index(property.index, property.field, index_hash) }
+      index_hash
+    end
+
+    # @api semipublic
+    def unique_indexes
+      index_hash = {}
+      each { |property| parse_index(property.unique_index, property.field, index_hash) }
+      index_hash
+    end
+
+    # @api semipublic
+    def get(resource)
+      return [] if resource.nil?
+      map { |property| resource.__send__(property.name) }
+    end
+
+    # @api semipublic
+    def get!(resource)
+      map { |property| property.get!(resource) }
+    end
+
+    # @api semipublic
+    def set(resource, values)
+      zip(values) { |property, value| resource.__send__("#{property.name}=", value) }
+    end
+
+    # @api semipublic
+    def set!(resource, values)
+      zip(values) { |property, value| property.set!(resource, value) }
+    end
+
+    # @api semipublic
+    def loaded?(resource)
+      all? { |property| property.loaded?(resource) }
+    end
+
+    # @api semipublic
+    def valid?(values)
+      zip(values.nil? ? [] : values).all? { |property, value| property.valid?(value) }
+    end
+
+    # @api semipublic
+    def typecast(values)
+      zip(values.nil? ? [] : values).map { |property, value| property.typecast(value) }
+    end
+
+    # @api private
+    def field_map
+      Hash[ map { |property| [ property.field, property ] } ]
+    end
+
+    def inspect
+      to_a.inspect
+    end
+
+    private
+
+    # @api private
+    def clear_cache
+      @defaults, @key, @discriminator = nil
+    end
+
+    # @api private
+    def parse_index(index, property, index_hash)
+      case index
+        when true
+          index_hash[property] = [ property ]
+        when Symbol
+          index_hash[index] ||= []
+          index_hash[index] << property
+        when Array
+          index.each { |idx| parse_index(idx, property, index_hash) }
+      end
+    end
+  end # class PropertySet
+end # module Ardm

data/lib/ardm/query/expression.rb

@@ -0,0 +1,85 @@
+module Ardm
+  module Query
+    class Expression
+      attr_reader :relation, :target, :operator, :value
+
+      def self.build_scope(relation, target, value)
+        new(relation, target, value).scope
+      end
+
+      def initialize(relation, target, value)
+        @relation   = relation
+        @value      = value
+
+        case target
+        when Ardm::Query::Operator
+          @target   = target.target
+          @operator = target.operator
+        when Symbol, String
+          @target = target
+          @operator = :eq
+        else
+          raise ArgumentError, "Unknown target #{target.inspect} in Expresion"
+        end
+      end
+
+      def resolved_target
+        target_from_association || target
+      end
+
+      def arel_target
+        arel_table[resolved_target]
+      end
+
+      def to_arel
+        arel_target.send(arel_operator, arel_value)
+      end
+
+      def scope
+        relation.where to_arel
+      end
+
+      private
+
+      def arel_table
+        relation.arel_table
+      end
+
+      def association
+        @association ||= relation.reflect_on_association(target)
+      end
+
+      def target_from_association
+        if association
+          if association.macro == :belongs_to
+            association.foreign_key.to_sym
+          else
+            $stderr.puts "WARNING: #{association.macro} based queries not yet supported?"
+            association.primary_key.to_sym
+          end
+        end
+      end
+
+      def arel_operator
+        value.respond_to?(:to_ary) ? operator.for_array : operator
+      end
+
+      def arel_value(val = value)
+        if val.respond_to?(:to_ary)
+          return val.map {|v| arel_value(v) }
+        end
+
+        case val
+        when ::ActiveRecord::Base
+          val.id
+        when ::ActiveRecord::Relation
+          arel_value(val.to_ary)
+        when ::Array
+          val.map {|v| arel_value(v) }
+        else
+          val
+        end
+      end
+    end
+  end
+end

data/lib/ardm/query/ext/symbol.rb

@@ -0,0 +1,37 @@
+require 'ardm/query/operator'
+
+module Ardm
+  module Query
+    module Ext
+      module Symbol
+        Ardm::Query::Operator::OPERATORS.each do |dm, arel|
+          define_method dm do
+            Ardm::Query::Operator.new(self, arel)
+          end
+          #class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          #  def #{dm}
+          #    #{"raise \"explicit use of '#{dm}' operator is deprecated (#{caller.first})\"" if dm == :eql || dm == :in}
+          #    Ardm::Query::Operator.new(self, #{arel.inspect})
+          #  end
+          #RUBY
+        end
+
+        # FIXME: handle aliased columns
+        # It's easier to turn these into strings for now,
+        # but I think it will break for aliased columns.
+        Ardm::Query::Operator::ORDERS.each do |dm, arel|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{dm}
+              "\#{self} #{arel.upcase}"
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end
+
+class ::Symbol
+  Ardm::Query::Operator::ALL.keys.each { |meth| method_defined?(meth) && remove_method(meth) }
+  include Ardm::Query::Ext::Symbol
+end # class Symbol

data/lib/ardm/query/operator.rb

@@ -0,0 +1,64 @@
+require 'ardm/support/equalizer'
+module Ardm
+  module Query
+    class Operator
+      extend Ardm::Equalizer
+
+      OPERATORS = {
+        # DM      => ARel
+        :eql      => :eq,
+        :not      => :not,
+        :in       => :in,
+        :gt       => :gt,
+        :gte      => :gteq,
+        :lt       => :lt,
+        :lte      => :lteq,
+        :like     => :matches,
+        :not_like => :does_not_match,
+        :regexp   => :regexp,
+      }
+
+      ORDERS = {
+        :asc  => :asc,
+        :desc => :desc,
+      }
+
+      ALL = OPERATORS.merge(ORDERS)
+
+      equalize :target, :operator
+
+      # @api private
+      attr_reader :target
+
+      # @api private
+      attr_reader :operator
+
+      # @api private
+      def inspect
+        "#<#{self.class.name} #{target.inspect}.#{operator.inspect}>"
+      end
+
+      FOR_ARRAY = {
+        :eq     => :in,
+        :not_eq => :not_in
+      }.freeze
+
+      def for_array
+        FOR_ARRAY[operator]
+      end
+
+      def to_arel(arel_table, value)
+        Ardm::Query::Expression.new(arel_table, target, operator, value)
+      end
+
+      private
+
+      # @api private
+      def initialize(target, operator)
+        @target, @operator = target, operator.to_sym
+      end
+    end # class Operator
+  end # module Query
+end # module Ardm
+
+require 'ardm/query/ext/symbol'

data/lib/ardm/record.rb

@@ -0,0 +1 @@
+require "ardm/#{Ardm.orm}/record"

data/lib/ardm/support/assertions.rb

@@ -0,0 +1,8 @@
+module Ardm
+  module Assertions
+    def assert_kind_of(name, value, *klasses)
+      klasses.each { |k| return if value.kind_of?(k) }
+      raise ArgumentError, "+#{name}+ should be #{klasses.map { |k| k.name } * ' or '}, but was #{value.class.name}", caller(2)
+    end
+  end
+end

data/lib/ardm/support/deprecate.rb

@@ -0,0 +1,12 @@
+module Ardm
+  module Deprecate
+    def deprecate(old_method, new_method)
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{old_method}(*args, &block)
+          warn "\#{self.class}##{old_method} is deprecated, use \#{self.class}##{new_method} instead (\#{caller.first})"
+          send(#{new_method.inspect}, *args, &block)
+        end
+      RUBY
+    end
+  end # module Deprecate
+end # module Ardm

data/lib/ardm/support/descendant_set.rb

@@ -0,0 +1,89 @@
+module Ardm
+  class DescendantSet
+    include Enumerable
+
+    # Initialize a DescendantSet instance
+    #
+    # @param [#to_ary] descendants
+    #   initialize with the descendants
+    #
+    # @api private
+    def initialize(descendants = [])
+      @descendants = SubjectSet.new(descendants)
+    end
+
+    # Copy a DescendantSet instance
+    #
+    # @param [DescendantSet] original
+    #   the original descendants
+    #
+    # @api private
+    def initialize_copy(original)
+      @descendants = @descendants.dup
+    end
+
+    # Add a descendant
+    #
+    # @param [Module] descendant
+    #
+    # @return [DescendantSet]
+    #   self
+    #
+    # @api private
+    def <<(descendant)
+      @descendants << descendant
+      self
+    end
+
+    # Remove a descendant
+    #
+    # Also removes from all descendants
+    #
+    # @param [Module] descendant
+    #
+    # @return [DescendantSet]
+    #   self
+    #
+    # @api private
+    def delete(descendant)
+      @descendants.delete(descendant)
+      each { |d| d.descendants.delete(descendant) }
+    end
+
+    # Iterate over each descendant
+    #
+    # @yield [descendant]
+    # @yieldparam [Module] descendant
+    #
+    # @return [DescendantSet]
+    #   self
+    #
+    # @api private
+    def each
+      @descendants.each do |descendant|
+        yield descendant
+        descendant.descendants.each { |dd| yield dd }
+      end
+      self
+    end
+
+    # Test if there are any descendants
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def empty?
+      @descendants.empty?
+    end
+
+    # Removes all entries and returns self
+    #
+    # @return [DescendantSet] self
+    #
+    # @api private
+    def clear
+      @descendants.clear
+    end
+
+  end # class DescendantSet
+end # module Ardm

data/lib/ardm/support/equalizer.rb

@@ -0,0 +1,48 @@
+module Ardm
+  module Equalizer
+    def equalize(*methods)
+      define_eql_method(methods)
+      define_equivalent_method(methods)
+      define_hash_method(methods)
+    end
+
+    private
+
+    def define_eql_method(methods)
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def eql?(other)
+          return true if equal?(other)
+          instance_of?(other.class) &&
+          #{methods.map { |method| "#{method}.eql?(other.#{method})" }.join(' && ')}
+        end
+      RUBY
+    end
+
+    def define_equivalent_method(methods)
+      respond_to = []
+      equivalent = []
+
+      methods.each do |method|
+        respond_to << "other.respond_to?(#{method.inspect})"
+        equivalent << "#{method} == other.#{method}"
+      end
+
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def ==(other)
+          return true if equal?(other)
+          return false unless kind_of?(other.class) || other.kind_of?(self.class)
+          #{respond_to.join(' && ')} &&
+          #{equivalent.join(' && ')}
+        end
+      RUBY
+    end
+
+    def define_hash_method(methods)
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def hash
+          self.class.hash ^ #{methods.map { |method| "#{method}.hash" }.join(' ^ ')}
+        end
+      RUBY
+    end
+  end
+end

data/lib/ardm/support/ext/array.rb

@@ -0,0 +1,22 @@
+module Ardm; module Ext
+  module Array
+    # Transforms an Array of key/value pairs into a {Mash}.
+    #
+    # This is a better idiom than using Mash[*array.flatten] in Ruby 1.8.6
+    # because it is not possible to limit the flattening to a single
+    # level.
+    #
+    # @param [Array] array
+    #   The array of key/value pairs to transform.
+    #
+    # @return [Mash]
+    #   A {Mash} where each entry in the Array is turned into a key/value.
+    #
+    # @api semipublic
+    def self.to_mash(array)
+      m = Mash.new
+      array.each { |k,v| m[k] = v }
+      m
+    end
+  end # class Array
+end; end

data/lib/ardm/support/ext/blank.rb

@@ -0,0 +1,25 @@
+module Ardm
+  module Ext
+    # Determines whether the specified +value+ is blank.
+    #
+    # An object is blank if it's false, empty, or a whitespace string.
+    # For example, "", "   ", +nil+, [], and {} are blank.
+    #
+    # @api semipublic
+    def self.blank?(value)
+      return value.blank? if value.respond_to?(:blank?)
+      case value
+      when ::NilClass, ::FalseClass
+        true
+      when ::TrueClass, ::Numeric
+        false
+      when ::Array, ::Hash
+        value.empty?
+      when ::String
+        value !~ /\S/
+      else
+        value.nil? || (value.respond_to?(:empty?) && value.empty?)
+      end
+    end
+  end
+end

data/lib/ardm/support/ext/hash.rb

@@ -0,0 +1,67 @@
+module Ardm; module Ext
+  module Hash
+    # Creates a hash with *only* the specified key/value pairs from +hash+.
+    #
+    # @param [Hash] hash The hash from which to pick the key/value pairs.
+    # @param [Array] *keys The hash keys to include.
+    #
+    # @return [Hash] A new hash with only the selected keys.
+    #
+    # @example
+    #   hash = { :one => 1, :two => 2, :three => 3 }
+    #   Ext::Hash.only(hash, :one, :two) # => { :one => 1, :two => 2 }
+    #
+    # @api semipublic
+    def self.only(hash, *keys)
+      h = {}
+      keys.each {|k| h[k] = hash[k] if hash.has_key?(k) }
+      h
+    end
+
+    # Returns a hash that includes everything but the given +keys+.
+    #
+    # @param [Hash] hash The hash from which to pick the key/value pairs.
+    # @param [Array] *keys The hash keys to exclude.
+    #
+    # @return [Hash] A new hash without the specified keys.
+    #
+    # @example
+    #   hash = { :one => 1, :two => 2, :three => 3 }
+    #   Ext::Hash.except(hash, :one, :two) # => { :three => 3 }
+    #
+    # @api semipublic
+    def self.except(hash, *keys)
+      self.except!(hash.dup, *keys)
+    end
+
+    # Removes the specified +keys+ from the given +hash+.
+    #
+    # @param [Hash] hash The hash to modify.
+    # @param [Array] *keys The hash keys to exclude.
+    #
+    # @return [Hash] +hash+
+    #
+    # @example
+    #   hash = { :one => 1, :two => 2, :three => 3 }
+    #   Ext::Hash.except!(hash, :one, :two)
+    #   hash # => { :three => 3 }
+    #
+    # @api semipublic
+    def self.except!(hash, *keys)
+      keys.each { |key| hash.delete(key) }
+      hash
+    end
+
+    # Converts the specified +hash+ to a {Mash}.
+    #
+    # @param [Hash] hash The hash to convert.
+    # @return [Mash] The {Mash} for the specified +hash+.
+    #
+    # @api semipublic
+    def self.to_mash(hash)
+      h = Mash.new(hash)
+      h.default = hash.default
+      h
+    end
+  end
+end; end

data/lib/ardm/support/ext/module.rb

@@ -0,0 +1,47 @@
+module Ardm; module Ext
+  module Module
+
+    # @api semipublic
+    def self.find_const(mod, const_name)
+      if const_name[0..1] == '::'
+        Ardm::Ext::Object.full_const_get(const_name[2..-1])
+      else
+        nested_const_lookup(mod, const_name)
+      end
+    end
+
+  private
+
+    # Doesn't do any caching since constants can change with remove_const
+    def self.nested_const_lookup(mod, const_name)
+      unless mod.equal?(::Object)
+        constants = []
+
+        mod.name.split('::').each do |part|
+          const = constants.last || ::Object
+          constants << const.const_get(part)
+        end
+
+        parts = const_name.split('::')
+
+        # from most to least specific constant, use each as a base and try
+        # to find a constant with the name const_name within them
+        constants.reverse_each do |const|
+          # return the nested constant if available
+          return const if parts.all? do |part|
+            const = if RUBY_VERSION >= '1.9.0'
+              const.const_defined?(part, false) ? const.const_get(part, false) : nil
+            else
+              const.const_defined?(part) ? const.const_get(part) : nil
+            end
+          end
+        end
+      end
+
+      # no relative constant found, fallback to an absolute lookup and
+      # use const_missing if not found
+      Ardm::Ext::Object.full_const_get(const_name)
+    end
+
+  end
+end; end