mack-data_mapper 0.8.1 → 0.8.2

data/lib/gems/dm-types-0.9.7/lib/dm-types/flag.rb

@@ -0,0 +1,61 @@
+module DataMapper
+  module Types
+    class Flag < DataMapper::Type(Integer)
+      def self.inherited(target)
+        target.instance_variable_set("@primitive", self.primitive)
+      end
+
+      def self.flag_map
+        @flag_map
+      end
+
+      def self.flag_map=(value)
+        @flag_map = value
+      end
+
+      def self.new(*flags)
+        type = Class.new(Flag)
+        type.flag_map = {}
+
+        flags.each_with_index do |flag, i|
+          type.flag_map[2 ** i] = flag
+        end
+
+        type
+      end
+
+      def self.[](*flags)
+        new(*flags)
+      end
+
+      def self.load(value, property)
+        begin
+          matches = []
+
+          0.upto((Math.log(value) / Math.log(2)).ceil) do |i|
+            pow = 2 ** i
+            matches << flag_map[pow] if value & pow == pow
+          end
+
+          matches.compact
+        rescue TypeError, Errno::EDOM
+          []
+        end
+      end
+
+      def self.dump(value, property)
+        return if value.nil?
+        flags = value.is_a?(Array) ? value : [value]
+        flags.map!{ |f| f.to_sym }
+        flag_map.invert.values_at(*flags.flatten).compact.inject(0) { |sum, i| sum + i }
+      end
+
+      def self.typecast(value, property)
+        case value
+        when Array then value.map {|v| v.to_sym}
+        else value.to_sym
+        end
+      end
+    end # class Flag
+  end # module Types
+end # module DataMapper

data/lib/gems/dm-types-0.9.7/lib/dm-types/ip_address.rb

@@ -0,0 +1,30 @@
+require 'ipaddr'
+
+module DataMapper
+  module Types
+    class IPAddress < DataMapper::Type
+      primitive String
+
+      def self.load(value, property)
+        if value.nil?
+          nil
+        elsif value.is_a?(String) && !value.empty?
+          IPAddr.new(value)
+        elsif value.is_a?(String) && value.empty?
+          IPAddr.new("0.0.0.0")
+        else
+          raise ArgumentError.new("+value+ must be nil or a String")
+        end
+      end
+
+      def self.dump(value, property)
+        return nil if value.nil?
+        value.to_s
+      end
+
+      def self.typecast(value, property)
+        value.kind_of?(IPAddr) ? value : load(value, property)
+      end
+    end # class IPAddress
+  end # module Types
+end # module DataMapper

data/lib/gems/dm-types-0.9.7/lib/dm-types/json.rb

@@ -0,0 +1,40 @@
+require 'json'
+
+module DataMapper
+  module Types
+    class Json < DataMapper::Type
+      primitive String
+      size 65535
+      lazy true
+
+      def self.load(value, property)
+        if value.nil?
+          nil
+        elsif value.is_a?(String)
+          ::JSON.load(value)
+        else
+          raise ArgumentError.new("+value+ must be nil or a String")
+        end
+      end
+
+      def self.dump(value, property)
+        if value.nil?
+          nil
+        elsif value.is_a?(String)
+          value
+        else
+          ::JSON.dump(value)
+        end
+      end
+
+      def self.typecast(value, property)
+        # Arrays and hashes are left alone, while strings are parsed as JSON.
+        if value.kind_of?(Array) || value.kind_of?(Hash)
+          value
+        else
+          ::JSON.load(value.to_s)
+        end
+      end
+    end # class Json
+  end # module Types
+end # module DataMapper

data/lib/gems/dm-types-0.9.7/lib/dm-types/regexp.rb

@@ -0,0 +1,20 @@
+module DataMapper
+  module Types
+    class Regexp < DataMapper::Type
+      primitive String
+
+      def self.load(value, property)
+        ::Regexp.new(value) unless value.nil?
+      end
+
+      def self.dump(value, property)
+        return nil if value.nil?
+        value.source
+      end
+
+      def self.typecast(value, property)
+        value.kind_of?(::Regexp) ? value : load(value, property)
+      end
+    end
+  end
+end

data/lib/gems/dm-types-0.9.7/lib/dm-types/serial.rb

@@ -0,0 +1,8 @@
+module DataMapper
+  module Types
+    class Serial < DataMapper::Type
+      primitive Integer
+      serial true
+    end # class Serial
+  end # module Types
+end # module DataMapper

data/lib/gems/dm-types-0.9.7/lib/dm-types/slug.rb

