ardm 0.0.1

data/lib/ardm/property/slug.rb

@@ -0,0 +1,29 @@
+require 'ardm/property/string'
+require 'stringex'
+
+module Ardm
+  class Property
+    class Slug < String
+
+      # Maximum length chosen because URI type is limited to 2000
+      # characters, and a slug is a component of a URI, so it should
+      # not exceed the maximum URI length either.
+      length 2000
+
+      def typecast(value)
+        if value.nil?
+          nil
+        elsif value.respond_to?(:to_str)
+          escape(value.to_str)
+        else
+          raise ArgumentError, '+value+ must be nil or respond to #to_str'
+        end
+      end
+
+      def escape(string)
+        string.to_url
+      end
+
+    end # class Slug
+  end # class Property
+end # module Ardm

data/lib/ardm/property/string.rb

@@ -0,0 +1,40 @@
+require 'ardm/property/object'
+
+module Ardm
+  class Property
+    class String < Object
+      load_as         ::String
+      dump_as         ::String
+      coercion_method :to_string
+
+      accept_options :length
+
+      DEFAULT_LENGTH = 50
+      length(DEFAULT_LENGTH)
+
+      # Returns maximum property length (if applicable).
+      # This usually only makes sense when property is of
+      # type Range or custom
+      #
+      # @return [Integer, nil]
+      #   the maximum length of this property
+      #
+      # @api semipublic
+      def length
+        if @length.kind_of?(Range)
+          @length.max
+        else
+          @length
+        end
+      end
+
+    protected
+
+      def initialize(model, name, options = {})
+        super
+        @length = @options.fetch(:length)
+      end
+
+    end # class String
+  end # class Property
+end # module Ardm

data/lib/ardm/property/support/dirty_minder.rb

