ardm 0.0.1

data/lib/ardm/active_record/predicate_builder/rails4.rb

@@ -0,0 +1,139 @@
+require 'active_support/concern'
+
+module Ardm
+  module ActiveRecord
+    module PredicateBuilder
+      module Rails4
+        extend ActiveSupport::Concern
+
+        Base     = ::ActiveRecord::Base
+        Relation = ::ActiveRecord::Relation
+
+        included do
+          class << self
+            alias_method :original_build_from_hash, :build_from_hash
+          end
+
+          class_attribute :handlers
+          self.handlers = []
+
+          register_handler(BasicObject, ->(attribute, value) { attribute.eq(value) })
+          register_handler(Class, ->(attribute, value) { attribute.eq(value.name) })
+          register_handler(Base, ->(attribute, value) { attribute.eq(value.id) })
+          register_handler(Range, ->(attribute, value) { attribute.in(value) })
+          register_handler(Relation, RelationHandler.new)
+          register_handler(Array, ArrayHandler.new)
+        end
+
+        module ClassMethods
+          def resolve_column_aliases(klass, hash)
+            hash = hash.dup
+            hash.keys.grep(Symbol) do |key|
+              if klass.attribute_alias? key
+                hash[klass.attribute_alias(key)] = hash.delete key
+              end
+            end
+            hash
+          end
+
+          def build_from_hash(klass, attributes, default_table)
+            queries = []
+
+            #
+            # attributes {
+            #   Ardm::Query::Operator(target: :attr, operator: :not) =>
+            attributes.each do |column, value|
+              table = default_table
+
+              if value.is_a?(Hash)
+                if value.empty?
+                  queries << '1=0'
+                else
+                  table       = Arel::Table.new(column, default_table.engine)
+                  association = klass.reflect_on_association(column.to_sym)
+
+                  value.each do |k, v|
+                    queries.concat expand(association && association.klass, table, k, v)
+                  end
+                end
+              else
+                if Ardm::Query::Operator === column
+                  column = column.target.to_s
+                  operator = column.operator
+                else
+                  column = column.to_s
+                  operator = nil
+                end
+
+                if column.include?('.')
+                  table_name, column = column.split('.', 2)
+                  table = Arel::Table.new(table_name, default_table.engine)
+                end
+
+                queries.concat expand(klass, table, column, value)
+              end
+            end
+
+            queries
+          end
+
+          def expand(klass, table, column, value)
+            queries = []
+
+            # Find the foreign key when using queries such as:
+            # Post.where(author: author)
+            #
+            # For polymorphic relationships, find the foreign key and type:
+            # PriceEstimate.where(estimate_of: treasure)
+            if klass && value.is_a?(Base) && reflection = klass.reflect_on_association(column.to_sym)
+              if reflection.polymorphic?
+                queries << build(table[reflection.foreign_type], value.class.base_class)
+              end
+
+              column = reflection.foreign_key
+            end
+
+            queries << build(table[column], value)
+            queries
+          end
+
+          def references(attributes)
+            attributes.map do |key, value|
+              if value.is_a?(Hash)
+                key
+              else
+                key = key.to_s
+                key.split('.').first if key.include?('.')
+              end
+            end.compact
+          end
+
+          # Define how a class is converted to Arel nodes when passed to +where+.
+          # The handler can be any object that responds to +call+, and will be used
+          # for any value that +===+ the class given. For example:
+          #
+          #     MyCustomDateRange = Struct.new(:start, :end)
+          #     handler = proc do |column, range|
+          #       Arel::Nodes::Between.new(column,
+          #         Arel::Nodes::And.new([range.start, range.end])
+          #       )
+          #     end
+          #     ActiveRecord::PredicateBuilder.register_handler(MyCustomDateRange, handler)
+          def register_handler(klass, handler)
+            handlers.unshift([klass, handler])
+          end
+
+          private
+
+          def build(attribute, value)
+            handler_for(value).call(attribute, value)
+          end
+
+          def handler_for(object)
+            handlers.detect { |klass, _| klass === object }.last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ardm/active_record/predicate_builder/relation_handler.rb

@@ -0,0 +1,15 @@
+module Ardm
+  module ActiveRecord
+    module PredicateBuilder
+      class RelationHandler # :nodoc:
+        def call(attribute, value)
+          if value.select_values.empty?
+            value = value.select(value.klass.arel_table[value.klass.primary_key])
+          end
+
+          attribute.in(value.arel.ast)
+        end
+      end
+    end
+  end
+end

data/lib/ardm/active_record/predicate_builder.rb