@@ -0,0 +1,37 @@
+require 'iconv'
+
+module DataMapper
+  module Types
+    class Slug < DataMapper::Type
+      primitive String
+      size 65535
+
+      def self.load(value, property)
+        value
+      end
+
+      def self.dump(value, property)
+        if value.nil?
+          nil
+        elsif value.is_a?(String)
+          #Iconv.new('UTF-8//TRANSLIT//IGNORE', 'UTF-8').iconv(value.gsub(/[^\w\s\-\—]/,'').gsub(/[^\w]|[\_]/,' ').split.join('-').downcase).to_s
+          escape(value)
+        else
+          raise ArgumentError.new("+value+ must be nil or a String")
+        end
+      end
+
+      # Hugs and kisses to Rick Olsons permalink_fu for the escape method
+      def self.escape(string)
+        result = Iconv.iconv('ascii//translit//IGNORE', 'utf-8', string).to_s
+        result.gsub!(/[^\x00-\x7F]+/, '')  # Remove anything non-ASCII entirely (e.g. diacritics).
+        result.gsub!(/[^\w_ \-]+/i,   '')  # Remove unwanted chars.
+        result.gsub!(/[ \-]+/i,      '-')  # No more than one of the separator in a row.
+        result.gsub!(/^\-|\-$/i,      '')  # Remove leading/trailing separator.
+        result.downcase!
+        result
+      end
+
+    end # class Slug
+  end # module Types
+end # module DataMapper

data/lib/gems/dm-types-0.9.7/lib/dm-types/uri.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'addressable/uri'
+
+module DataMapper
+  module Types
+    class URI < DataMapper::Type
+      primitive String
+
+      def self.load(value, property)
+        Addressable::URI.parse(value)
+      end
+
+      def self.dump(value, property)
+        return nil if value.nil?
+        value.to_s
+      end
+
+      def self.typecast(value, property)
+        if value.kind_of?(Addressable::URI)
+          value
+        elsif value.nil?
+          load(nil, property)
+        else
+          load(value.to_s, property)
+        end
+      end
+    end # class URI
+  end # module Types
+end # module DataMapper

data/lib/gems/dm-types-0.9.7/lib/dm-types/uuid.rb

@@ -0,0 +1,64 @@
+require 'uuidtools'
+
+module DataMapper
+  module Types
+    # 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 < DataMapper::Type
+      primitive String
+      size 36
+
+      def self.load(value, property)
+        return nil if value.nil?
+        ::UUID.parse(value)
+      end
+
+      def self.dump(value, property)
+        return nil if value.nil?
+        value.to_s
+      end
+
+      def self.typecast(value, property)
+        value.kind_of?(::UUID) ? value : load(value, property)
+      end
+
+      #::DataMapper::Property::TYPES << self
+      #if defined? DataMapper::Adapters::PostgresAdapter
+      #  DataMapper::Adapters::PostgresAdapter.type_map.map(self).to('UUID').with(:size => nil)
+      #end
+    end
+  end
+end

data/lib/gems/dm-types-0.9.7/lib/dm-types/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  module Types
+    VERSION = "0.9.7"
+  end
+end

data/lib/gems/dm-types-0.9.7/lib/dm-types/yaml.rb

@@ -0,0 +1,36 @@
+require 'yaml'
+
+module DataMapper
+  module Types
+    class Yaml < DataMapper::Type
+      primitive String
+      size 65535
+      lazy true
+
+      def self.load(value, property)
+        if value.nil?
+          nil
+        elsif value.is_a?(String)
+          ::YAML.load(value)
+        else
+          raise ArgumentError.new("+value+ must be nil or a String")
+        end
+      end
+
+      def self.dump(value, property)
+        if value.nil?
+          nil
+        elsif value.is_a?(String) && value =~ /^---/
+          value
+        else
+          ::YAML.dump(value)
+        end
+      end
+
+      def self.typecast(value, property)
+        # No typecasting; leave values exactly as they're provided.
+        value
+      end
+    end # class Yaml
+  end # module Types
+end # module DataMapper

data/lib/gems/dm-types-0.9.7/lib/dm-types.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'pathname'
+
+gem 'dm-core', '~>0.9.7'
+require 'dm-core'
+
+dir = Pathname(__FILE__).dirname.expand_path / 'dm-types'
+
+require dir / 'csv'
+require dir / 'enum'
+require dir / 'epoch_time'
+require dir / 'file_path'
+require dir / 'flag'
+require dir / 'ip_address'
+require dir / "json"""
+require dir / 'uri'
+require dir / 'uuid'
+require dir / 'yaml'
+require dir / 'serial'
+require dir / 'regexp'
+require dir / 'slug'
+
+# this looks a little ugly, but everyone who uses dm-types shouldn't have to have ruby-bcrypt installed
+module DataMapper
+  module Types
+    autoload(:BCryptHash, File.join(Pathname(__FILE__).dirname.expand_path, 'dm-types', 'bcrypt_hash'))
+  end
+end

