axiom-types 0.0.2 → 0.0.3

data/lib/axiom/types/encodable.rb

@@ -69,7 +69,7 @@ module Axiom
         constraint { |object| object.encoding.equal?(encoding) }
       end
 
-    end if RUBY_VERSION >= '1.9'
+    end
 
   end # module Types
 end # module Axiom

data/lib/axiom/types/float.rb

@@ -8,6 +8,9 @@ module Axiom
       primitive       ::Float
       coercion_method :to_float
 
+      minimum primitive::MIN
+      maximum primitive::MAX
+
     end # class Float
   end # module Types
 end # module Axiom

data/lib/axiom/types/hash.rb

@@ -14,6 +14,9 @@ module Axiom
 
       # Infer the type of the object
       #
+      # @example
+      #   type = Axiom::Types.infer(object)
+      #
       # @param [Object] object
       #
       # @return [Class<Axiom::Types::Hash>]
@@ -60,6 +63,7 @@ module Axiom
         value_type = Types.infer(value) || Object
         infer_from(key_type, value_type) || new_from(key_type, value_type)
       end
+      private_class_method :infer_from_primitive_instance
 
       # Infer the type from the key_type and value_type
       #
@@ -77,6 +81,7 @@ module Axiom
           self
         end
       end
+      private_class_method :infer_from
 
       # Instantiate a new type from a base type
       #
@@ -92,6 +97,7 @@ module Axiom
       def self.new_from(key_type, value_type)
         new { key_type(key_type).value_type(value_type) } if base?
       end
+      private_class_method :new_from
 
       # Test if the type is a base type
       #
@@ -101,6 +107,7 @@ module Axiom
       def self.base?
         equal?(Hash)
       end
+      private_class_method :base?
 
       # Add a constraints for the key and value
       #
@@ -114,9 +121,7 @@ module Axiom
           end
         end
       end
-
-      private_class_method :infer_from_primitive_instance, :infer_from,
-        :new_from, :base?, :matches_key_and_value_types
+      private_class_method :matches_key_and_value_types
 
     end # class Hash
   end # module Types

data/lib/axiom/types/length_comparable.rb

@@ -17,7 +17,11 @@ module Axiom
       # @api private
       def self.extended(descendant)
         super
-        descendant.accept_options :minimum_length, :maximum_length
+        descendant.class_eval do
+          accept_options :minimum_length, :maximum_length
+          minimum_length Infinity
+          maximum_length NegativeInfinity
+        end
       end
 
       # Finalize by setting up a length range constraint
@@ -41,9 +45,8 @@ module Axiom
       #
       # @api private
       def has_length_within_range
-        constraint do |object|
-          object.length.between?(minimum_length, maximum_length)
-        end
+        range = minimum_length..maximum_length
+        constraint { |object| range.cover?(object.length) }
       end
 
     end # module LengthComparable

data/lib/axiom/types/numeric.rb

@@ -5,9 +5,14 @@ module Axiom
 
     # Represents a numeric type
     class Numeric < Object
+      extend ValueComparable
+
       primitive       ::Numeric
       coercion_method :to_numeric
 
+      minimum NegativeInfinity
+      maximum Infinity
+
     end # class Numeric
   end # module Types
 end # module Axiom

data/lib/axiom/types/object.rb

@@ -51,6 +51,7 @@ module Axiom
         self if object.respond_to?(:ancestors) &&
                 object.ancestors.include?(primitive)
       end
+      private_class_method :infer_from_primitive_class
 
       # Add a constraint for the primitive
       #
@@ -60,8 +61,7 @@ module Axiom
       def self.inherits_from_primitive
         constraint(&primitive.method(:===))
       end
-
-      private_class_method :infer_from_primitive_class, :inherits_from_primitive
+      private_class_method :inherits_from_primitive
 
     end # class Object
   end # module Types

