ardm 0.0.1

data/lib/ardm/active_record/relation.rb

@@ -0,0 +1,83 @@
+require 'active_support/concern'
+require 'active_record'
+
+module Ardm
+  module ActiveRecord
+    module Relation
+      extend ActiveSupport::Concern
+
+      included do
+        alias_method :destory_without_ardm, :destroy
+        alias_method :update_without_ardm, :update
+
+        # we need to overrite the implementation in the class
+        class_eval do
+          def update(*a)
+            if a.size == 1
+              # need to translate attributes
+              options = @klass.send(:dump_properties_hash, a.first)
+              update_all(options)
+            else
+              update_without_ardm(*a)
+            end
+          end
+
+          def destroy(id = nil)
+            if id
+              destroy_without_ardm(id)
+            else
+              destroy_all
+            end
+          end
+
+          def first_or_create(attributes = nil, options = {}, &block)
+            first(attributes) || create(attributes, options, &block)
+          end
+
+          def first_or_create!(attributes = nil, options = {}, &block)
+            first(attributes) || create!(attributes, options, &block)
+          end
+
+          def first_or_initialize(attributes = nil, options = {}, &block)
+            first(attributes) || create(attributes, options, &block)
+          end
+        end
+      end
+
+      def all(options={})
+        apply_finder_options(options)
+      end
+
+      def apply_finder_options(options)
+        return super if options.nil? || options.empty?
+        options = options.dup
+        conditions = options.slice!(*::ActiveRecord::SpawnMethods::VALID_FIND_OPTIONS)
+        super(options).where(conditions)
+      end
+
+      def calculate(operation, column_name, options={})
+        if property = properties[column_name]
+          column_name = property.field
+        end
+        super(operation, column_name, options)
+      end
+
+      def method_missing(meth, *a, &b)
+        if a.empty? && association = reflect_on_association(meth.to_sym)
+          case association.macro
+          when :belongs_to
+            association.klass.where(klass.primary_key => self.select(association.foreign_key))
+          when :has_many, :has_one
+            association.klass.where(association.foreign_key => self.clone)
+          end
+        else
+          super
+        end
+      end
+
+      def destroy!
+        delete_all
+      end
+    end
+  end
+end

data/lib/ardm/active_record/repository.rb

@@ -0,0 +1,38 @@
+require 'active_support/concern'
+
+module Ardm
+  module ActiveRecord
+    module Repository
+      extend ActiveSupport::Concern
+
+      def repository
+        self.class.repository
+      end
+
+      module ClassMethods
+        def repository
+          if block_given?
+            yield
+          else
+            Ardm::ActiveRecord::Repository::Proxy.new self
+          end
+        end
+      end
+
+      class Proxy
+        def initialize(model)
+          @model = model
+        end
+
+        def adapter
+          self
+        end
+
+        def select(*args)
+          array_of_hashes = @model.connection.select_all(@model.send(:sanitize_sql_array, args))
+          array_of_hashes.map { |h| Hashie::Mash.new(h) }
+        end
+      end
+    end
+  end
+end

data/lib/ardm/active_record/serialization.rb