data/lib/gems/dm-validations-0.9.7/lib/dm-validations/absent_field_validator.rb

@@ -0,0 +1,60 @@
+module DataMapper
+  module Validate
+
+    ##
+    #
+    # @author Guy van den Berg
+    # @since  0.9
+    class AbsentFieldValidator < GenericValidator
+
+      def initialize(field_name, options={})
+        super
+        @field_name, @options = field_name, options
+      end
+
+      def call(target)
+        field_value = target.send(field_name).blank?
+        return true if field_value
+
+        error_message = @options[:message] || "%s must be absent".t(Extlib::Inflection.humanize(@field_name))
+        add_error(target, error_message , @field_name)
+
+        return false
+      end
+    end # class AbsentFieldValidator
+
+    module ValidatesAbsent
+
+      ##
+      # Validates that the specified attribute is "blank" via the attribute's
+      # #blank? method.
+      #
+      # @note
+      #   dm-core's support lib adds the #blank? method to many classes,
+      # @see lib/dm-core/support/blank.rb (dm-core) for more information.
+      #
+      # @example [Usage]
+      #   require 'dm-validations'
+      #
+      #   class Page
+      #     include DataMapper::Resource
+      #
+      #     property :unwanted_attribute, String
+      #     property :another_unwanted, String
+      #     property :yet_again, String
+      #
+      #     validates_absent :unwanted_attribute
+      #     validates_absent :another_unwanted, :yet_again
+      #
+      #     # a call to valid? will return false unless
+      #     # all three attributes are blank
+      #   end
+      #
+      def validates_absent(*fields)
+        opts = opts_from_validator_args(fields)
+        add_validator_to_context(opts, fields, DataMapper::Validate::AbsentFieldValidator)
+      end
+
+    end # module ValidatesAbsent
+  end # module Validate
+end # module DataMapper

data/lib/gems/dm-validations-0.9.7/lib/dm-validations/acceptance_validator.rb

@@ -0,0 +1,76 @@
+module DataMapper
+  module Validate
+
+    ##
+    #
+    # @author Martin Kihlgren
+    # @since  0.9
+    class AcceptanceValidator < GenericValidator
+
+      def self.default_message_for_field(field_name)
+        '%s is not accepted'.t(Extlib::Inflection.humanize(field_name))
+      end
+
+      def initialize(field_name, options = {})
+        super
+        @options = options
+        @field_name = field_name
+        @options[:allow_nil] = true unless @options.include?(:allow_nil)
+        @options[:accept] ||= ["1",1,"true",true,"t"]
+        @options[:accept] = Array(@options[:accept])
+      end
+
+      def call(target)
+        unless valid?(target)
+          error_message = @options[:message] || DataMapper::Validate::AcceptanceValidator.default_message_for_field(@field_name)
+          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?
+        return false if !@options[:allow_nil] && field_value.nil?
+
+        @options[:accept].include?(field_value)
+      end
+
+    end # class AcceptanceValidator
+
+    module ValidatesIsAccepted
+
+      ##
+      # Validates that the attributes's value is in the set of accepted values.
+      #
+      # @option :allow_nil<Boolean> true if nil is allowed, false if nil is not
+      #                             allowed. Default is true.
+      # @option :accept<Array>      a list of accepted values.
+      #                             Default are ["1",1,"true",true,"t"]).
+      #
+      # @example [Usage]
+      #   require 'dm-validations'
+      #
+      #   class Page
+      #     include DataMapper::Resource
+      #
+      #     property :license_agreement_accepted, String
+      #     property :terms_accepted, String
+      #     validates_is_accepted :license_agreement, :accept => "1"
+      #     validates_is_accepted :terms_accepted, :allow_nil => false
+      #
+      #     # a call to valid? will return false unless:
+      #     # license_agreement is nil or "1"
+      #     # and
+      #     # terms_accepted is one of ["1",1,"true",true,"t"]
+      #
+      def validates_is_accepted(*fields)
+        opts = opts_from_validator_args(fields)
+        add_validator_to_context(opts, fields, DataMapper::Validate::AcceptanceValidator)
+      end
+
+    end # module ValidatesIsAccepted
+  end # module Validate
+end # module DataMapper

data/lib/gems/dm-validations-0.9.7/lib/dm-validations/auto_validate.rb