data/lib/axiom/types/support/infinity.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+
+module Axiom
+  module Types
+
+    # Represent an infinite number
+    class Infinity < BasicObject
+      extend ::Comparable
+
+      # Test the number against infinity
+      #
+      # @param [Numeric, Infinity] other
+      #
+      # @return [0]
+      #   returned if the other object is infinity
+      # @return [1]
+      #   returned if the other object is something other than infinity
+      #
+      # @api private
+      def self.<=>(other)
+        case other
+        when ::BigDecimal                       then 1
+        when number                             then 0
+        when ::Numeric, inverse.singleton_class then 1
+        end
+      end
+
+      # Coerce a number into an Infinity class for comparison
+      #
+      # @param [::Numeric] other
+      #
+      # @return [Array(Infinity, Infinity)]
+      #
+      # @api private
+      def self.coerce(other)
+        case other
+        when ::BigDecimal then [inverse, self]
+        when number       then [self,    self]
+        when ::Numeric    then [inverse, self]
+        else
+          raise ::TypeError, "#{other.class} cannot be coerced"
+        end
+      end
+
+      # Return the next successive object, which is always self
+      #
+      # @return [Class<Infinity>]
+      #
+      # @api private
+      def self.succ
+        self
+      end
+
+      # The inverse of infinity
+      #
+      # @return [Class<NegativeInfinity>]
+      #
+      # @api private
+      def self.inverse
+        NegativeInfinity
+      end
+      private_class_method :inverse
+
+      # The numeric representation of infinity
+      #
+      # @return [Float]
+      #
+      # @api private
+      def self.number
+        ::Float::INFINITY
+      end
+      private_class_method :number
+
+    end # class Infinity
+
+    # Represent a negative infinite number
+    class NegativeInfinity < Infinity
+
+      # Test the number against negative infinity
+      #
+      # @param [Numeric, Infinity] _other
+      #
+      # @return [0]
+      #   returned if the other object is negative infinity
+      # @return [-1]
+      #   returned if the other object is not negative infinity
+      #
+      # @api private
+      def self.<=>(_other)
+        comparison = super
+        -comparison if comparison
+      end
+
+      # The inverse of negative infinity
+      #
+      # @return [Class<Infinity>]
+      #
+      # @api private
+      def self.inverse
+        Infinity
+      end
+      private_class_method :inverse
+
+      # The numeric representation of negative infinity
+      #
+      # @return [Float]
+      #
+      # @api private
+      def self.number
+        -::Float::INFINITY
+      end
+      private_class_method :number
+
+    end # class NegativeInfinity
+  end # module Types
+end # module Axiom

data/lib/axiom/types/support/options.rb

@@ -22,15 +22,15 @@ module Axiom
       def accept_options(*new_options)
         (new_options - accepted_options).each do |new_option|
           assert_method_available(new_option)
-          add_accepted_option(new_option)
           define_option_method(new_option)
+          setup_option(new_option)
         end
         self
       end
 
     protected
 
-      # Adds new option that an attribute class can accept
+      # Set up the option in the current class and descendants
       #
       # @param [Symbol] new_option
       #   new option to be added
@@ -38,7 +38,8 @@ module Axiom
       # @return [self]
       #
       # @api private
-      def add_accepted_option(new_option)
+      def setup_option(new_option)
+        instance_variable_set(:"@#{new_option}", nil)
         accepted_options << new_option
         descendants.each do |descendant|
           descendant.send(__method__, new_option)
@@ -46,18 +47,6 @@ module Axiom
         self
       end
 
-      # Set the option if it is not already set
-      #
-      # @param [Symbol] option
-      # @param [Object] value
-      #
-      # @return [self]
-      #
-      # @api private
-      def set_option(option, value)
-        public_send(option, value) unless public_send(option)
-      end
-
     private
 
       # Adds descendant to descendants array and inherits default options
@@ -70,7 +59,7 @@ module Axiom
       def inherited(descendant)
         super
         options.each do |option, value|
-          descendant.add_accepted_option(option).set_option(option, value)
+          descendant.setup_option(option).public_send(option, value)
         end
       end
 
@@ -116,8 +105,10 @@ module Axiom
       # @api private
       def assert_method_available(name)
         return unless respond_to?(name)
-        raise ReservedMethodError,
+        raise(
+          ReservedMethodError,
           "method named `#{name.inspect}` is already defined"
+        )
       end
 
       # Adds a reader/writer method for the give option name
@@ -128,7 +119,7 @@ module Axiom
       #
       # @api private
       def define_option_method(name)
