datamapper 0.1.0

data/lib/data_mapper/support/proc.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/blank_slate'
+
+class Proc
+  
+  # Yeah, all this is kinda the suck.
+  def to_hash
+    Conditions.new(&self).__to_hash__
+  end
+  
+  class Conditions < BlankSlate
+    
+    def initialize(&block)
+      @block = block
+      @conditions = []
+    end
+    
+    def method_missing(sym, *args)
+      attribute = Attribute.new(sym)
+      @conditions << attribute
+      attribute
+    end
+    
+    def __to_hash__
+      instance_eval(&@block)      
+      @conditions.inject({}) do |h,attribute|
+        h[attribute.__operator__] = *attribute.__args__; h
+      end
+    end
+    
+    class Attribute < BlankSlate
+      
+      def initialize(message)
+        @message = message
+        @args = nil
+        @operator = nil
+      end
+    
+      def method_missing(sym, *args)
+        op = case sym
+          when :==, :===, :in then :eql
+          when :=~ then :like
+          when :"<=>" then :not
+          when :< then :lt
+          when :<= then :lte
+          when :> then :gt
+          when :>= then :gte
+          else sym
+        end
+        
+        @operator = Symbol::Operator.new(@message, op)
+        @args = args
+      end
+      
+      def __operator__
+        @operator
+      end
+      
+      def __args__
+        @args
+      end
+    
+      def __message__
+        @message
+      end
+      
+    end
+        
+  end
+end

data/lib/data_mapper/support/string.rb

@@ -0,0 +1,23 @@
+module DataMapper
+  module Support
+    module String
+      
+      def ensure_starts_with(part)
+        [0,1] == part ? self : (part + self)
+      end
+  
+      def ensure_ends_with(part)
+        [-1,1] == part ? self : (self + part)
+      end
+  
+      def ensure_wrapped_with(a, b = nil)
+        ensure_starts_with(a).ensure_ends_with(b || a)
+      end
+      
+    end # module String
+  end # module Support
+end # module DataMapper
+
+class String #:nodoc:
+  include DataMapper::Support::String
+end

data/lib/data_mapper/support/symbol.rb

@@ -0,0 +1,91 @@
+module DataMapper
+  module Support
+    module Symbol
+      
+      class Operator
+      
+        attr_reader :value, :type, :options
+      
+        def initialize(value, type, options = nil)
+          @value, @type, @options = value, type, options
+        end
+    
+        def to_sym
+          @value
+        end
+      end
+    
+      def gt
+        Operator.new(self, :gt)
+      end
+  
+      def gte
+        Operator.new(self, :gte)
+      end
+  
+      def lt
+        Operator.new(self, :lt)
+      end
+  
+      def lte
+        Operator.new(self, :lte)
+      end
+  
+      def not
+        Operator.new(self, :not)
+      end
+  
+      def eql
+        Operator.new(self, :eql)
+      end
+  
+      def like
+        Operator.new(self, :like)
+      end
+  
+      def in
+        Operator.new(self, :in)
+      end
+  
+      def select(klass = nil)    
+        Operator.new(self, :select, { :class => klass })
+      end
+  
+      def to_s
+        @string_form || (@string_form = id2name.freeze)
+      end
+  
+      def to_proc
+       lambda { |value| value.send(self) }
+      end
+      
+      def as_instance_variable_name
+        @instance_variable_name_form || (@instance_variable_name_form = "@#{id2name}".freeze)
+      end
+  
+      # Calculations:
+  
+      def count
+        Operator.new(self, :count)
+      end
+  
+      def max
+        Operator.new(self, :max)
+      end
+  
+      def avg
+        Operator.new(self, :avg)
+      end
+      alias average avg
+  
+      def min
+        Operator.new(self, :min)
+      end
+      
+    end # module Symbol
+  end # module Support
+end # module DataMapper
+
+class Symbol #:nodoc:
+  include DataMapper::Support::Symbol
+end

data/lib/data_mapper/support/weak_hash.rb

