axiom-types 0.0.1

data/lib/axiom/types/set.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module Axiom
+  module Types
+
+    # Represents a set type
+    class Set < Object
+      primitive       ::Set
+      coercion_method :to_set
+
+    end # class Set
+  end # module Types
+end # module Axiom

data/lib/axiom/types/string.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module Axiom
+  module Types
+
+    # Represents a string type
+    class String < Object
+      extend LengthComparable, Encodable
+
+      primitive       ::String
+      coercion_method :to_string
+
+      minimum_length 0
+      maximum_length 255
+
+    end # class String
+  end # module Types
+end # module Axiom

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

@@ -0,0 +1,129 @@
+# encoding: utf-8
+
+module Axiom
+  module Types
+
+    # A module that adds class and instance level options
+    module Options
+
+      # Raised when the method is already used
+      class ReservedMethodError < ArgumentError; end
+
+      # Defines which options are valid for a given attribute class
+      #
+      # @example
+      #   class MyTypes < Axiom::Types::Object
+      #     accept_options :foo, :bar
+      #   end
+      #
+      # @return [self]
+      #
+      # @api public
+      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)
+        end
+        self
+      end
+
+    protected
+
+      # Adds new option that an attribute class can accept
+      #
+      # @param [Symbol] new_option
+      #   new option to be added
+      #
+      # @return [self]
+      #
+      # @api private
+      def add_accepted_option(new_option)
+        accepted_options << new_option
+        descendants.each do |descendant|
+          descendant.send(__method__, new_option)
+        end
+        self
+      end
+
+    private
+
+      # Adds descendant to descendants array and inherits default options
+      #
+      # @param [Class] descendant
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def inherited(descendant)
+        super
+        options.each do |option, value|
+          descendant.add_accepted_option(option).public_send(option, value)
+        end
+      end
+
+      # Returns default options hash for a given attribute class
+      #
+      # @example
+      #   Axiom::Types::String.options
+      #   # => {:primitive => String}
+      #
+      # @return [Hash]
+      #   a hash of default option values
+      #
+      # @api private
+      def options
+        accepted_options.each_with_object({}) do |name, options|
+          options[name] = public_send(name)
+        end
+      end
+
+      # Returns an array of valid options
+      #
+      # @example
+      #   Axiom::Types::String.accepted_options
+      #   # => [:primitive, :accessor, :reader, :writer]
+      #
+      # @return [Array]
+      #   the array of valid option names
+      #
+      # @api private
+      def accepted_options
+        @accepted_options ||= []
+      end
+
+      # Assert that the option is not already defined
+      #
+      # @param [Symbol] name
+      #
+      # @return [undefined]
+      #
+      # @raise [ReservedMethodError]
+      #   raised when the method is already defined
+      #
+      # @api private
+      def assert_method_available(name)
+        return unless respond_to?(name)
+        raise ReservedMethodError,
+          "method named `#{name.inspect}` is already defined"
+      end
+
+      # Adds a reader/writer method for the give option name
+      #
+      # @param [#to_s] name
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def define_option_method(name)
+        ivar = "@#{name}"
+        define_singleton_method(name) do |*args|
+          return instance_variable_get(ivar) if args.empty?
+          instance_variable_set(ivar, *args)
+          self
+        end
+      end
+
+    end # module Options
+  end # module Types
+end # module Axiom

data/lib/axiom/types/symbol.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module Axiom
+  module Types
+
+    # Represents a symbol type
+    class Symbol < Object
+      extend LengthComparable, Encodable
+
+      primitive       ::Symbol
+      coercion_method :to_symbol
+
+      minimum_length 0
+      maximum_length 255
+
+    end # class Symbol
+  end # module Types
+end # module Axiom

data/lib/axiom/types/time.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Axiom
+  module Types
+
+    # Represents a date time type
+    class Time < Object
+      extend ValueComparable
+
+      # The minimum and maximum seconds for Time on 32-bit systems
+      MINIMUM_SECONDS = -0x7FFFFFFF
+      MAXIMUM_SECONDS = 0x7FFFFFFF
+
+      primitive       ::Time
+      coercion_method :to_time
+
+      minimum primitive.at(MINIMUM_SECONDS).utc
+      maximum primitive.at(MAXIMUM_SECONDS).utc
+
+    end # class Time
+  end # module Types
+end # module Axiom

data/lib/axiom/types/type.rb