-        ivar = "@#{name}"
+        ivar = :"@#{name}"
         define_singleton_method(name) do |*args|
           return instance_variable_get(ivar) if args.empty?
           instance_variable_set(ivar, *args)

data/lib/axiom/types/time.rb

@@ -8,8 +8,8 @@ module Axiom
       extend ValueComparable
 
       # The minimum and maximum seconds for Time on 32-bit systems
-      MINIMUM_SECONDS = -0x7FFFFFFF
-      MAXIMUM_SECONDS = 0x7FFFFFFF
+      MINIMUM_SECONDS = -2**31
+      MAXIMUM_SECONDS =  2**31 - 1
 
       primitive       ::Time
       coercion_method :to_time

data/lib/axiom/types/type.rb

@@ -30,7 +30,7 @@ module Axiom
       # @example
       #   type = Axiom::Types::Type.new  # => Axiom::Types::Type
       #
-      # @param [#call] constraint
+      # @param [Array(#call)] args
       #   optional constraint for the new type
       #
       # @yield [object]
@@ -44,9 +44,9 @@ module Axiom
       # @return [Class<Axiom::Types::Type>]
       #
       # @api public
-      def self.new(constraint = Undefined, &block)
+      def self.new(*args, &block)
         type = ::Class.new(self, &block)
-        type.constraint(constraint)
+        type.constraint(*args)
         type.finalize
       end
 
@@ -82,6 +82,9 @@ module Axiom
         constraint.call(object)
       end
 
+      # Silence warnings when redeclaring constraint
+      singleton_class.class_eval { undef_method :constraint }
+
       # Add a constraint to the type
       #
       # @example with an argument
@@ -136,12 +139,13 @@ module Axiom
       #
       # @api private
       def self.add_constraint(constraint)
-        current     = self.constraint
-        @constraint = if current
-          lambda { |object| constraint.call(object) && current.call(object) }
-        else
-          constraint
-        end
+        current = self.constraint
+        @constraint =
+          if current
+            ->(object) { constraint.call(object) && current.call(object) }
+          else
+            constraint
+          end
       end
 
       private_class_method :add_constraint

data/lib/axiom/types/value_comparable.rb

@@ -17,7 +17,9 @@ module Axiom
       # @api private
       def self.extended(descendant)
         super
-        descendant.accept_options :minimum, :maximum
+        descendant.class_eval do
+          accept_options :minimum, :maximum
+        end
       end
 
       # Finalize by setting up a value range constraint
@@ -41,7 +43,8 @@ module Axiom
       #
       # @api private
       def has_value_within_range
-        constraint { |object| object.between?(minimum, maximum) }
+        range = minimum..maximum
+        constraint(range.method(:cover?))
       end
 
     end # module ValueComparable

data/lib/axiom/types/version.rb

@@ -4,7 +4,7 @@ module Axiom
   module Types
 
     # Gem version
-    VERSION = '0.0.2'.freeze
+    VERSION = '0.0.3'.freeze
 
   end # module Types
 end # module Axiom

data/spec/unit/axiom/types/boolean/class_methods/infer_spec.rb

@@ -30,4 +30,10 @@ describe Axiom::Types::Boolean, '.infer' do
 
     it { should be_nil }
   end
+
+  context 'when the argument is not nil' do
+    let(:arg) { 1 }
+
+    it { should be_nil }
+  end
 end

data/spec/unit/axiom/types/collection/class_methods/finalize_spec.rb

@@ -16,7 +16,7 @@ describe Axiom::Types::Collection, '.finalize' do
     its(:constraint) { should be_frozen }
 
     it 'adds a constraint that returns true for a collection' do
-      should include([ Object.new ])
+      should include([Object.new])
     end
 
     it 'adds a constraint that returns false for a non-collection' do
@@ -39,11 +39,11 @@ describe Axiom::Types::Collection, '.finalize' do
     its(:constraint) { should be_frozen }
 
     it 'adds a constraint that returns true for a valid member' do
-      should include([ member ])
+      should include([member])
     end
 
     it 'adds a constraint that returns false for an invalid member' do
-      should_not include([ member.to_s ])
+      should_not include([member.to_s])
     end
   end
 end