@@ -0,0 +1,19 @@
+require 'active_record/relation/predicate_builder' # force it to load
+
+require 'ardm/active_record/predicate_builder/relation_handler'
+require 'ardm/active_record/predicate_builder/array_handler'
+
+if ::ActiveRecord::PredicateBuilder.respond_to? :expand
+  require 'ardm/active_record/predicate_builder/rails4'
+  ::ActiveRecord::PredicateBuilder.send(:include, Ardm::ActiveRecord::PredicateBuilder::Rails4)
+else
+  require 'ardm/active_record/predicate_builder/rails3'
+  ::ActiveRecord::PredicateBuilder.send(:include, Ardm::ActiveRecord::PredicateBuilder::Rails3)
+end
+
+::ActiveRecord::PredicateBuilder.class_eval do
+  # calls super instead of calling the method on the class
+  class << self
+    remove_method :build_from_hash
+  end
+end

data/lib/ardm/active_record/property.rb

@@ -0,0 +1,357 @@
+require 'active_support/concern'
+require 'ardm/property/lookup'
+
+module Ardm
+  module ActiveRecord
+    module Property
+      extend ActiveSupport::Concern
+
+      included do
+        extend Ardm::Property::Lookup
+        extend Ardm::ActiveRecord::Property::ClassMethods
+
+        instance_variable_set(:@properties, Ardm::PropertySet.new)
+        instance_variable_set(:@field_naming_convention, nil)
+        send :before_validation, :initialize_ardm_property_defaults
+      end
+
+      def self.extended(model)
+        raise "Please include #{self} instead of extend."
+      end
+
+      module ClassMethods
+
+        def inherited(model)
+          model.instance_variable_set(:@properties, Ardm::PropertySet.new)
+          model.instance_variable_set(:@field_naming_convention, @field_naming_convention)
+
+          model_properties = model.properties
+          @properties.each { |property| model_properties << property }
+
+          super
+        end
+
+        # Defines a Property on the Resource
+        #
+        # @param [Symbol] name
+        #   the name for which to call this property
+        # @param [Class] type
+        #   the ruby type to define this property as
+        # @param [Hash(Symbol => String)] options
+        #   a hash of available options
+        #
+        # @return [Property]
+        #   the created Property
+        #
+        # @see Property
+        #
+        # @api public
+        def property(name, type, options = {})
+          # if the type can be found within Property then
+          # use that class rather than the primitive
+          klass = Ardm::Property.determine_class(type)
+
+          unless klass
+            raise ArgumentError, "+type+ was #{type.inspect}, which is not a supported type"
+          end
+
+          property = klass.new(self, name, options)
+
+          self.properties << property
+
+          # add the property to the child classes only if the property was
+          # added after the child classes' properties have been copied from
+          # the parent
+          descendants.each do |descendant|
+            descendant.properties << property
+          end
+
+          serialize(property.field, property)
+
+          set_primary_key_for(property)
+          create_reader_for(property)
+          create_writer_for(property)
+          add_validations_for(property)
+
+          # FIXME: explicit return needed for YARD to parse this properly
+          return property
+        end
+
+        # Gets a list of all properties that have been defined on this Model
+        #
+        # @return [PropertySet]
+        #   A list of Properties defined on this Model in the given Repository
+        #
+        # @api public
+        def properties
+          @properties ||= PropertySet.new
+        end
+
+        def initialize_attributes(attributes, options = {})
+          super(attributes, options)
+
+          properties.each do |property|
+            if attributes.key?(property.name)
+              attributes[property.field] = attributes[property.name]
+            end
+          end
+
+          attributes
+        end
+
+        def columns
+          @columns ||= properties.map do |property|
+            sql_type = connection.type_to_sql(
+              property.dump_as.name.to_sym,
+              property.options[:limit],
+              property.options[:precision],
+              property.options[:scale]
+            )
+
+            column = ::ActiveRecord::ConnectionAdapters::Column.new(
+              #property.name.to_s,
+              property.field.to_s,
+              nil,#property.dump(property.default),
+              sql_type,
+              property.allow_nil?
+            )
+
+            column.primary = property.key?
+            column
+          end
+        end
+
+        # Hook into the query system when we would be finding composed_of
+        # fields in active record. This lets us mangle the query as needed.
+        #
+        # Every DM property needs to be dumped when it's being sent to a query.
+        # This also gives us a chance to handle aliased fields
+        def expand_hash_conditions_for_aggregates(*args)
+          dump_properties_hash(super)
+        end
+
+        def dump_properties_hash(options)
+          options.inject({}) do |new_attrs, (key, value)|
+            if property = properties[key]
+              new_attrs[property.field] = property.dump(value)
+            else
+              new_attrs[key] = value
+            end
+            new_attrs
+          end
+        end
+
+        # Gets the list of key fields for this Model
+        #
+        # @return [Array]
+        #   The list of key fields for this Model
+        #
+        # @api public
+        def key
+          properties.key
+        end
+
+        # @api public
+        def serial
+          key.detect { |property| property.serial? }
+        end
+
+        # Gets the field naming conventions for this resource in the given Repository
+        #
+        # @return [#call]
+        #   The naming convention for the given Repository
+        #
+        # @api public
+        def field_naming_convention
+          @field_naming_convention ||= lambda { |property| property.name.to_s.underscore }
+        end
+
+        # @api private
+        def properties_with_subclasses
+          props = properties.dup
+
+          descendants.each do |model|
+            model.properties.each do |property|
+              props << property
+            end
+          end
+
+          props
+        end
+
+        # @api private
+        def key_conditions(key)
+          Hash[ self.key.zip(key.nil? ? [] : key) ]
+        end
+
+      private
+
+        # Defines the anonymous module that is used to add properties.
+        # Using a single module here prevents having a very large number
+        # of anonymous modules, where each property has their own module.
+        # @api private
+        def property_module
+          @property_module ||= begin
+            mod = Module.new
+            class_eval do
+              include mod
+            end
+            mod
+          end
+        end
+
+        def set_primary_key_for(property)
+          if property.key? || property.serial?
+            self.primary_key = property.name
+          end
+        end
+
+        # defines the reader method for the property
+        #
+        # @api private
+        def create_reader_for(property)
+          return if property.key? || property.serial? # let AR do it
+          name                   = property.name.to_s
+          reader_visibility      = property.reader_visibility
+          instance_variable_name = property.instance_variable_name
+          property_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+            #{reader_visibility}
+            def #{name}
+              attribute_get(#{name.inspect})
+            end
+          RUBY
+
+          if property.kind_of?(Ardm::Property::Boolean)
+            boolean_reader_name = "#{name}?"
+            property_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+              #{reader_visibility}
+              def #{boolean_reader_name}
+                #{name}
+              end
+            RUBY
+          end
+        end
+
+        # defines the setter for the property
+        #
+        # @api private
+        def create_writer_for(property)
+          return if property.key? || property.serial? # let AR do it
+          name              = property.name
+          writer_visibility = property.writer_visibility
+
+          writer_name = "#{name}="
+          property_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+            #{writer_visibility}
+            def #{writer_name}(value)
+              attribute_set(#{name.inspect}, value)
+            end
+          RUBY
+        end
+
+        def add_validations_for(property)
+          return if property.key? || property.serial?
+          rules = Ardm::Property::Validation.rules_for_property(property)
+          rules.each do |options|
+            validates(property.name, options)
+          end
+        end
+
+        # @api public
+        # This confuses the rails
+        #
+        #def method_missing(method, *args, &block)
+        #  if property = properties[method]
+        #    return property
+        #  end
+
+        #  super
+        #end
+      end # module ClassMethods
+
+      # when exactly does a datamapper default property get set?
+      def initialize_ardm_property_defaults
+        return unless new_record?
+        self.class.properties.each do |property|
+          attribute_get(property.name) # assigns default on fetch
+        end
+        true
+      end
+
+      # This not the same as read_attribute in AR
+      def attribute_get(name)
+        property = self.class.properties[name]
+        val = read_attribute property.field
+        if new_record? && val.nil? && property.default?
+          write_attribute property.field, property.typecast(property.default_for(self))
+        end
+        read_attribute property.field
+      end
+
+      # This not the same as write_attribute in AR
+      def attribute_set(name, value)
+        property = self.class.properties[name]
+        write_attribute property.field, property.typecast(value)
+        read_attribute property.field
+      end
+
+      # Retrieve the key(s) for this resource.
+      #
+      # This always returns the persisted key value,
+      # even if the key is changed and not yet persisted.
+      # This is done so all relations still work.
+      #
+      # @return [Array(Key)]
+      #   the key(s) identifying this resource
+      #
+      # @api public
+      def key
+        return @_key if defined?(@_key)
+
+        model_key = self.class.key
+
+        key = model_key.map do |property|
+          changed_attributes[property.name] || (property.loaded?(self) ? property.get!(self) : nil)
+        end
+
+        # only memoize a valid key
+        @_key = key if model_key.valid?(key)
+      end
+
+      # Gets this instance's Model's properties
+      #
+      # @return [PropertySet]
+      #   List of this Resource's Model's properties
+      #
+      # @api private
+      def properties
+        self.class.properties
+      end
+
+      # Fetches all the names of the attributes that have been loaded,
+      # even if they are lazy but have been called
+      #
+      # @return [Array<Property>]
+      #   names of attributes that have been loaded
+      #
+      # @api private
+      def fields
+        properties.select do |property|
+          property.loaded?(self) || (new_record? && property.default?)
+        end
+      end
+
+      # Reset the key to the original value
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def reset_key
+        properties.key.zip(key) do |property, value|
+          property.set!(self, value)
+        end
+      end
+
+    end # module Property
+  end # module Rails
+end # module Ardm

data/lib/ardm/active_record/query.rb

@@ -0,0 +1,108 @@
+require 'active_support/concern'
+
+require 'ardm/query/expression'
+require 'ardm/query/operator'
+require 'ardm/query/ext/symbol'
+require 'ardm/active_record/predicate_builder'
+
+module Ardm
+  module ActiveRecord
+    module Query
+      extend ActiveSupport::Concern
+
+      def self.order(model, ord)
+        case ord
+        when Array
+          ord.map {|o| order(model, o) }.join(", ")
+        when Ardm::Query::Operator
+          field = ord.target
+          if property = model.properties[field]
+            field = property.field
+          end
+          "#{field} #{ord.operator.upcase}"
+        else
+          ord
+        end
+      end
+
+      module ClassMethods
+        # hook into query engine in the most general way possible
+        def expand_hash_conditions_for_aggregates(options)
+          complex, simple = options.partition {|k,v| Ardm::Query::Operator === k }
+          result = super(Hash[simple]) # send simple all at once to save computation
+          complex.each do |(operator, value)|
+            expanded_opts = super(operator.target => value)
+
+            if expanded_opts.size > 1
+              $stderr.puts "WARNING: Operator #{operator.target.inspect} on multiple attribute aggregate #{expanded_opts.inspect} might be totally crazyballs."
+            end
+
+            expanded_opts.each do |new_key, new_val|
+              new_operator = Ardm::Query::Operator.new(new_key, operator.operator)
+              result[new_operator] = new_val
+            end
+          end
+
+          # This hack allows access to the original class from within the PredicateBuilder (so hax)
+          class << result
+            attr_accessor :klass
+          end
+          result.klass = self
+          result
+        end
+
+        def get(id)
+          all(id: id).first
+        end
+
+        def get!(id)
+          find(id)
+        end
+
+        def first_or_create(find_params)
+          all(find_params).first_or_create
+        end
+
+        def first_or_create!(find_params)
+          all(find_params).first_or_create!
+        end
+
+        def first_or_initialize(find_params)
+          all(find_params).first_or_initialize
+        end
+
+        #def first(args=nil)
+        #  if Hash === args
+        #    all(args).first
+        #  else
+        #    puts "#{self}.first(#{args.inspect})"
+        #    puts caller[0..1]
+        #    super(args)
+        #  end
+        #end
+
+        #def all(options={})
+        #  puts "#{self}.all(#{options.inspect})"
+        #  puts caller[0..1]
+        #  binding.pry if options[:account]
+        #  Ardm::Query.all(self, options)
+        #end
+
+        #def exist?(options={})
+        #  puts "#{self}.exist?(#{options.inspect})"
+        #  puts caller[0..10]
+        #  options.empty? ? super : all(options).exist?
+        #end
+
+        #def count(options={})
+        #  puts "#{self}.count(#{options.inspect})"
+        #  puts caller[0..10]
+        #  $visited ||= 0
+        #  puts $visited += 1
+        #  raise if $visited > 10
+        #  options.empty? ? super : all(options).count
+        #end
+      end
+    end
+  end
+end

data/lib/ardm/active_record/record.rb

@@ -0,0 +1,70 @@
+require 'active_record'
+require 'ardm'
+require 'ardm/active_record/base'
+
+module Ardm
+  module ActiveRecord
+    class Record < ::ActiveRecord::Base
+      include Ardm::ActiveRecord::Base
+
+      self.abstract_class = true
+
+      JSON = Json
+
+      def self.finalize
+      end
+
+      def self.execute_sql(sql)
+        connection.execute(sql)
+      end
+
+      def self.property(property_name, property_type, options={})
+        property = super
+        begin
+        attr_accessible property.name
+        attr_accessible property.field
+        rescue => e
+          puts "WARNING: Error silenced. FIXME before release.\n#{e}"
+        end
+        property
+      end
+
+      # no-op in active record
+      def self.timestamps(*a)
+      end
+
+      def key
+        id
+      end
+
+      def new?
+        new_record?
+      end
+
+      def save_self(*)
+        save
+      end
+
+      def update(*a)
+        if a.size == 1
+          update_attributes(*a)
+        else
+          super
+        end
+      end
+
+      def update!(*a)
+        update_attributes!(*a)
+      end
+
+      #active record internals for detecting if this method should exist as an attribute
+      #if attribute_method_matcher(:open)
+      #  def open
+      #    read_attribute(:open)
+      #    #attribute_missing(match, *args, &block)
+      #  end
+      #end
+
+    end
+  end
+end