@@ -0,0 +1,169 @@
+# Approach
+#
+# We need to detect whether or not the underlying Hash or Array changed and
+# update the dirty-ness of the encapsulating Resource accordingly (so that it
+# will actually save).
+#
+# DM's state-tracking code only triggers dirty-ness by comparing the new value
+# against the instance's Property's current value.  WRT mutation, we have to
+# choose one of the following approaches:
+#
+#   (1) mutate a copy ("after"), then invoke the Resource assignment and State
+#       tracking
+#
+#   (2) create a copy ("before"), mutate self ("after"), then invoke the
+#       Resource assignment and State tracking
+#
+# (1) seemed simpler at first, but it required additional steps to alias the
+# original (pre-hooked) methods before overriding them (so they could be invoked
+# externally, ala self.clone.send("orig_...")), and more importantly it resulted
+# in any external references keeping their old value (instead of getting the
+# new), like so:
+#
+#   copy = instance.json
+#   copy[:some] = :value
+#   instance.json[:some] == :value
+#    => true
+#   copy[:some] == :value
+#    => false  # fk!
+#
+# In order to do (2) and still have State tracking trigger normally, we need to
+# ensure the Property has a different value other than self when the State
+# tracking does the comparison.  This equates to setting the Property directly
+# to the "before" value (a clone and thus a different object/value) before
+# invoking the Resource Property/attribute assignment.
+#
+# The cloning of any value might sound expensive, but it's identical in cost to
+# what you already had to do: assign a cloned copy in order to trigger
+# dirty-ness (e.g. ::Ardm::Property::Json):
+#
+#     model.json = model.json.merge({:some=>:value})
+#
+# Hooking Core Classes
+#
+# We want to hook certain methods on Hash and Array to trigger dirty-ness in the
+# resource.  However, because these are core classes, they are individually
+# mapped to C primitives and thus cannot be hooked through #send/#__send__.  We
+# have to override each method, but we don't want to write a lot of code.
+#
+# Minimally Invasive
+#
+# We also want to extend behaviour of existing class instances instead of
+# impersonating/delegating from a proxy class of our own, or overriding a global
+# class behaviour.  This is the most flexible approach and least prone to error,
+# since it leaves open the option for consumers to proxy or override global
+# classes, and is less likely to interfere with method_missing/etc shenanigans.
+#
+# Nested Object Mutations
+#
+# Since we use {Array,Hash}#hash to compare before & after, and #hash accounts
+# for/traverses nested structures, no "deep" inspection logic is technically
+# necessary.  However, Resource#dirty? only queries a cache of dirtied
+# attributes, whose own population strategy is to hook assignment (instead of
+# interrogating properties on demand).  So the approach is still limited to
+# top-level mutators.
+#
+# Maybe consider optional "advisory" Property#dirty? method for Resource#dirty?
+# that custom properties could use for this purpose.
+#
+# TODO: add support for detecting mutations in nested objects, but we can't
+#       catch the assignment from here (yet?).
+# TODO: ensure we covered all indirectly-mutable classes that DM uses underneath
+#       a property type
+# TODO: figure out how to hook core class methods on RBX (which do use #send)
+
+module Ardm
+  class Property
+    module DirtyMinder
+
+      module Hooker
+        MUTATION_METHODS = {
+          ::Array => %w{
+            []= push << shift pop insert unshift delete
+            delete_at replace fill clear
+            slice! reverse! rotate! compact! flatten! uniq!
+            collect! map! sort! sort_by! reject! delete_if!
+            select! shuffle!
+          }.select { |meth| ::Array.instance_methods.any? { |m| m.to_s == meth } },
+
+          ::Hash => %w{
+            []= store delete delete_if replace update
+            delete rehash shift clear
+            merge! reject! select!
+          }.select { |meth| ::Hash.instance_methods.any? { |m| m.to_s == meth } },
+        }
+
+        def self.extended(instance)
+          # FIXME: DirtyMinder is currently unsupported on RBX, because unlike
+          # the other supported Rubies, RBX core class (e.g. Array, Hash)
+          # methods use #send().  In other words, the other Rubies don't use
+          # #send() (they map directly to their C functions).
+          #
+          # The current methodology takes advantage of this by using #send() to
+          # forward method invocations we've hooked.  Supporting RBX will
+          # require finding another way, possibly for all Rubies.  In the
+          # meantime, something is better than nothing.
+          return if defined?(RUBY_ENGINE) and RUBY_ENGINE == 'rbx'
+
+          return unless type = MUTATION_METHODS.keys.find { |k| instance.kind_of?(k) }
+          instance.extend const_get("#{type}Hooks")
+        end
+
+        MUTATION_METHODS.each do |klass, methods|
+          methods.each do |meth|
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              module #{klass}Hooks
+                def #{meth}(*)
+                  before = self.clone
+                  ret    = super
+                  after  = self
+
+                  # If the hashes aren't equivalent then we know the Resource
+                  # should be dirty.  However because we mutated self, normal
+                  # State tracking will never trigger, because it will compare the
+                  # new value - self - to the Resource's existing property value -
+                  # which is also self.
+                  #
+                  # The solution is to drop 1 level beneath Resource State
+                  # tracking and set the value of the property directly to the
+                  # previous value (a different object now, because it's a clone).
+                  # Then trigger the State tracking like normal.
+                  if before.hash != after.hash
+                    @property.set(@resource, before)
+                    @resource.attribute_set(@property.name, after)
+                  end
+
+                  ret
+                end
+              end
+            RUBY
+          end
+        end
+
+        def track(resource, property)
+          @resource, @property = resource, property
+        end
+
+      end # Hooker
+
+      # Catch any direct assignment (#set), and any Resource#reload (set!).
+      def set!(resource, value)
+        # Do not extend non observed value classes 
+        if Hooker::MUTATION_METHODS.keys.detect { |klass| value.kind_of?(klass) }
+          hook_value(resource, value) unless value.kind_of? Hooker
+        end
+        super
+      end
+
+      private
+
+      def hook_value(resource, value)
+        return if value.kind_of? Hooker
+
+        value.extend Hooker
+        value.track(resource, self)
+      end
+
+    end # DirtyMinder
+  end # Property
+end # Ardm

data/lib/ardm/property/support/flags.rb

@@ -0,0 +1,41 @@
+require 'active_support/concern'
+
+module Ardm
+  class Property
+    module Flags
+      extend ActiveSupport::Concern
+
+      included do
+        accept_options :flags
+        attr_reader :flag_map
+
+        class << self
+          attr_accessor :generated_classes
+        end
+
+        self.generated_classes = {}
+      end
+
+      def custom?
+        true
+      end
+
+      module ClassMethods
+        # TODO: document
+        # @api public
+        def [](*values)
+          if klass = generated_classes[values.flatten]
+            klass
+          else
+            klass = ::Class.new(self)
+            klass.flags(values)
+
+            generated_classes[values.flatten] = klass
+
+            klass
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ardm/property/support/paranoid_base.rb