@@ -0,0 +1,164 @@
+require 'active_support/concern'
+
+module Ardm
+  module ActiveRecord
+    module Serialization
+      extend ActiveSupport::Concern
+
+      included do
+        # Returns a hash of all the attributes that have been specified for
+        # serialization as keys and their class restriction as values.
+        class_attribute :serialized_attributes, instance_accessor: false
+        self.serialized_attributes = {}
+      end
+
+      module ClassMethods
+        ##
+        # :method: serialized_attributes
+        #
+        # Returns a hash of all the attributes that have been specified for
+        # serialization as keys and their class restriction as values.
+
+        # If you have an attribute that needs to be saved to the database as an
+        # object, and retrieved as the same object, then specify the name of that
+        # attribute using this method and it will be handled automatically. The
+        # serialization is done through YAML. If +class_name+ is specified, the
+        # serialized object must be of that class on retrieval or
+        # <tt>SerializationTypeMismatch</tt> will be raised.
+        #
+        # ==== Parameters
+        #
+        # * +attr_name+ - The field name that should be serialized.
+        # * +class_name+ - Optional, class name that the object type should be equal to.
+        #
+        # ==== Example
+        #
+        #   # Serialize a preferences attribute.
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences
+        #   end
+        def serialize(attr_name, class_name = Object)
+          include Behavior
+
+          coder = if [:load, :dump].all? { |x| class_name.respond_to?(x) }
+                    class_name
+                  else
+                    Coders::YAMLColumn.new(class_name)
+                  end
+
+          # merge new serialized attribute and create new hash to ensure that each class in inheritance hierarchy
+          # has its own hash of own serialized attributes
+          self.serialized_attributes = serialized_attributes.merge(attr_name.to_s => coder)
+        end
+      end
+
+      # *DEPRECATED*: Use ActiveRecord::AttributeMethods::Serialization::ClassMethods#serialized_attributes class level method instead.
+      def serialized_attributes
+        message = "Instance level serialized_attributes method is deprecated, please use class level method."
+        ActiveSupport::Deprecation.warn message
+        defined?(@serialized_attributes) ? @serialized_attributes : self.class.serialized_attributes
+      end
+
+      class Type # :nodoc:
+        def initialize(column)
+          @column = column
+        end
+
+        def type_cast(value)
+          if value.state == :serialized
+            value.unserialized_value @column.type_cast value.value
+          else
+            value.unserialized_value
+          end
+        end
+
+        def type
+          @column.type
+        end
+      end
+
+      class Attribute < Struct.new(:coder, :value, :state) # :nodoc:
+        def unserialized_value(v = value)
+          state == :serialized ? unserialize(v) : value
+        end
+
+        def serialized_value
+          state == :unserialized ? serialize : value
+        end
+
+        def unserialize(v)
+          self.state = :unserialized
+          self.value = coder.load(v)
+        end
+
+        def serialize
+          self.state = :serialized
+          self.value = coder.dump(value)
+        end
+      end
+
+      # This is only added to the model when serialize is called, which
+      # ensures we do not make things slower when serialization is not used.
+      module Behavior # :nodoc:
+        extend ActiveSupport::Concern
+
+        module ClassMethods # :nodoc:
+          def initialize_attributes(attributes, options = {})
+            serialized = (options.delete(:serialized) { true }) ? :serialized : :unserialized
+            super(attributes, options)
+
+            serialized_attributes.each do |key, coder|
+              if attributes.key?(key)
+                attributes[key] = Attribute.new(coder, attributes[key], serialized)
+              end
+            end
+
+            attributes
+          end
+        end
+
+        def type_cast_attribute_for_write(column, value)
+          if column && coder = self.class.serialized_attributes[column.name]
+            Attribute.new(coder, value, :unserialized)
+          else
+            super
+          end
+        end
+
+        def _field_changed?(attr, old, value)
+          if self.class.serialized_attributes.include?(attr)
+            old != value
+          else
+            super
+          end
+        end
+
+        def read_attribute_before_type_cast(attr_name)
+          if self.class.serialized_attributes.include?(attr_name)
+            super.unserialized_value
+          else
+            super
+          end
+        end
+
+        def attributes_before_type_cast
+          super.dup.tap do |attributes|
+            self.class.serialized_attributes.each_key do |key|
+              if attributes.key?(key)
+                attributes[key] = attributes[key].unserialized_value
+              end
+            end
+          end
+        end
+
+        def typecasted_attribute_value(name)
+          if self.class.serialized_attributes.include?(name)
+            @attributes[name].serialized_value
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ardm/active_record/storage_names.rb

@@ -0,0 +1,28 @@
+require 'active_support/concern'
+
+module Ardm
+  module ActiveRecord
+    module StorageNames
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def storage_names
+          Ardm::ActiveRecord::StorageNames::Proxy.new(self)
+        end
+      end
+
+      class Proxy
+        def initialize(model)
+          @model = model
+        end
+
+        def []=(repo, table_name)
+          unless repo == :default
+            raise ArgumentError, "repositories other than :default not supported."
+          end
+          @model.table_name = table_name
+        end
+      end
+    end
+  end
+end

data/lib/ardm/active_record/validations.rb

