datamapper 0.1.0

data/lib/data_mapper/validations/formats/email.rb

@@ -0,0 +1,78 @@
+# http://www.faqs.org/rfcs/rfc2822.html
+module DataMapper
+  module Validations
+    module Helpers
+      module Email
+        
+        module RFC2822
+          EmailAddress = begin
+            alpha = "a-zA-Z"
+            digit = "0-9"
+            atext = "[#{alpha}#{digit}\!\#\$\%\&\'\*+\/\=\?\^\_\`\{\|\}\~\-]"
+            dot_atom_text = "#{atext}+([.]#{atext}*)*"
+            dot_atom = "#{dot_atom_text}"
+            qtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]'
+            text = "[\\x01-\\x09\\x11\\x12\\x14-\\x7f]"
+            quoted_pair = "(\\x5c#{text})"
+            qcontent = "(?:#{qtext}|#{quoted_pair})"
+            quoted_string = "[\"]#{qcontent}+[\"]"
+            atom = "#{atext}+"
+            word = "(?:#{atom}|#{quoted_string})"
+            obs_local_part = "#{word}([.]#{word})*"
+            local_part = "(?:#{dot_atom}|#{quoted_string}|#{obs_local_part})"
+            no_ws_ctl = "\\x01-\\x08\\x11\\x12\\x14-\\x1f\\x7f"    
+            dtext = "[#{no_ws_ctl}\\x21-\\x5a\\x5e-\\x7e]"
+            dcontent = "(?:#{dtext}|#{quoted_pair})"
+            domain_literal = "\\[#{dcontent}+\\]"
+            obs_domain = "#{atom}([.]#{atom})*"
+            domain = "(?:#{dot_atom}|#{domain_literal}|#{obs_domain})"
+            addr_spec = "#{local_part}\@#{domain}"
+            pattern = /^#{addr_spec}$/
+          end
+        end
+        
+      end
+    end
+  end
+end
+
+=begin
+addresses = [
+  '-- dave --@example.com', # (spaces are invalid unless enclosed in quotation marks)
+  '[dave]@example.com', # (square brackets are invalid, unless contained within quotation marks)
+  '.dave@example.com', # (the local part of a domain name cannot start with a period)
+  'Max@Job 3:14', 
+  'Job@Book of Job',
+  'J. P. \'s-Gravezande, a.k.a. The Hacker!@example.com',
+  ]
+addresses.each do |address|
+  if address =~ RFC2822::EmailAddress
+    puts "#{address} deveria ter sido rejeitado, ERRO"
+  else
+    puts "#{address} rejeitado, OK"
+  end
+end
+
+
+addresses = [
+  '+1~1+@example.com',
+  '{_dave_}@example.com',
+  '"[[ dave ]]"@example.com',
+  'dave."dave"@example.com',
+  'test@localhost',
+  'test@example.com', 
+  'test@example.co.uk',
+  'test@example.com.br',
+  '"J. P. \'s-Gravezande, a.k.a. The Hacker!"@example.com',
+  'me@[187.223.45.119]',
+  'someone@123.com',
+  'simon&garfunkel@songs.com'
+  ]
+addresses.each do |address|
+  if address =~ RFC2822::EmailAddress
+    puts "#{address} aceito, OK"
+  else
+    puts "#{address} deveria ser aceito, ERRO"
+  end
+end
+=end

data/lib/data_mapper/validations/generic_validator.rb

@@ -0,0 +1,27 @@
+module DataMapper
+  module Validations
+    
+    # All Validators should inherit from the GenericValidator.
+    class GenericValidator
+    
+      # Adds an error message to the target class.
+      def add_error(target, message, attribute = :base)
+        target.errors.add(attribute, message)
+      end
+      
+      # Gets the proper error message
+      def validation_error_message(default, custom_message, validation_binding)
+        eval("\"#{(custom_message || default)}\"", validation_binding)
+      end
+      
+      # Call the validator. We use "call" so the operation
+      # is BoundMethod and Block compatible.
+      # The result should always be TRUE or FALSE.
+      def call(target)
+        raise 'You must overwrite this method'
+      end
+      
+    end
+        
+  end
+end

