dm-types 0.10.2 → 1.0.0.rc1

data/lib/dm-types/csv.rb

@@ -1,3 +1,5 @@
+require 'dm-core'
+
 if RUBY_VERSION >= '1.9.0'
   require 'csv'
 else
@@ -6,27 +8,25 @@ else
 end
 
 module DataMapper
-  module Types
-    class Csv < DataMapper::Type
-      primitive Text
-
-      def self.load(value, property)
+  class Property
+    class Csv < Text
+      def load(value)
         case value
-          when String then CSV.parse(value)
-          when Array  then value
+          when ::String then CSV.parse(value)
+          when ::Array  then value
           else
             nil
         end
       end
 
-      def self.dump(value, property)
+      def dump(value)
         case value
-          when Array  then CSV.generate { |csv| value.each { |row| csv << row } }
-          when String then value
+          when ::Array  then CSV.generate { |csv| value.each { |row| csv << row } }
+          when ::String then value
           else
             nil
         end
       end
     end # class Csv
-  end # module Types
+  end # class Property
 end # module DataMapper

data/lib/dm-types/enum.rb

@@ -1,73 +1,56 @@
-module DataMapper
-  module Types
-    class Enum < Type
-      primitive Integer
+require 'dm-core'
 
-      def self.inherited(target)
-        target.instance_variable_set("@primitive", self.primitive)
-      end
+module DataMapper
+  class Property
+    class Enum < Integer
+      accept_options :flags
 
-      def self.flag_map
-        @flag_map
-      end
+      attr_reader :flag_map
 
-      def self.flag_map=(value)
-        @flag_map = value
-      end
+      def initialize(model, name, options = {}, type = nil)
+        super
 
-      def self.new(*flags)
-        enum = Class.new(Enum)
-        enum.flag_map = {}
+        @flag_map = {}
 
+        flags = options.fetch(:flags)
         flags.each_with_index do |flag, i|
-          enum.flag_map[i + 1] = flag
+          @flag_map[i + 1] = flag
         end
 
-        enum
+        if defined?(::DataMapper::Validations)
+          unless model.skip_auto_validation_for?(self)
+            if self.class.ancestors.include?(Property::Enum)
+              allowed = flag_map.values_at(*flag_map.keys.sort)
+              model.validates_within name, model.options_with_message({ :set => allowed }, self, :within)
+            end
+          end
+        end
       end
 
-      def self.[](*flags)
-        new(*flags)
+      def custom?
+        true
       end
 
-      def self.load(value, property)
-        self.flag_map[value]
+      def load(value)
+        flag_map[value]
       end
 
-      def self.dump(value, property)
+      def dump(value)
         case value
-          when Array then value.collect { |v| self.dump(v, property) }
-          else            self.flag_map.invert[value]
+        when ::Array then value.collect { |v| dump(v) }
+        else              flag_map.invert[value]
         end
       end
 
-      def self.typecast(value, property)
+      def typecast_to_primitive(value)
         # Attempt to typecast using the class of the first item in the map.
-        return value if value.nil?
-        case self.flag_map[1]
-          when Symbol then value.to_sym
-          when String then value.to_s
-          when Fixnum then value.to_i
-          else             value
-        end
-      end
-
-      def self.bind(property)
-        if defined?(::DataMapper::Validate)
-          model = property.model
-
-          unless model.skip_auto_validation_for?(property)
-            if property.type.ancestors.include?(Types::Enum)
-              model.class_eval do
-                flag_map = property.type.flag_map
-                allowed  = flag_map.values_at(*flag_map.keys.sort)
-
-                validates_within property.name, options_with_message({ :set => allowed }, property, :within)
-              end
-            end
-          end
+        case flag_map[1]
+        when ::Symbol then value.to_sym
+        when ::String then value.to_s
+        when ::Fixnum then value.to_i
+        else               value
         end
       end
     end # class Enum
-  end # module Types
+  end # class Property
 end # module DataMapper

data/lib/dm-types/epoch_time.rb

@@ -1,22 +1,22 @@
-module DataMapper
-  module Types
-    class EpochTime < DataMapper::Type
-      primitive Integer
+require 'dm-core'
 
-      def self.load(value, property)
-        if value.kind_of?(Integer)
-          Time.at(value)
+module DataMapper
+  class Property
+    class EpochTime < Integer
+      def load(value)
+        if value.kind_of?(::Integer)
+          ::Time.at(value)
         else
           value
         end
       end
 
-      def self.dump(value, property)
+      def dump(value)
         case value
-          when Integer, Time then value.to_i
-          when DateTime      then value.to_time.to_i
+          when ::Integer, ::Time then value.to_i
+          when ::DateTime      then value.to_time.to_i
         end
       end
     end # class EpochTime
-  end # module Types
+  end # class Property
 end # module DataMapper

data/lib/dm-types/file_path.rb

@@ -1,12 +1,16 @@
 require 'pathname'
+require 'dm-core'
 
 module DataMapper
-  module Types
-    class FilePath < DataMapper::Type
-      primitive String
-      length    255
+  class Property
+    class FilePath < String
+      length 255
 
-      def self.load(value, property)
+      def primitive?(value)
+        value.kind_of?(Pathname)
+      end
+
+      def load(value)
         if value.blank?
           nil
         else