@@ -0,0 +1,46 @@
+module DataMapper
+  module Support
+    class WeakHash
+      attr_reader :cache
+      def initialize( cache = Hash.new )
+        @cache = cache
+        @key_map = {}
+        @rev_cache = Hash.new{|h,k| h[k] = {}}
+        @reclaim_value = lambda do |value_id| 
+          if @rev_cache.has_key? value_id
+            @rev_cache[value_id].each_key{|key| @cache.delete key}
+            @rev_cache.delete value_id
+          end
+        end
+        @reclaim_key = lambda do |key_id|
+          if @key_map.has_key? key_id
+            @cache.delete @key_map[key_id]
+          end
+        end
+      end
+
+     def []( key )
+       value_id = @cache[key]
+       return ObjectSpace._id2ref(value_id) unless value_id.nil?
+       nil
+     rescue RangeError
+       nil
+     end
+
+     def []=( key, value )
+       case key
+       when Fixnum, Symbol, true, false
+         key2 = key
+       else
+         key2 = key.dup
+       end
+       @rev_cache[value.object_id][key2] = true
+       @cache[key2] = value.object_id
+       @key_map[key.object_id] = key2
+
+       ObjectSpace.define_finalizer(value, @reclaim_value)
+       ObjectSpace.define_finalizer(key, @reclaim_key)
+     end
+   end # class WeakHash
+ end # module Support
+end # module DataMapper

data/lib/data_mapper/unit_of_work.rb

@@ -0,0 +1,38 @@
+module DataMapper
+  
+  # Should this track relations?
+  module UnitOfWork
+
+    def new_record?
+      @new_record.nil? || @new_record
+    end
+    
+    def dirty?(name = nil)
+      if name.nil?
+        session.schema[self.class].columns.any? { |column| self.instance_variable_get(column.instance_variable_name).hash != original_hashes[column.name] }
+      else
+        key = name.kind_of?(Symbol) ? name : name.to_sym
+        self.instance_variable_get("@#{name}").hash != original_hashes[key]
+      end
+    end
+
+    def dirty_attributes
+      if new_record?
+        session.schema[self.class].columns.reject do |column|
+          instance_variable_get(column.instance_variable_name).nil?
+        end
+      else        
+        session.schema[self.class].columns.select do |column|
+          column.name != :id && instance_variable_get(column.instance_variable_name).hash != original_hashes[column.name]
+        end
+      end.inject({}) do |fields, column|
+        fields[column.name] = instance_variable_get(column.instance_variable_name); fields
+      end
+    end
+    
+    def original_hashes
+      @original_hashes || (@original_hashes = {})
+    end
+  end
+
+end

data/lib/data_mapper/validations/confirmation_validator.rb

@@ -0,0 +1,55 @@
+module DataMapper
+  module Validations
+    
+    class ConfirmationValidator < GenericValidator
+      
+      ERROR_MESSAGES = {
+        :confirmation => '#{field} does not match the confirmation'
+      }
+      
+      def initialize(field_name, options = {})
+        @options = options
+        @field_name, @confirm_field_name = field_name, (options[:confirm] || "#{field_name}_confirmation").to_sym
+      end
+      
+      def call(target)
+        field = Inflector.humanize(@field_name)
+
+        unless valid?(target)
+          error_message = validation_error_message(ERROR_MESSAGES[:confirmation], nil, binding)        
+          add_error(target, error_message , @field_name)
+          return false
+        end
+        
+        return true
+      end
+      
+      def valid?(target)
+        field_value = target.instance_variable_get("@#{@field_name}")
+        return true if @options[:allow_nil] && field_value.nil?
+
+        confirm_value = target.instance_variable_get("@#{@confirm_field_name}")
+        field_value == confirm_value
+      end
+      
+    end
+    
+    module ValidatesConfirmationOf
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        # No bueno?
+        DEFAULT_OPTIONS = { :on => :save }
+
+        def validates_confirmation_of(field, options = {})
+          opts = retrieve_options_from_arguments_for_validators([options], DEFAULT_OPTIONS)
+          validations.context(opts[:context]) << Validations::ConfirmationValidator.new(field, opts)
+        end
+
+      end
+    end
+    
+  end  
+end