data/lib/data_mapper/validations/length_validator.rb

@@ -0,0 +1,75 @@
+module DataMapper
+  module Validations
+    
+    class LengthValidator < GenericValidator
+      
+      ERROR_MESSAGES = {
+        :range => '#{field} must be between #{min} and #{max} characters long',
+        :min => '#{field} must be more than #{min} characters long',
+        :max => '#{field} must be less than #{max} characters long',
+        :equals => '#{field} must be #{equal} characters long'
+      }
+      
+      def initialize(field_name, options)
+        @field_name = field_name
+        @options = options
+        
+        @min = options[:minimum] || options[:min]
+        @max = options[:maximum] || options[:max]
+        @equal = options[:is] || options[:equals]
+        @range = options[:within] || options[:in]
+
+        @validation_method ||= :range if @range
+        @validation_method ||= :min if @min && @max.nil?
+        @validation_method ||= :max if @max && @min.nil?
+        @validation_method ||= :equals unless @equal.nil?
+      end
+      
+      def call(target)
+        field_value = target.instance_variable_get("@#{@field_name}").to_s
+        return true if @options[:allow_nil] && field_value.nil?
+        
+        # HACK seems hacky to do this on every validation, probably should do this elsewhere?
+        field = Inflector.humanize(@field_name)
+        min = @range ? @range.min : @min
+        max = @range ? @range.max : @max
+        equal = @equal
+
+        error_message = validation_error_message(ERROR_MESSAGES[@validation_method], nil, binding)
+        
+        valid = case @validation_method
+        when :range then
+          @range.include?(field_value.size)
+        when :min then
+          field_value.size >= min
+        when :max then
+          field_value.size <= max
+        when :equals then
+          field_value.size == equal
+        end
+        
+        add_error(target, error_message, @field_name) unless valid
+
+        return valid
+      end
+
+    end
+    
+    module ValidatesLengthOf
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        DEFAULT_VALIDATES_LENGTH_OF_OPTIONS = { :on => :save }
+
+        def validates_length_of(field, options = {})
+          opts = retrieve_options_from_arguments_for_validators([options], DEFAULT_VALIDATES_LENGTH_OF_OPTIONS)
+          validations.context(opts[:context]) << Validations::LengthValidator.new(field, opts)
+        end
+
+      end
+    end
+    
+  end  
+end

data/lib/data_mapper/validations/required_field_validator.rb

@@ -0,0 +1,47 @@
+module DataMapper
+  module Validations
+    
+    class RequiredFieldValidator < GenericValidator
+      
+      ERROR_MESSAGES = {
+        :required => '#{field} must not be blank'
+      }
+      
+      def initialize(field_name)
+        @field_name = field_name
+      end
+      
+      def call(target)
+        field_value = !target.instance_variable_get("@#{@field_name}").nil?
+        return true if field_value
+        
+        field = Inflector.humanize(@field_name)
+        
+        error_message = validation_error_message(ERROR_MESSAGES[:required], nil, binding)        
+        add_error(target, error_message , @field_name)
+        
+        return false
+      end
+      
+    end
+    
+    module ValidatesPresenceOf
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+
+        def validates_presence_of(*fields)
+          options = retrieve_options_from_arguments_for_validators(fields)
+          
+          fields.each do |field|
+            validations.context(options[:context]) << Validations::RequiredFieldValidator.new(field)
+          end
+        end
+
+      end
+    end
+    
+  end  
+end

data/lib/data_mapper/validations/unique_validator.rb