@@ -0,0 +1,111 @@
+require 'active_support/concern'
+require 'active_model/validations'
+
+module Ardm
+  module ActiveRecord
+    # Extend ActiveRecord to support DataMapper validations
+    module Validations
+      extend ActiveSupport::Concern
+
+      include ActiveModel::Validations
+
+      # Extract and convert options from DM style to AR style
+      def self.extract_options(fields, *keep)
+        keep += [:on, :message, :if, :unless]
+
+        if Hash === fields.last
+          ar = fields.pop.dup
+          ar[:on]      = ar.delete(:when) if ar[:when] && [:create, :update].include?(ar[:when])
+          ar[:maximum] = ar.delete(:max)  if ar[:max]
+          ar[:in]      = ar.delete(:set)  if ar[:set]
+
+          removed = ar.slice!(*keep)
+          unless removed.empty?
+            $stderr.puts "WARNING validation options not handled: #{removed.inspect} in:"
+            $stderr.puts caller[0..1]
+          end
+        else
+          ar = {}
+        end
+
+        [fields, ar]
+      end
+
+      module ClassMethods
+
+        def validates_belongs_to(*fields)
+          fields, options = Ardm::ActiveRecord::Validations.extract_options(fields)
+          validates *fields, presence: options
+        end
+
+        def validates_presence_of(*fields)
+          fields, options = Ardm::ActiveRecord::Validations.extract_options(fields)
+          validates *fields, presence: options
+        end
+
+        def validates_length_of(*fields)
+          fields, options = Ardm::ActiveRecord::Validations.extract_options(fields, :in, :within, :maximum, :minimum, :is)
+          validates *fields, length: options
+        end
+
+        def validates_uniqueness_of(*fields)
+          fields, options = Ardm::ActiveRecord::Validations.extract_options(fields, :scope)
+          fields = fields.map do |field|
+            if property = properties[field]
+              property.field
+            elsif assoc = reflect_on_association(field)
+              assoc.foreign_key
+            else
+              field
+            end
+          end
+
+          if options[:scope]
+            options[:scope] = Array(options[:scope]).map do |scope|
+              assoc = reflect_on_association(scope)
+              assoc ? assoc.foreign_key : scope
+            end
+          end
+
+          validates *fields, uniqueness: options
+        end
+
+        def validates_within(*fields)
+          fields, options = Ardm::ActiveRecord::Validations.extract_options(fields, :in)
+          validates *fields, inclusion: options
+        end
+
+        # Possible formats:
+        #
+        # validates_with_method :attr, :method_name
+        # validates_with_method :attr, method: :method_name
+        # validates_with_method :method_name, options: "here"
+        def validates_with_method(*fields)
+          fields, options = Ardm::ActiveRecord::Validations.extract_options(fields, :method)
+
+          # validates_with_method :attr, :method_name
+          att, meth = *fields
+
+          # validates_with_method :attr, method: :method_name
+          meth = options[:method] if options[:method]
+
+          # validates_with_method :method_name
+          att, meth = :base, att if !meth
+
+          validates_with_block(att) do
+            self.send(meth)
+          end
+        end
+
+        def validates_with_block(att=nil, &block)
+          validate do |record|
+            val, message = instance_eval(&block)
+            unless val
+              errors.add(att, message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ardm/active_record.rb

@@ -0,0 +1,43 @@
+puts __FILE__
+require 'ardm'
+
+# only load support libs in active record mode (dm will supply its own libs)
+require 'ardm/support/ext/blank'
+require 'ardm/support/ext/hash'
+require 'ardm/support/ext/object'
+require 'ardm/support/ext/string'
+
+require 'ardm/support/ext/module'
+require 'ardm/support/ext/array'
+require 'ardm/support/ext/try_dup'
+
+require 'ardm/support/mash'
+require 'ardm/support/deprecate'
+require 'ardm/support/descendant_set'
+require 'ardm/support/equalizer'
+require 'ardm/support/assertions'
+require 'ardm/support/lazy_array'
+require 'ardm/support/local_object_space'
+require 'ardm/support/hook'
+require 'ardm/support/subject'
+require 'ardm/support/ordered_set'
+require 'ardm/support/subject_set'
+require 'ardm/support/descendant_set'
+
+require 'active_record'
+require 'active_record/relation'
+
+require 'ardm/active_record/record'
+require 'ardm/active_record/relation'
+
+module Ardm
+  Record = Ardm::ActiveRecord::Record
+end
+
+#::ActiveRecord::Base.class_eval do
+#  include Ardm::ActiveRecord::Base
+#end
+
+::ActiveRecord::Relation.class_eval do
+  include Ardm::ActiveRecord::Relation
+end

data/lib/ardm/data_mapper/not_found.rb

@@ -0,0 +1,5 @@
+module Ardm
+  class Record
+    NotFound = DataMapper::ObjectNotFoundError
+  end
+end

data/lib/ardm/data_mapper/record.rb

@@ -0,0 +1,41 @@
+require 'awsm/resource'
+
+module Ardm
+  module DataMapper
+    module Record
+      extend ActiveSupport::Concern
+
+      NotFound = DataMapper::ObjectNotFoundError
+
+      module ClassMethods
+        def inherited(base)
+          base.send(:include, DataMapper::Resource)
+          base.send(:include, Awsm::Resource)
+          #base.send(:extend, DataMapper::CollectionRaise)
+
+          unless %w[Alert Association Nonce Account::Cancellation::Handler].include?(base.name)
+            base.timestamps :at
+          end
+        end
+
+        extend Forwardable
+        def datamapper() DataMapper end
+        def_delegators :datamapper, :repository, :finalize, :logger, :logger=
+
+          def execute_sql(sql)
+            DataMapper.repository.adapter.execute(sql)
+          end
+
+        def alias_attribute(new, old)
+          alias_method new, old
+        end
+
+        def attr_accessible(*attrs)
+        end
+
+        def abstract_class=(val)
+        end
+      end
+    end
+  end
+end

data/lib/ardm/data_mapper.rb

@@ -0,0 +1,5 @@
+require 'ardm/data_mapper/record'
+
+module Ardm
+  Record = Ardm::DataMapper::Record
+end

data/lib/ardm/env.rb

@@ -0,0 +1,5 @@
+# Load Ardm based on the $ORM environment variable.
+#
+require 'ardm'
+Ardm.orm = ENV['ORM']
+require Ardm.lib

data/lib/ardm/property/api_key.rb

@@ -0,0 +1,30 @@
+require 'ardm/property/string'
+
+require 'digest/sha1'
+
+module Ardm
+  class Property
+    class APIKey < String
+
+      # The amount of random seed data to use to generate tha API Key
+      PADDING = 256
+
+      length 40
+      unique true
+      default proc { APIKey.generate }
+
+      #
+      # Generates a new API Key.
+      #
+      # @return [String]
+      #   The new API Key.
+      #
+      def self.generate
+        sha1 = Digest::SHA1.new
+
+        PADDING.times { sha1 << rand(256).chr }
+        return sha1.hexdigest
+      end
+    end
+  end
+end

data/lib/ardm/property/bcrypt_hash.rb

@@ -0,0 +1,31 @@
+require 'ardm/property/string'
+require 'bcrypt'
+
+module Ardm
+  class Property
+    class BCryptHash < String
+      load_as BCrypt::Password
+
+      length 60
+
+      def load(value)
+        unless value.nil?
+          begin
+            value_loaded?(value) ? value : BCrypt::Password.new(value)
+          rescue BCrypt::Errors::InvalidHash
+            BCrypt::Password.create(value, :cost => BCrypt::Engine::DEFAULT_COST)
+          end
+        end
+      end
+
+      def dump(value)
+        load(value)
+      end
+
+      def typecast(value)
+        load(value)
+      end
+
+    end # class BCryptHash
+  end # class Property
+end # module Ardm

data/lib/ardm/property/binary.rb

@@ -0,0 +1,23 @@
+require 'ardm/property/string'
+
+module Ardm
+  class Property
+    class Binary < String
+
+      if RUBY_VERSION >= "1.9"
+
+        def load(value)
+          super.dup.force_encoding("BINARY") unless value.nil?
+        end
+
+        def dump(value)
+          value.dup.force_encoding("BINARY") unless value.nil?
+        rescue
+          value
+        end
+
+      end
+
+    end # class Binary
+  end # class Property
+end # module Ardm

data/lib/ardm/property/boolean.rb

@@ -0,0 +1,29 @@
+require 'ardm/property/object'
+
+module Ardm
+  class Property
+    class Boolean < Object
+      load_as         ::TrueClass
+      dump_as         ::TrueClass
+      coercion_method :to_boolean
+
+      def initialize(model, name, options = {})
+        # validates presence in rails fails for false.
+        # Boolean must therefore behave like a set.
+        options[:set] = [true, false]
+        super model, name, options
+      end
+
+      # @api semipublic
+      def value_dumped?(value)
+        value_loaded?(value)
+      end
+
+      # @api semipublic
+      def value_loaded?(value)
+        value == true || value == false
+      end
+
+    end # class Boolean
+  end # class Property
+end # module Ardm

data/lib/ardm/property/class.rb

@@ -0,0 +1,19 @@
+require 'ardm/property/object'
+
+module Ardm
+  class Property
+    class Class < Object
+      load_as         ::Class
+      dump_as         ::Class
+      coercion_method :to_constant
+
+      # @api semipublic
+      def typecast(value)
+        Ardm::Ext::Module.find_const(model, value.to_s) unless value.nil?
+      rescue NameError
+        value
+      end
+
+    end # class Class
+  end # class Property
+end # module Ardm

data/lib/ardm/property/comma_separated_list.rb

@@ -0,0 +1,28 @@
+require 'ardm/property/yaml'
+
+module Ardm
+  class Property
+    class CommaSeparatedList < Yaml
+
+      def dump(value)
+        if value.nil?
+          nil
+        elsif value.kind_of?(::Array)
+          super(value)
+        elsif value.kind_of?(::String)
+          v = []
+
+          value.split(',').each do |element|
+            element.strip!
+            v << element unless element.empty?
+          end
+
+          super(v)
+        else
+          raise ArgumentError, "+value+ of CommaSeparatedList must be a string, an array or nil, but given #{value.inspect}"
+        end
+      end # dump
+
+    end # CommaSeparatedList
+  end # Property
+end # Ardm