@@ -0,0 +1,136 @@
+# encoding: utf-8
+
+module Axiom
+  module Types
+
+    # Abstract base class for every type
+    class Type
+      extend Options, DescendantsTracker
+
+      accept_options :constraint
+      constraint Tautology
+
+      # Instantiate a new Axiom::Types::Type subclass
+      #
+      # @example
+      #   type = Axiom::Types::Type.new  # => Axiom::Types::Type
+      #
+      # @param [#call] constraint
+      #   optional constraint for the new type
+      #
+      # @yield [object]
+      #
+      # @yieldparam object [Object]
+      #   test if the object matches the type constraint
+      #
+      # @yieldreturn [Boolean]
+      #   true if the object matches the type constraint
+      #
+      # @return [Class<Axiom::Types::Type>]
+      #
+      # @api public
+      def self.new(constraint = Undefined, &block)
+        type = ::Class.new(self, &block)
+        type.constraint(constraint)
+        type.finalize
+      end
+
+      # Finalize by deep freezing
+      #
+      # @return [Axiom::Types::Type]
+      #
+      # @api private
+      def self.finalize
+        IceNine.deep_freeze(constraint)
+        freeze
+      end
+
+      # Test if the object matches the type constraint
+      #
+      # @example
+      #   type = Axiom::Types::Integer.new do
+      #     minimum 1
+      #     maximum 100
+      #   end
+      #
+      #   type.include?(1)    # => true
+      #   type.include?(100)  # => true
+      #   type.include?(0)    # => false
+      #   type.include?(101)  # => false
+      #
+      # @param [Object] object
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def self.include?(object)
+        constraint.call(object)
+      end
+
+      # Add a constraint to the type
+      #
+      # @example with an argument
+      #   type.constraint(lambda { |object| object == 42 }
+      #
+      # @example with a block
+      #   type.constraint { |object| object == 42 }
+      #
+      # @example with no arguments
+      #   type.constraint  # => constraint
+      #
+      # @param [#call] constraint
+      #   optional constraint
+      #
+      # @yield [object]
+      #
+      # @yieldparam object [Object]
+      #   test if the object matches the type constraint
+      #
+      # @yieldreturn [Boolean]
+      #   true if the object matches the type constraint
+      #
+      # @return [self]
+      #
+      # @api public
+      def self.constraint(constraint = Undefined, &block)
+        constraint = block if constraint.equal?(Undefined)
+        return @constraint if constraint.nil?
+        add_constraint(constraint)
+        self
+      end
+
+      # Add a constraint that the object must be included in a set
+      #
+      # @param [Array<Object>] members
+      #
+      # @return [undefined]
+      #
+      # @todo move into a module
+      #
+      # @api private
+      def self.includes(*members)
+        set = IceNine.deep_freeze(members.to_set)
+        constraint(&set.method(:include?))
+      end
+
+      # Add new constraint to existing constraint, if any
+      #
+      # @param [#call] constraint
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def self.add_constraint(constraint)
+        current     = self.constraint
+        @constraint = if current
+          lambda { |object| constraint.call(object) && current.call(object) }
+        else
+          constraint
+        end
+      end
+
+      private_class_method :add_constraint
+
+    end # class Type
+  end # module Types
+end # module Axiom

data/lib/axiom/types/value_comparable.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module Axiom
+  module Types
+
+    # Add a minimum and maximum value constraint to a type
+    module ValueComparable
+
+      # Hook called when module is extended
+      #
+      # Add #minimum and #maximum DSL methods to descendant.
+      #
+      # @param [Class<Axiom::Types::Type>] descendant
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def self.extended(descendant)
+        super
+        descendant.accept_options :minimum, :maximum
+      end
+
+      # Finalize by setting up a value range constraint
+      #
+      # @return [Axiom::Types::ValueComparable]
+      #
+      # @api private
+      def finalize
+        return self if frozen?
+        has_value_within_range
+        super
+      end
+
+    private
+
+      # Add a constraint for a value within a range
+      #
+      # @return [undefined]
+      #
+      # @todo freeze the minimum and maximum
+      #
+      # @api private
+      def has_value_within_range
+        constraint { |object| object.between?(minimum, maximum) }
+      end
+
+    end # module ValueComparable
+  end # module Types
+end # module Axiom

data/lib/axiom/types/version.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+module Axiom
+  module Types
+
+    # Gem version
+    VERSION = '0.0.1'.freeze
+
+  end # module Types
+end # module Axiom

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'devtools'
+
+Devtools.init_spec_helper
+
+if ENV['COVERAGE'] == 'true'
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    command_name     'spec:unit'
+    add_filter       'config'
+    add_filter       'spec'
+    minimum_coverage 100
+  end
+end
+
+require 'axiom-types'
+
+include Axiom::Types
+
+# require spec support files and shared behavior
+Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each do |file|
+  require file
+end
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expect_with|
+    expect_with.syntax = :expect
+  end
+end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types, '.finalize' do
+  subject { object.finalize }
+
+  let(:object)      { described_class                   }
+  let(:descendants) { [ descendant ]                    }
+  let(:descendant)  { mock('descendant').as_null_object }
+
+  before do
+    object::Type.should_receive(:descendants).and_return(descendants)
+  end
+
+  it_should_behave_like 'a command method'
+
+  it 'finalizes the descendants' do
+    descendant.should_receive(:finalize)
+    subject
+  end
+end