@@ -0,0 +1,65 @@
+module DataMapper
+  module Validations
+    
+    class UniqueValidator < GenericValidator
+      
+      ERROR_MESSAGES = {
+        :unique => '#{field} has already been taken'
+      }
+      
+      def initialize(field_name, options = {})
+        @options = options
+        @field_name = field_name.to_sym
+      end
+      
+      def call(target)
+        field = Inflector.humanize(@field_name)
+
+        unless valid?(target)
+          error_message = validation_error_message(ERROR_MESSAGES[:unique], 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?
+        
+        finder_options = { @field_name => field_value }
+        
+        if @options[:scope]
+          scope_value = target.instance_variable_get("@#{@options[:scope]}")
+          finder_options.merge! @options[:scope] => scope_value
+        end
+        
+        finder_options.merge!({ target.session.mappings[target.class].key.name.not => target.key }) unless target.new_record?
+        
+        # HACK: gotta make sure we're using the same database that this instance was
+        # found with unless new_record?
+        target.session.find(target.class, :first, finder_options).nil?
+      end
+      
+    end
+    
+    module ValidatesUniquenessOf
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        # No bueno?
+        DEFAULT_OPTIONS = { :on => :save }
+
+        def validates_uniqueness_of(field, options = {})
+          opts = retrieve_options_from_arguments_for_validators([options], DEFAULT_OPTIONS)
+          validations.context(opts[:context]) << Validations::UniqueValidator.new(field, opts)
+        end
+
+      end
+    end
+    
+  end  
+end

data/lib/data_mapper/validations/validation_errors.rb

@@ -0,0 +1,34 @@
+module DataMapper
+  
+  class ValidationErrors
+  
+    def initialize
+      @errors = Hash.new { |h,k| h[k.to_sym] = [] }
+    end
+    
+    # Clear existing validation errors.
+    def clear!
+      @errors.clear
+    end
+    
+    # Add a validation error. Use the attribute :general if
+    # the error doesn't apply to a specific attribute.
+    def add(attribute, message)
+      @errors[attribute] << message
+    end
+    
+    # Collect all errors into a single list.
+    def full_messages
+      @errors.inject([]) do |list,pair|
+        list += pair.last
+      end
+    end
+    
+    # Are any errors present?
+    def empty?
+      @errors.empty?
+    end
+   
+  end
+  
+end

data/lib/data_mapper/validations/validation_helper.rb

@@ -0,0 +1,60 @@
+dirname = File.dirname(__FILE__)
+
+require dirname + '/validation_errors'
+require dirname + '/contextual_validations'
+require dirname + '/generic_validator'
+
+Dir[dirname + '/*_validator.rb'].reject do |path|
+  path =~ /\/generic_validator/
+end.each do |validator|
+  load validator
+end
+
+module DataMapper
+  module Extensions
+    
+    module ValidationHelper
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.class_eval do
+          include DataMapper::Validations::ValidatesPresenceOf
+          include DataMapper::Validations::ValidatesLengthOf
+          include DataMapper::Validations::ValidatesConfirmationOf
+          include DataMapper::Validations::ValidatesUniquenessOf
+          include DataMapper::Validations::ValidatesFormatOf
+        end
+      end
+      
+      def errors
+        @errors ||= ValidationErrors.new
+      end
+      
+      def valid?(context = :general)
+        self.class.validations.execute(context, self)
+      end
+      
+      module ClassMethods
+        
+        def validations
+          @validations ||= ContextualValidations.new
+        end
+        
+        def retrieve_options_from_arguments_for_validators(args, defaults = nil)
+          options = args.last.kind_of?(Hash) ? args.pop : {}
+          
+          context = :general
+          context = options[:context] if options.has_key?(:context)
+          context = options.delete(:on) if options.has_key?(:on)
+          options[:context] = context
+          
+          options.merge!(defaults) unless defaults.nil?
+          return options
+        end
+                
+      end
+      
+    end    
+    
+  end
+end

data/performance.rb

@@ -0,0 +1,156 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection :adapter => 'mysql',
+  :host     => 'localhost',
+  :username => 'root',
+  :password => '',
+  :database => 'data_mapper_1'
+      
+class ARAnimal < ActiveRecord::Base
+  set_table_name 'animals'
+end
+
+class ARPerson < ActiveRecord::Base
+  set_table_name 'people'
+end
+
+$LOAD_PATH.unshift('lib')
+require 'data_mapper'
+
+log_path = File.dirname(__FILE__) + '/development.log'
+
+require 'fileutils'
+FileUtils::rm log_path if File.exists?(log_path)
+
+DataMapper::Database.setup do
+  adapter   'mysql'
+  username 'root'
+  database 'data_mapper_1'
+  log_stream 'development.log'
+  log_level Logger::DEBUG
+end
+
+class DMAnimal < DataMapper::Base
+  set_table_name 'animals'
+  property :name, :string
+  property :notes, :string, :lazy => true
+end
+
+class DMPerson < DataMapper::Base
+  set_table_name 'people'
+  property :name, :string
+  property :age, :integer
+  property :occupation, :string
+  property :notes, :text, :lazy => true
+end
+
+class Exhibit < DataMapper::Base
+  property :name, :string
+  belongs_to :zoo
+end
+
+class Zoo < DataMapper::Base
+  property :name, :string
+  has_many :exhibits
+end
+
+class ARZoo < ActiveRecord::Base
+  set_table_name 'zoos'
+  has_many :exhibits, :class_name => 'ARExhibit', :foreign_key => 'zoo_id'
+end
+
+class ARExhibit < ActiveRecord::Base
+  set_table_name 'exhibits'
+  belongs_to :zoo, :class_name => 'ARZoo', :foreign_key => 'zoo_id'
+end
+
+N = (ENV['N'] || 1000).to_i
+
+Benchmark::send(ENV['BM'] || :bmbm, 40) do |x|
+  
+  x.report('ActiveRecord:id') do
+    N.times { ARAnimal.find(1) }
+  end
+  
+  x.report('DataMapper:id') do
+    N.times { DMAnimal[1] }
+  end
+  
+  x.report('ActiveRecord:conditions') do
+    N.times { ARZoo.find(:first, :conditions => ['name = ?', 'Galveston']) }
+  end
+  
+  x.report('DataMapper:conditions:short') do
+    N.times { Zoo[:name => 'Galveston'] }
+  end
+  
+  x.report('DataMapper:conditions:long') do
+    N.times { Zoo.find(:first, :conditions => ['name = ?', 'Galveston']) }
+  end
+  
+  people = [
+    ['Sam', 29, 'Programmer'],
+    ['Amy', 28, 'Business Analyst Manager'],
+    ['Scott', 25, 'Programmer'],
+    ['Josh', 23, 'Supervisor'],
+    ['Bob', 40, 'Peon']
+    ]
+
+  DMPerson.truncate!
+  
+  x.report('ActiveRecord:insert') do
+    N.times do
+      people.each do |a|
+        ARPerson::create(:name => a[0], :age => a[1], :occupation => a[2])
+      end
+    end
+  end
+  
+  DMPerson.truncate!
+  
+  x.report('DataMapper:insert') do
+    N.times do
+      people.each do |a|
+        DMPerson::create(:name => a[0], :age => a[1], :occupation => a[2])
+      end
+    end
+  end
+  
+  x.report('ActiveRecord:update') do
+    N.times do
+      bob = ARAnimal.find(:first, :conditions => ["name = ?", 'elephant'])
+      bob.notes = 'Updated by ActiveRecord'
+      bob.save
+    end
+  end
+  
+  x.report('DataMapper:update') do
+    N.times do
+      bob = DMAnimal.first(:name => 'elephant')
+      bob.notes = 'Updated by DataMapper'
+      bob.save
+    end
+  end
+  
+  x.report('ActiveRecord:associations:lazy') do
+    N.times do
+      zoos = ARZoo.find(:all)
+      zoos.each { |zoo| zoo.exhibits.entries }
+    end
+  end
+  
+  x.report('ActiveRecord:associations:included') do
+    N.times do
+      zoos = ARZoo.find(:all, :include => [:exhibits])
+      zoos.each { |zoo| zoo.exhibits.entries }
+    end
+  end
+  
+  x.report('DataMapper:associations') do
+    N.times do
+      database do
+        Zoo.all.each { |zoo| zoo.exhibits.entries }
+      end
+    end
+  end
+end