@@ -0,0 +1,153 @@
+module DataMapper
+  class Property
+    # for options_with_message
+    PROPERTY_OPTIONS << :message << :messages << :set
+  end
+
+  module Validate
+    module AutoValidate
+      # adds message for validator
+      def options_with_message(base_options, property, validator_name)
+        options = base_options.clone
+        opts = property.options
+        options[:message] = if opts[:messages]
+          if opts[:messages].is_a?(Hash) and msg = opts[:messages][validator_name]
+            msg
+          else
+            nil
+          end
+        elsif opts[:message]
+          opts[:message]
+        else
+          nil
+        end
+        options
+      end
+
+
+      ##
+      # Auto-generate validations for a given property. This will only occur
+      # if the option :auto_validation is either true or left undefined.
+      #
+      # @details [Triggers]
+      #   Triggers that generate validator creation
+      #
+      #   :nullable => false
+      #       Setting the option :nullable to false causes a
+      #       validates_presence_of validator to be automatically created on
+      #       the property
+      #
+      #   :size => 20 or :length => 20
+      #       Setting the option :size or :length causes a validates_length_of
+      #       validator to be automatically created on the property. If the
+      #       value is a Integer the validation will set :maximum => value if
+      #       the value is a Range the validation will set :within => value
+      #
+      #   :format => :predefined / lambda / Proc
+      #       Setting the :format option causes a validates_format_of
+      #       validator to be automatically created on the property
+      #
+      #   :set => ["foo", "bar", "baz"]
+      #       Setting the :set option causes a validates_within
+      #       validator to be automatically created on the property
+      #
+      #   Integer type
+      #       Using a Integer type causes a validates_is_number
+      #       validator to be created for the property.  integer_only
+      #       is set to true
+      #
+      #   BigDecimal or Float type
+      #       Using a Integer type causes a validates_is_number
+      #       validator to be created for the property.  integer_only
+      #       is set to false, and precision/scale 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
+      #
+      def auto_generate_validations(property)
+        property.options[:auto_validation] = true unless property.options.has_key?(:auto_validation)
+        return unless property.options[:auto_validation]
+
+        # a serial property is allowed to be nil too, because the
+        # value is set by the storage system
+        opts = { :allow_nil => property.nullable? || property.serial? }
+        opts[:context] = property.options[:validates] if property.options.has_key?(:validates)
+
+        # presence
+        unless opts[:allow_nil]
+          # validates_present property.name, opts
+          validates_present property.name, options_with_message(opts, property, :presence)
+        end
+
+        # length
+        if property.type == String
+          #len = property.length  # XXX: maybe length should always return a Range, with the min defaulting to 1
+          len = property.options.fetch(:length, property.options.fetch(:size, DataMapper::Property::DEFAULT_LENGTH))
+          if len.is_a?(Range)
+            opts[:within] = len
+          else
+            opts[:maximum] = len
+          end
+          # validates_length property.name, opts
+          validates_length property.name, options_with_message(opts, property, :length)
+        end
+
+        # format
+        if property.options.has_key?(:format)
+          opts[:with] = property.options[:format]
+          # validates_format property.name, opts
+          validates_format property.name, options_with_message(opts, property, :format)
+        end
+
+        # uniqueness validator
+        if property.options.has_key?(:unique)
+          value = property.options[:unique]
+          if value.is_a?(Array) || value.is_a?(Symbol)
+            # validates_is_unique property.name, :scope => Array(value)
+            validates_is_unique property.name, options_with_message({:scope => Array(value)}, property, :is_unique)
+          elsif value.is_a?(TrueClass)
+            # validates_is_unique property.name
+            validates_is_unique property.name, options_with_message({}, property, :is_unique)
+          end
+        end
+
+        # within validator
+        if property.options.has_key?(:set)
+          validates_within property.name, options_with_message({:set => property.options[:set]}, property, :within)
+        end
+
+        # numeric validator
+        if Integer == property.type
+          opts[:integer_only] = true
+          # validates_is_number property.name, opts
+          validates_is_number property.name, options_with_message(opts, property, :is_number)
+        elsif BigDecimal == property.type || Float == property.type
+          opts[:precision] = property.precision
+          opts[:scale]     = property.scale
+          # validates_is_number property.name, opts
+          validates_is_number property.name, options_with_message(opts, property, :is_number)
+        else
+          # We only need this in the case we don't already
+          # have a numeric validator, because otherwise
+          # it will cause duplicate validation errors
+          unless property.custom?
+            # validates_is_primitive property.name, opts
+            validates_is_primitive property.name, options_with_message(opts, property, :is_primitive)
+          end
+        end
+      end
+
+    end # module AutoValidate
+  end # module Validate
+end # module DataMapper