@@ -0,0 +1,78 @@
+require 'active_support/concern'
+
+module Ardm
+  class Property
+    module ParanoidBase
+      extend ActiveSupport::Concern
+
+      included do
+        extend ClassMethods
+        instance_variable_set(:@paranoid_properties, {})
+        instance_variable_set(:@paranoid_scopes, [])
+      end
+
+      def paranoid_destroy
+        self.class.paranoid_properties.each do |name, block|
+          attribute_set(name, block.call(self))
+        end
+        save
+        @readonly = true
+        true
+      end
+
+      def destroy(execute_hooks = true)
+        # NOTE: changed behavior because AR doesn't call hooks on destroying new objects
+        return false if new_record?
+        if execute_hooks
+          run_callbacks :destroy do
+            paranoid_destroy
+          end
+        else
+          super
+        end
+      end
+
+      module ClassMethods
+        def inherited(model)
+          model.instance_variable_set(:@paranoid_properties, @paranoid_properties.dup)
+          model.instance_variable_set(:@paranoid_scopes, @paranoid_scopes.dup)
+          super
+        end
+
+        # @api public
+        def with_deleted(&block)
+          with_deleted_scope = self.scoped.with_default_scope
+          paranoid_scopes.each do |cond|
+            with_deleted_scope.where_values.delete(cond)
+          end
+
+          if block_given?
+            with_deleted_scope.scoping(&block)
+          else
+            with_deleted_scope.all
+          end
+        end
+
+        # @api private
+        def paranoid_properties
+          @paranoid_properties
+        end
+
+        def paranoid_scopes
+          @paranoid_scopes
+        end
+
+        # @api private
+        def set_paranoid_property(name, &block)
+          paranoid_properties[name] = block
+        end
+
+        def set_paranoid_scope(conditions)
+          paranoid_scope = conditions
+          paranoid_scopes << paranoid_scope
+          default_scope { where(paranoid_scope) }
+        end
+      end # module ClassMethods
+    end # module ParanoidBase
+  end # class Property
+end # module Ardm

data/lib/ardm/property/text.rb

@@ -0,0 +1,11 @@
+require 'ardm/property/string'
+
+module Ardm
+  class Property
+    class Text < String
+      length 65535
+      lazy   true
+
+    end # class Text
+  end # class Property
+end # module Ardm

data/lib/ardm/property/time.rb

@@ -0,0 +1,12 @@
+require 'ardm/property/object'
+
+module Ardm
+  class Property
+    class Time < Object
+      load_as         ::Time
+      dump_as         ::Time
+      coercion_method :to_time
+
+    end # class Time
+  end # class Property
+end # module Ardm

data/lib/ardm/property/uri.rb

@@ -0,0 +1,27 @@
+require 'ardm/property/string'
+require 'addressable/uri'
+
+module Ardm
+  class Property
+    class URI < String
+      load_as Addressable::URI
+
+      # Maximum length chosen based on recommendation:
+      # http://stackoverflow.com/questions/417142/what-is-the-maximum-length-of-an-url
+      length 2000
+
+      def load(value)
+        Addressable::URI.parse(value) unless value.nil?
+      end
+
+      def dump(value)
+        value.to_s unless value.nil?
+      end
+
+      def typecast(value)
+        load(value) unless value.nil?
+      end
+
+    end # class URI
+  end # class Property
+end # module Ardm

data/lib/ardm/property/uuid.rb

