sbf-dm-types 1.3.0.beta

data/lib/dm-types/api_key.rb

@@ -0,0 +1,30 @@
+require 'dm-core'
+
+require 'digest/sha1'
+
+module DataMapper
+  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 }
+        sha1.hexdigest
+      end
+    end
+  end
+end

data/lib/dm-types/bcrypt_hash.rb

@@ -0,0 +1,33 @@
+require 'dm-core'
+require 'bcrypt'
+
+module DataMapper
+  class Property
+    class BCryptHash < String
+      load_as BCrypt::Password
+
+      length 60
+
+      def load(value)
+        typecast(value)
+      end
+
+      def dump(value)
+        hash = typecast(value)
+        return if hash.nil?
+
+        hash_string = hash.to_s
+        hash_string.encode!('UTF-8') if hash_string.respond_to?(:encode!)
+        hash_string
+      end
+
+      def typecast(value)
+        return value if value.nil? || value.kind_of?(BCrypt::Password)
+
+        BCrypt::Password.new(value)
+      rescue BCrypt::Errors::InvalidHash
+        BCrypt::Password.create(value)
+      end
+    end
+  end
+end

data/lib/dm-types/comma_separated_list.rb

@@ -0,0 +1,28 @@
+require 'dm-core'
+require 'dm-types/yaml'
+
+module DataMapper
+  class Property
+    class CommaSeparatedList < Yaml
+
+      def dump(value)
+        if value.nil?
+          nil
+        elsif value.is_a?(::Array)
+          super(value)
+        elsif value.is_a?(::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
+    end
+  end
+end

data/lib/dm-types/csv.rb

@@ -0,0 +1,34 @@
+require 'dm-core'
+require 'dm-types/support/dirty_minder'
+
+if RUBY_VERSION >= '1.9.0'
+  require 'csv'
+else
+  require 'fastercsv' # must be ~>1.5
+  CSV = FasterCSV unless defined?(CSV)
+end
+
+module DataMapper
+  class Property
+    class Csv < String
+      load_as ::Array
+
+      def load(value)
+        case value
+        when ::String then CSV.parse(value)
+        when ::Array  then value
+        end
+      end
+
+      def dump(value)
+        case value
+        when ::Array
+          CSV.generate { |csv| value.each { |row| csv << row } }
+        when ::String then value
+        end
+      end
+
+      include ::DataMapper::Property::DirtyMinder
+    end
+  end
+end

data/lib/dm-types/enum.rb

@@ -0,0 +1,55 @@
+require 'dm-core'
+require 'dm-types/support/flags'
+
+module DataMapper
+  class Property
+    class Enum < Integer
+      min 1
+
+      include Flags
+
+      load_as ::Object
+      dump_as ::Integer
+
+      def initialize(model, name, options = {})
+        @flag_map = {}
+
+        flags = options.fetch(:flags, self.class.flags)
+        flags.each_with_index do |flag, i|
+          @flag_map[i.succ] = flag
+        end
+
+        if self.class.accepted_options.include?(:set) && !options.include?(:set)
+          options[:set] = @flag_map.values_at(*@flag_map.keys.sort)
+        end
+
+        options[:max] = @flag_map.size
+
+        super
+      end
+
+      def load(value)
+        flag_map[value]
+      end
+
+      def dump(value)
+        case value
+        when ::Array then value.collect { |v| dump(v) }
+        else              flag_map.invert[value]
+        end
+      end
+
+      def typecast(value)
+        return if value.nil?
+
+        # Attempt to typecast using the class of the first item in the map.
+        case flag_map[1]
+        when ::Symbol then value.to_sym
+        when ::String then value.to_s
+        when ::Integer then value.to_i
+        else value
+        end
+      end
+    end
+  end
+end

data/lib/dm-types/epoch_time.rb

@@ -0,0 +1,35 @@
+require 'dm-core'
+
+module DataMapper
+  class Property
+    class EpochTime < Time
+      dump_as ::Integer
+
+      def load(value)
+        if value.kind_of?(::Numeric)
+          ::Time.at(value.to_i)
+        else
+          value
+        end
+      end
+
+      def dump(value)
+        value&.to_i
+      end
+
+      def typecast(value)
+        case value
+        when ::Time               then value
+        when ::Numeric, /\A\d+\z/ then ::Time.at(value.to_i)
+        when ::DateTime           then datetime_to_time(value)
+        when ::String             then ::Time.parse(value)
+        end
+      end
+
+      private def datetime_to_time(datetime)
+        utc = datetime.new_offset(0)
+        ::Time.utc(utc.year, utc.month, utc.day, utc.hour, utc.min, utc.sec)
+      end
+    end
+  end
+end

data/lib/dm-types/file_path.rb

@@ -0,0 +1,24 @@
+require 'pathname'
+require 'dm-core'
+
+module DataMapper
+  class Property
+    class FilePath < String
+      load_as Pathname
+
+      length 255
+
+      def load(value)
+        Pathname.new(value) unless DataMapper::Ext.blank?(value)
+      end
+
+      def dump(value)
+        value.to_s unless DataMapper::Ext.blank?(value)
+      end
+
+      def typecast(value)
+        load(value)
+      end
+    end # class FilePath
+  end # class Property
+end # module DataMapper

data/lib/dm-types/flag.rb

@@ -0,0 +1,64 @@
+require 'dm-core'
+require 'dm-types/support/flags'
+
+module DataMapper
+  class Property
+    class Flag < Object
+      include Flags
+
+      load_as ::Object
+      dump_as ::Integer
+
+      def initialize(model, name, options = {})
+        super
+
+        @flag_map = {}
+
+        flags = options.fetch(:flags, self.class.flags)
+        flags.each_with_index do |flag, i|
+          flag_map[i] = flag
+        end
+      end
+
+      def load(value)
+        return [] if value.nil? || value <= 0
+
+        begin
+          matches = []
+
+          0.upto(flag_map.size - 1) do |i|
+            matches << flag_map[i] if value[i] == 1
+          end
+
+          matches.compact
+        rescue TypeError, Errno::EDOM
+          []
+        end
+      end
+
+      def dump(value)
+        unless value.nil?
+          flags = Array(value).map { |flag| flag.to_sym }
+          flags.uniq!
+
+          flag = 0
+
+          flag_map.invert.values_at(*flags).each do |i|
+            next if i.nil?
+            flag += (1 << i)
+          end
+
+          flag
+        end
+      end
+
+      def typecast(value)
+        case value
+          when nil     then nil
+          when ::Array then value.map { |v| v.to_sym }
+          else [value.to_sym]
+        end
+      end
+    end # class Flag
+  end # class Property
+end # module DataMapper

data/lib/dm-types/ip_address.rb

@@ -0,0 +1,34 @@
+require 'ipaddr'
+require 'dm-core'
+
+module DataMapper
+  class Property
+    class IPAddress < String
+      load_as IPAddr
+
+      length 39
+
+      def load(value)
+        if value.nil? || value_loaded?(value)
+          value
+        elsif value.is_a?(::String)
+          if value.empty?
+            IPAddr.new("0.0.0.0")
+          else
+            IPAddr.new(value)
+          end
+        else
+          raise ArgumentError.new("+value+ must be nil or a String")
+        end
+      end
+
+      def dump(value)
+        value.to_s unless value.nil?
+      end
+
+      def typecast(value)
+        load(value) unless value.nil?
+      end
+    end # class IPAddress
+  end # module Property
+end # module DataMapper

data/lib/dm-types/json.rb

@@ -0,0 +1,48 @@
+require 'dm-core'
+require 'dm-types/support/dirty_minder'
+require 'multi_json'
+
+module DataMapper
+  class Property
+    class Json < Text
+      load_as ::Object
+
+      def load(value)
+        if value.nil? || value_loaded?(value)
+          value
+        elsif value.is_a?(::String)
+          typecast(value)
+        else
+          raise ArgumentError.new("+value+ of a property of JSON type must be nil or a String")
+        end
+      end
+
+      def dump(value)
+        if value.nil? || value.is_a?(::String)
+          value
+        else
+          MultiJson.dump(value)
+        end
+      end
+
+      def typecast(value)
+        return if value.nil?
+
+        if value_loaded?(value)
+          value
+        else
+          MultiJson.load(value.to_s)
+        end
+      end
+
+      def value_loaded?(value)
+        value.kind_of?(::Array) || value.kind_of?(::Hash)
+      end
+
+      include ::DataMapper::Property::DirtyMinder
+
+    end # class Json
+
+    JSON = Json
+  end # class Property
+end # module DataMapper

data/lib/dm-types/paranoid/base.rb

@@ -0,0 +1,56 @@
+module DataMapper
+  module Types
+    module Paranoid
+      module Base
+        def self.included(model)
+          model.extend ClassMethods
+          model.instance_variable_set(:@paranoid_properties, {})
+        end
+
+        def paranoid_destroy
+          model.paranoid_properties.each do |name, block|
+            attribute_set(name, block.call(self))
+          end
+          save_self
+          self.persistence_state = Resource::PersistenceState::Immutable.new(self)
+          true
+        end
+
+      private
+
+        # @api private
+        def _destroy(execute_hooks = true)
+          return false unless saved?
+
+          if execute_hooks
+            paranoid_destroy
+          else
+            super
+          end
+        end
+      end
+
+      module ClassMethods
+        def inherited(model)
+          model.instance_variable_set(:@paranoid_properties, @paranoid_properties.dup)
+          super
+        end
+
+        # @api public
+        def with_deleted
+          with_exclusive_scope({}) { block_given? ? yield : all }
+        end
+
+        # @api private
+        def paranoid_properties
+          @paranoid_properties
+        end
+
+        # @api private
+        def set_paranoid_property(name, &block)
+          paranoid_properties[name] = block
+        end
+      end
+    end
+  end
+end

data/lib/dm-types/paranoid_boolean.rb

@@ -0,0 +1,23 @@
+require 'dm-types/paranoid/base'
+
+module DataMapper
+  class Property
+    class ParanoidBoolean < Boolean
+      default false
+      lazy    true
+
+      # @api private
+      def bind
+        property_name = name.inspect
+
+        model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          include DataMapper::Types::Paranoid::Base
+
+          set_paranoid_property(#{property_name}) { true }
+
+          default_scope(#{repository_name.inspect}).update(#{property_name} => false)
+        RUBY
+      end
+    end # class ParanoidBoolean
+  end # module Property
+end # module DataMapper

data/lib/dm-types/paranoid_datetime.rb

@@ -0,0 +1,22 @@
+require 'dm-types/paranoid/base'
+
+module DataMapper
+  class Property
+    class ParanoidDateTime < DateTime
+      lazy true
+
+      # @api private
+      def bind
+        property_name = name.inspect
+
+        model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          include DataMapper::Types::Paranoid::Base
+
+          set_paranoid_property(#{property_name}) { ::DateTime.now }
+
+          default_scope(#{repository_name.inspect}).update(#{property_name} => nil)
+        RUBY
+      end
+    end
+  end
+end

data/lib/dm-types/regexp.rb

@@ -0,0 +1,21 @@
+require 'dm-core'
+
+module DataMapper
+  class Property
+    class Regexp < String
+      load_as ::Regexp
+
+      def load(value)
+        ::Regexp.new(value) unless value.nil?
+      end
+
+      def dump(value)
+        value.source unless value.nil?
+      end
+
+      def typecast(value)
+        load(value)
+      end
+    end
+  end
+end

data/lib/dm-types/slug.rb

@@ -0,0 +1,28 @@
+require 'dm-core'
+require 'stringex'
+
+module DataMapper
+  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 DataMapper