@@ -14,15 +18,14 @@ module DataMapper
         end
       end
 
-      def self.dump(value, property)
+      def dump(value)
         return nil if value.blank?
         value.to_s
       end
 
-      def self.typecast(value, property)
-        # Leave alone if a Pathname is given.
-        value.kind_of?(Pathname) ? value : load(value, property)
+      def typecast_to_primitive(value)
+        load(value)
       end
     end # class FilePath
-  end # module Types
+  end # class Property
 end # module DataMapper

data/lib/dm-types/flag.rb

@@ -1,36 +1,28 @@
-module DataMapper
-  module Types
-    class Flag < Type
-      primitive Integer
+require 'dm-core'
 
-      def self.inherited(target)
-        target.instance_variable_set('@primitive', self.primitive)
-      end
+module DataMapper
+  class Property
+    class Flag < Integer
+      accept_options :flags
 
-      def self.flag_map
-        @flag_map
-      end
+      attr_reader :flag_map
 
-      def self.flag_map=(value)
-        @flag_map = value
-      end
+      def initialize(model, name, options = {}, type = nil)
+        super
 
-      def self.new(*flags)
-        type = Class.new(Flag)
-        type.flag_map = {}
+        @flag_map = {}
 
+        flags = options.fetch(:flags)
         flags.each_with_index do |flag, i|
-          type.flag_map[i] = flag
+          flag_map[i] = flag
         end
-
-        type
       end
 
-      def self.[](*flags)
-        new(*flags)
+      def custom?
+        true
       end
 
-      def self.load(value, property)
+      def load(value)
         return [] if value.nil? || value <= 0
 
         begin
@@ -46,13 +38,13 @@ module DataMapper
         end
       end
 
-      def self.dump(value, property)
+      def dump(value)
         return if value.nil?
         flags = Array(value).map { |flag| flag.to_sym }.flatten
         flag_map.invert.values_at(*flags).compact.inject(0) { |sum, i| sum += 1 << i }
       end
 
-      def self.typecast(value, property)
+      def typecast(value)
         case value
           when nil   then nil
           when Array then value.map {|v| v.to_sym}
@@ -60,5 +52,5 @@ module DataMapper
         end
       end
     end # class Flag
-  end # module Types
+  end # class Property
 end # module DataMapper

data/lib/dm-types/ip_address.rb

@@ -1,31 +1,35 @@
 require 'ipaddr'
+require 'dm-core'
 
 module DataMapper
-  module Types
-    class IPAddress < DataMapper::Type
-      primitive String
-      length    16
+  class Property
+    class IPAddress < String
+      length 39
 
-      def self.load(value, property)
+      def primitive?(value)
+        value.kind_of?(IPAddr)
+      end
+
+      def load(value)
         if value.nil?
           nil
-        elsif value.is_a?(String) && !value.empty?
+        elsif value.is_a?(::String) && !value.empty?
           IPAddr.new(value)
-        elsif value.is_a?(String) && value.empty?
+        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)
+      def dump(value)
         return nil if value.nil?
         value.to_s
       end
 
-      def self.typecast(value, property)
-        value.kind_of?(IPAddr) ? value : load(value, property)
+      def typecast_to_primitive(value)
+        load(value)
       end
     end # class IPAddress
-  end # module Types
+  end # module Property
 end # module DataMapper

data/lib/dm-types/json.rb

@@ -1,36 +1,39 @@
+require 'dm-core'
 require 'json'
 
 module DataMapper
-  module Types
-    class Json < DataMapper::Type
-      primitive Text
+  class Property
+    class Json < Text
+      def custom?
+        true
+      end
+
+      def primitive?(value)
+        value.kind_of?(::Array) || value.kind_of?(::Hash)
+      end
 
-      def self.load(value, property)
+      def load(value)
         if value.nil?
           nil
-        elsif value.is_a?(String)
+        elsif value.is_a?(::String)
           ::JSON.load(value)
         else
           raise ArgumentError.new("+value+ of a property of JSON type must be nil or a String")
         end
       end
 
-      def self.dump(value, property)
-        if value.nil? || value.is_a?(String)
+      def dump(value)
+        if value.nil? || value.is_a?(::String)
           value
         else
           ::JSON.dump(value)
         end
       end
 
-      def self.typecast(value, property)
-        if value.nil? || value.kind_of?(Array) || value.kind_of?(Hash)
-          value
-        else
-          ::JSON.load(value.to_s)
-        end
+      def typecast_to_primitive(value)
+        ::JSON.load(value.to_s)
       end
     end # class Json
     JSON = Json
-  end # module Types
+  end # class Property
 end # module DataMapper

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

@@ -0,0 +1,38 @@
+module DataMapper
+  module Types
+    module Paranoid
+      module Base
+        def self.included(model)
+          model.extend ClassMethods
+        end
+
+        def paranoid_destroy
+          model.paranoid_properties.each do |name, block|
+            attribute_set(name, block.call(self))
+          end
+          save_self
+          self.persisted_state = Resource::State::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 Base
+
+      module ClassMethods
+        def with_deleted
+          with_exclusive_scope({}) { block_given? ? yield : all }
+        end
+      end # module ClassMethods
+    end # module Paranoid
+  end # module Types
+end # module DataMapper

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 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