@@ -0,0 +1,65 @@
+require 'ardm/property/string'
+require 'uuidtools'  # must be ~>2.0
+
+module Ardm
+  class Property
+    # UUID Type
+    # First run at this, because I need it. A few caveats:
+    #  * Only works on postgres, using the built-in native uuid type.
+    #    To make it work in mysql, you'll have to add a typemap entry to
+    #    the mysql_adapter. I think. I don't have mysql handy, so I'm
+    #    not going to try. For SQLite, this will have to inherit from the
+    #    String primitive
+    #  * Won't accept a random default, because of the namespace clash
+    #    between this and the UUIDtools gem. Also can't set the default
+    #    type to UUID() (postgres-contrib's native generator) and
+    #    automigrate, because auto_migrate! tries to make it a string "UUID()"
+    # Feel free to enchance this, and delete these caveats when they're fixed.
+    #
+    #  -- Rando Sept 25, 08
+    #
+    # Actually, setting the primitive to "UUID" is not neccessary and causes
+    # a segfault when trying to query uuid's from the database.  The primitive
+    # should be a class which has been added to the do driver you are using.
+    # Also, it's only neccessary to add a class to the do drivers to use as a
+    # primitive when a value cannot be represented as a string.  A uuid can be
+    # represented as a string, so setting the primitive to String ensures that
+    # the value argument is a String containing the uuid in string form.
+    #
+    # <strike>It is still neccessary to add the UUID entry to the type map for
+    # each different adapter with their respective database primitive.</strike>
+    #
+    # The method that generates the SQL schema from the typemap currently
+    # ignores the size attribute from the type map if the primitive type
+    # is String.  The causes the generated SQL statement to contain a size for
+    # a UUID column (e.g. id UUID(50)), which causes a syntax error in postgres.
+    # Until this is resolved, you will have to manually change the column type
+    # to UUID in a migration, if you want to use postgres' built in UUID type.
+    #
+    #  -- benburkert Nov 15, 08
+    #
+    class UUID < String
+      load_as UUIDTools::UUID
+
+      length 36
+
+      def dump(value)
+        value.to_s unless value.nil?
+      end
+
+      def load(value)
+        if value_loaded?(value)
+          value
+        elsif !value.nil?
+          UUIDTools::UUID.parse(value)
+        end
+      end
+
+      def typecast(value)
+        return if value.nil?
+        load(value)
+      end
+
+    end
+  end
+end

data/lib/ardm/property/validation.rb