data/lib/data_mapper/validations/contextual_validations.rb

@@ -0,0 +1,50 @@
+module DataMapper
+  
+  class ContextualValidations
+    
+    # This will be raised when you try to access
+    # a context that's not a member of the DEFAULT_CONTEXTS array.
+    class UnknownContextError < StandardError
+    end
+    
+    # Add your custom contexts here.
+    DEFAULT_CONTEXTS = [
+        :general, :create, :save, :update
+      ]
+      
+    def initialize
+      @contexts = Hash.new { |h,k| h[k.to_sym] = [] }
+    end
+    
+    # Retrieves a context by symbol.
+    # Raises an exception if the symbol isn't a member of DEFAULT_CONTEXTS.
+    # This isn't to keep you from adding your own contexts, it's just to
+    # prevent errors due to typos. When adding your own contexts just
+    # remember to add it to DEFAULT_CONTEXTS first.
+    def context(name)
+      raise UnknownContextError.new(name) unless DEFAULT_CONTEXTS.include?(name)
+      @contexts[name]
+    end
+    
+    # Clear out all the currently defined validators.
+    # This makes testing easier.
+    def clear!
+      @contexts.clear
+    end
+    
+    # Execute all validations against an instance for a specified context,
+    # including the "always-on" :general context.
+    def execute(context_name, target)
+      target.errors.clear!
+      
+      validations = context(context_name)
+      validations += context(:general) unless context_name == :general
+      
+      validations.inject(true) do |result, validator|
+        result & validator.call(target)
+      end
+    end
+      
+  end
+  
+end

data/lib/data_mapper/validations/format_validator.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + '/formats/email'
+
+module DataMapper
+  module Validations
+    
+    class FormatValidator < GenericValidator
+      
+      # Seems to me that all this email garbage belongs somewhere else...  Where's the best
+      # place to stick it?
+      include DataMapper::Validations::Helpers::Email
+
+      ERROR_MESSAGES = {
+        :invalid => '#{field} is invalid',
+        :invalid_email => '#{value} is not a valid email address'
+      }
+            
+      FORMATS = {
+        :email_address => [lambda { |email_address| email_address =~ DataMapper::Validations::Helpers::Email::RFC2822::EmailAddress }, :invalid_email]
+      }
+      
+      def initialize(field_name, options = {}, &b)
+        @field_name, @options = field_name, options
+      end
+
+      def call(target)
+        field_value = target.instance_variable_get("@#{@field_name}")
+        return true if @options[:allow_nil] && field_value.nil?
+        
+        validation = (@options[:as] || @options[:with])
+        message_key = :invalid
+        
+        # Figure out what to use as the actual validator.  If a symbol is passed to :as, look up
+        # the canned validation in FORMATS.
+        validator = if validation.is_a? Symbol
+          if FORMATS[validation].is_a? Array
+            message_key = FORMATS[validation][1] || :invalid
+            FORMATS[validation][0]
+          else
+            FORMATS[validation] || validation
+          end
+        else
+          validation
+        end
+        
+        valid = case validator
+        when Proc then validator.call(field_value)
+        when Regexp then validator =~ field_value
+        else raise UnknownValidationFormat, "Can't determine how to validate #{target.class}##{@field_name} with #{validator.inspect}"
+        end 
+        
+        unless valid
+          field = Inflector.humanize(@field_name)
+          value = target.instance_variable_get("@#{@field_name}")
+          
+          error_message = validation_error_message(ERROR_MESSAGES[message_key], nil, binding)        
+          add_error(target, error_message , @field_name)
+        end
+        
+        return valid
+      end
+      
+      class UnknownValidationFormat < StandardError
+      end
+      
+    end
+    
+    module ValidatesFormatOf
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        # No bueno?
+        DEFAULT_OPTIONS = { :on => :save }
+        
+        def validates_format_of(field, options = {})
+          opts = retrieve_options_from_arguments_for_validators([options], DEFAULT_OPTIONS)
+          validations.context(opts[:context]) << Validations::FormatValidator.new(field, opts)
+        end
+
+      end
+    end
+    
+  end  
+end