@@ -0,0 +1,208 @@
+require 'ardm/property'
+require 'ardm/property/string'
+require 'ardm/property/text'
+require 'ardm/property/numeric'
+
+module Ardm
+  class Property
+    unless defined?(Infinity)
+      Infinity = 1.0/0
+    end
+    Ardm::Property.accept_options :auto_validation, :validates, :set, :format, :message, :messages
+
+    module Validation
+
+      # Infer validations for a given property. This will only occur
+      # if the option :auto_validation is either true or left undefined.
+      #
+      #   Triggers that generate validator creation
+      #
+      #   :required => true
+      #       Setting the option :required to true causes a Rule::Presence
+      #       to be created for the property
+      #
+      #   :length => 20
+      #       Setting the option :length causes a Rule::Length to be created
+      #       for the property.
+      #       If the value is a Integer the Rule will have :maximum => value.
+      #       If the value is a Range the Rule will have :within => value.
+      #
+      #   :format => :predefined / lambda / Proc
+      #       Setting the :format option causes a Rule::Format to be created
+      #       for the property
+      #
+      #   :set => ["foo", "bar", "baz"]
+      #       Setting the :set option causes a Rule::Within to be created
+      #       for the property
+      #
+      #   Integer type
+      #       Using a Integer type causes a Rule::Numericalness to be created
+      #       for the property.  The Rule's :integer_only option is set to true
+      #
+      #   BigDecimal or Float type
+      #       Using a Integer type causes a Rule::Numericalness to be created
+      #       for the property.  The Rule's :integer_only option will be set
+      #       to false, and precision/scale will be set to match the Property
+      #
+      #
+      #   Messages
+      #
+      #   :messages => {..}
+      #       Setting :messages hash replaces standard error messages
+      #       with custom ones. For instance:
+      #       :messages => {:presence => "Field is required",
+      #                     :format => "Field has invalid format"}
+      #       Hash keys are: :presence, :format, :length, :is_unique,
+      #                      :is_number, :is_primitive
+      #
+      #   :message => "Some message"
+      #       It is just shortcut if only one validation option is set
+      #
+      # @api private
+      def self.rules_for_property(property)
+        rule_definitions = []
+
+        # all inferred rules should not be skipped when the value is nil
+        #   (aside from Rule::Presence/Rule::Absence)
+        opts = { :allow_nil => true }
+
+        if property.options.key?(:validates)
+          opts[:context] = property.options[:validates]
+        end
+
+        rule_definitions << infer_presence(  property, opts.dup)
+        rule_definitions << infer_length(    property, opts.dup)
+        rule_definitions << infer_format(    property, opts.dup)
+        rule_definitions << infer_uniqueness(property, opts.dup)
+        rule_definitions << infer_within(    property, opts.dup)
+        rule_definitions << infer_type(      property, opts.dup)
+
+        rule_definitions.compact
+      end
+
+      private
+
+      # @api private
+      # Skip TrueClass dump because presence is invalid for false, but boolean false is ok for a boolean property.
+      def self.infer_presence(property, options)
+        return if property.allow_blank? || property.serial? || property.dump_as == ::TrueClass
+
+        validation_options = options_with_message(options, property, :presence)
+
+        {presence: validation_options}
+      end
+
+      # @api private
+      def self.infer_length(property, options)
+        # TODO: return unless property.primitive <= String (?)
+        return unless (property.kind_of?(Property::String) ||
+                       property.kind_of?(Property::Text))
+        length = property.options.fetch(:length, Property::String.length)
+
+
+        if length.is_a?(Range)
+          if length.last == Infinity
+            raise ArgumentError, "Infinity is not a valid upper bound for a length range"
+          end
+          options[:in]  = length
+        else
+          options[:maximum] = length
+        end
+
+        validation_options = options_with_message(options, property, :length)
+
+        {length: validation_options}
+      end
+
+      # @api private
+      def self.infer_format(property, options)
+        return unless property.options.key?(:format)
+
+        options[:with] = property.options[:format]
+
+        validation_options = options_with_message(options, property, :format)
+
+        {format: validation_options}
+      end
+
+      # @api private
+      def self.infer_uniqueness(property, options)
+        return unless property.options.key?(:unique)
+
+        case value = property.options[:unique]
+        when Array, Symbol
+          # TODO: fix this to behave like :unique_index
+          options[:scope] = Array(value)
+
+          validation_options = options_with_message(options, property, :is_unique)
+          {uniqueness: validation_options}
+        when TrueClass
+          validation_options = options_with_message(options, property, :is_unique)
+          {uniqueness: validation_options}
+        end
+      end
+
+      # @api private
+      def self.infer_within(property, options)
+        return unless property.options.key?(:set)
+
+        options[:in] = property.options[:set]
+        options[:message] ||= "must be one of #{options[:in].join(', ')}"
+
+        validation_options = options_with_message(options, property, :within)
+        {inclusion: validation_options}
+      end
+
+      # @api private
+      def self.infer_type(property, options)
+        return if property.respond_to?(:custom?) && property.custom?
+
+        if property.kind_of?(Property::Numeric)
+          options[:greater_than_or_equal_to] = property.min if property.min
+          options[:less_than_or_equal_to] = property.max if property.max
+        end
+
+        if Integer == property.load_as
+          options[:only_integer] = true
+
+          validation_options = options_with_message(options, property, :is_number)
+          {numericality: validation_options}
+        elsif (BigDecimal == property.load_as ||
+               Float == property.load_as)
+          options[:precision] = property.precision
+          options[:scale]     = property.scale
+
+          validation_options = options_with_message(options, property, :is_number)
+          {numericality: validation_options}
+        else
+          # We only need this in the case we don't already
+          # have a numeric validator, because otherwise
+          # it will cause duplicate validation errors
+          validation_options = options_with_message(options, property, :is_primitive)
+          # FIXME unsupported in Ardm::Property for now
+          nil
+        end
+      end
+
+      # TODO: eliminate this;
+      #   mutating one arg based on a non-obvious interaction of the other two...
+      #   well, it makes my skin crawl.
+      # 
+      # @api private
+      def self.options_with_message(base_options, property, validator_name)
+        options = base_options.clone
+        opts    = property.options
+
+        if opts.key?(:messages)
+          options[:message] = opts[:messages][validator_name]
+        elsif opts.key?(:message)
+          options[:message] = opts[:message]
+        end
+
+        options
+      end
+
+    end # module Validation
+  end # module Property
+end # module Ardm
+