finitio 0.4.1 → 0.5.0

data/lib/finitio/support/contract.rb

@@ -0,0 +1,33 @@
+module Finitio
+  class Contract
+    include Metadata
+
+    def initialize(infotype, dresser, undresser, name = nil, metadata = nil)
+      unless infotype.is_a?(Type)
+        raise ArgumentError, "Type expected, got `#{infotype}`"
+      end
+      unless dresser.respond_to?(:call)
+        raise ArgumentError, "r(:call) expected, got `#{dresser}`"
+      end
+      unless undresser.respond_to?(:call)
+        raise ArgumentError, "r(:call) expected, got `#{undresser}`"
+      end
+      unless name.nil? or name.is_a?(Symbol)
+        raise ArgumentError, "Symbol expected, got `#{name}`"
+      end
+
+      @name      = name
+      @infotype  = infotype
+      @dresser   = dresser
+      @undresser = undresser
+      @metadata  = metadata
+    end
+    attr_reader :name, :infotype, :dresser, :undresser
+
+    def bind_ruby_type(clazz)
+      @dresser   = clazz.method(name.to_sym)
+      @undresser = clazz.instance_method(:"to_#{name}")
+    end
+
+  end # class Contract
+end # module Finitio

data/lib/finitio/support/dress_helper.rb

@@ -24,7 +24,8 @@ module Finitio
     def just_try(rescue_on = TypeError)
       [ true, yield ]
     rescue rescue_on => cause
-      [ false, nil ]
+      #STDERR.puts cause.inspect
+      [ false, cause ]
     end
 
     def try(type, value)
@@ -44,7 +45,7 @@ module Finitio
 
     def default_error_message(type, value)
       value_s, type_s = value_to_s(value), type_to_s(type)
-      "Invalid value `#{value_s}` for #{type_s}"
+      "Invalid #{type_s} `#{value_s}`"
     end
 
     def location

data/lib/finitio/support/heading.rb

@@ -8,20 +8,21 @@ module Finitio
   class Heading
     include Enumerable
 
-    def initialize(attributes)
-      unless attributes.is_a?(Enumerable) and \
-             attributes.all?{|a| a.is_a?(Attribute) }
-        raise ArgumentError, "Enumerable[Attribute] expected"
-      end
+    DEFAULT_OPTIONS = { allow_extra: false }.freeze
 
-      @attributes = {}
-      attributes.each do |attr|
-        if @attributes[attr.name]
-          raise ArgumentError, "Attribute names must be unique"
-        end
-        @attributes[attr.name] = attr
+    def initialize(attributes, options = nil)
+      @attributes = normalize_attributes(attributes)
+      @options    = normalize_options(options)
+    end
+
+    def [](attrname)
+      @attributes[attrname]
+    end
+
+    def fetch(attrname)
+      @attributes.fetch(attrname) do
+        raise Error, "No such attribute `#{attrname}`"
       end
-      @attributes.freeze
     end
 
     def size
@@ -32,26 +33,65 @@ module Finitio
       size == 0
     end
 
+    def multi?
+      allow_extra? || any?{|attr| not(attr.required?) }
+    end
+
+    def allow_extra?
+      options[:allow_extra]
+    end
+
     def each(&bl)
       return to_enum unless bl
       @attributes.values.each(&bl)
     end
 
     def to_name
-      map(&:to_name).join(', ')
+      name = map(&:to_name).join(', ')
+      if allow_extra?
+        name << ", " unless empty?
+        name << "..."
+      end
+      name
     end
 
     def ==(other)
       return nil unless other.is_a?(Heading)
-      attributes == other.attributes
+      attributes == other.attributes && options == other.options
     end
 
     def hash
-      self.class.hash ^ attributes.hash
+      self.class.hash ^ attributes.hash ^ options.hash
     end
 
-    attr_reader :attributes
-    protected   :attributes
+    attr_reader :attributes, :options
+    protected   :attributes, :options
+
+  private
+
+    def normalize_attributes(attrs)
+      unless attrs.respond_to?(:each)
+        raise ArgumentError, "Enumerable[Attribute] expected"
+      end
+
+      attributes = {}
+      attrs.each do |attr|
+        unless attr.is_a?(Attribute)
+          raise ArgumentError, "Enumerable[Attribute] expected"
+        end
+        if attributes[attr.name]
+          raise ArgumentError, "Attribute names must be unique"
+        end
+        attributes[attr.name] = attr
+      end
+      attributes.freeze
+    end
+
+    def normalize_options(opts)
+      options = DEFAULT_OPTIONS
+      options = options.merge(opts).freeze if opts
+      options
+    end
 
   end # class Heading
 end # class Finitio

data/lib/finitio/support/metadata.rb

@@ -0,0 +1,20 @@
+module Finitio
+  module Metadata
+
+    EMPTY_METADATA = {}.freeze
+
+    def metadata
+      @metadata || EMPTY_METADATA
+    end
+
+    def metadata?
+      !@metadata.nil?
+    end
+
+    def metadata=(hash)
+      raise "Metadata already set to #{@metadata.inspect}" unless @metadata.nil?
+      @metadata = hash
+    end
+
+  end # module Metadata
+end # module Finitio

data/lib/finitio/support/type_factory.rb

@@ -1,30 +1,63 @@
 module Finitio
   class TypeFactory
 
+    DSL_METHODS = [
+      :attribute,
+      :heading,
+      :constraint,
+      :constraints,
+      :contract,
+      :contracts,
+      :any,
+      :builtin,
+      :adt,
+      :subtype,
+      :union,
+      :seq,
+      :set,
+      :struct,
+      :tuple,
+      :multi_tuple,
+      :relation,
+      :multi_relation,
+      :type,
+      :proxy
+    ]
+
     ################################################################## Factory
 
-    def type(type, name = nil, &bl)
-      return subtype(type(type, name), bl) if bl
+    def type(type, name = nil, metadata = nil, &bl)
+      return subtype(type(type, name, metadata), bl) if bl
       case type
       when Type
-        type
+        alias_type(type, name, metadata)
       when Module
-        BuiltinType.new(type, name || type.name.to_s)
+        BuiltinType.new(type, name || type.name.to_s, metadata)
       when Hash
-        tuple(type, name)
+        tuple(type, name, metadata)
       when Array
-        fail!("Array of arity 1 expected, got `#{type}`") unless type.size==1
-        seq(type.first, name)
+        case type.size
+        when 0
+          fail!("Array of arity > 0 expected, got `#{type}`")
+        when 1
+          seq(type.first, name, metadata)
+        else
+          struct(type, name, metadata)
+        end
       when Set
         fail!("Set of arity 1 expected, got `#{type}`") unless type.size==1
         sub = type(type.first)
-        sub.is_a?(TupleType) ? relation(sub.heading, name) : set(sub, name)
+        if sub.is_a?(TupleType)
+          relation(sub.heading, name, metadata)
+        else
+          set(sub, name, metadata)
+        end
       when Range
         clazz = [type.begin, type.end].map(&:class).uniq
         fail!("Unsupported range `#{type}`") unless clazz.size==1
-        subtype(clazz.first, type)
+        subtype(clazz.first, type, name, metadata)
       when Regexp
-        subtype(String, type)
+        subtype(String, type, name, metadata)
       else
         fail!("Unable to factor a Finitio::Type from `#{type}`")
       end
@@ -48,16 +81,41 @@ module Finitio
       name.nil? ? nil : name.strip
     end
 
+    def metadata(metadata)
+      unless metadata.nil? or metadata.is_a?(Hash)
+        fail!("Wrong metadata `#{metadata}`")
+      end
+
+      metadata
+    end
+
+    def constraint(constraint, name = nil)
+      case constraint
+      when Constraint then constraint
+      else Constraint.new(constraint, name)
+      end
+    end
+
     def constraints(constraints = nil, &bl)
-      constrs = {}
-      constrs[:predicate] = bl if bl
-      constrs[:predicate] = constraints unless constraints.is_a?(Hash)
-      constrs.merge!(constraints)       if constraints.is_a?(Hash)
+      constrs = []
+      constrs << Constraint.new(bl) if bl
+      case constraints
+      when Hash
+        constraints.each_pair do |name, cstr|
+          constrs << constraint(cstr, name)
+        end
+      when Array
+        constraints.each do |c|
+          constrs << constraint(c)
+        end
+      else
+        constrs << Constraint.new(constraints)
+      end
       constrs
     end
 
-    def attribute(name, type)
-      Attribute.new(name, type(type))
+    def attribute(name, type, required = true, metadata = nil)
+      Attribute.new(name, type(type), required, metadata)
     end
 
     def attributes(attributes)
@@ -84,52 +142,64 @@ module Finitio
       end
     end
 
+    def contract(infotype, dresser, undresser, name = nil, metadata = nil)
+      infotype = type(infotype)
+      Contract.new(infotype, dresser, undresser, name, metadata)
+    end
+
     def contracts(contracts)
-      unless contracts.is_a?(Hash)
-        fail!("Hash expected, got `#{contracts}`")
-      end
-      unless (invalid = contracts.keys.reject{|k| k.is_a?(Symbol) }).empty?
-        fail!("Invalid contract names `#{invalid}`")
+      case contracts
+      when Array
+        unless contracts.all?{|c| c.is_a?(Contract) }
+          fail!("[Contract] expected, got `#{contracts}`")
+        end
+        contracts
+      when Hash
+        contracts.map do |k,v|
+          contract(*v.push(k.to_sym))
+        end
       end
-
-      contracts
     end
 
     ########################################################## Type generators
 
-    def any(name = nil)
+    def any(name = nil, metadata = nil)
       name = name(name)
+      meta = metadata(metadata)
 
-      AnyType.new(name)
+      AnyType.new(name, meta)
     end
 
-    def builtin(ruby_type, name = nil)
+    def builtin(ruby_type, name = nil, metadata = nil)
       ruby_type = ruby_type(ruby_type)
       name      = name(name)
+      meta      = metadata(metadata)
 
-      BuiltinType.new(ruby_type, name)
+      BuiltinType.new(ruby_type, name, meta)
     end
 
-    def adt(ruby_type, contracts, name = nil)
+    def adt(ruby_type, contracts, name = nil, metadata = nil)
       ruby_type = ruby_type(ruby_type) if ruby_type
       contracts = contracts(contracts)
       name      = name(name)
+      meta      = metadata(metadata)
 
-      AdType.new(ruby_type, contracts, name)
+      AdType.new(ruby_type, contracts, name, meta)
     end
 
     ### Sub and union
 
-    def subtype(super_type, constraints = nil, name = nil, &bl)
+    def subtype(super_type, constraints = nil, name = nil, metadata = nil, &bl)
       super_type  = type(super_type)
       constraints = constraints(constraints, &bl)
       name        = name(name)
+      meta        = metadata(metadata)
 
-      SubType.new(super_type, constraints, name)
+      SubType.new(super_type, constraints, name, metadata)
     end
 
     def union(*args)
-      candidates, name = [], nil
+      candidates, name, meta = [], nil, nil
       args.each do |arg|
         case arg
         when Array  then candidates = arg.map{|t| type(t) }
@@ -139,43 +209,86 @@ module Finitio
         end
       end
 
-      UnionType.new(candidates, name)
+      UnionType.new(candidates, name, meta)
     end
 
     ### Collections
 
-    def seq(elm_type, name = nil)
+    def seq(elm_type, name = nil, metadata = nil)
       elm_type = type(elm_type)
       name     = name(name)
+      meta     = metadata(metadata)
 
-      SeqType.new(elm_type, name)
+      SeqType.new(elm_type, name, meta)
     end
 
-    def set(elm_type, name = nil)
+    def set(elm_type, name = nil, metadata = nil)
       elm_type = type(elm_type)
       name     = name(name)
+      meta     = metadata(metadata)
+
+      SetType.new(elm_type, name, meta)
+    end
+
+    def struct(component_types, name = nil, metadata = nil)
+      component_types = component_types.map{|t| type(t) }
+      name            = name(name)
+      meta            = metadata(metadata)
 
-      SetType.new(elm_type, name)
+      StructType.new(component_types, name, meta)
     end
 
     ### Tuples and relations
 
-    def tuple(heading, name = nil)
+    def tuple(heading, name = nil, metadata = nil)
       heading = heading(heading)
       name    = name(name)
+      meta    = metadata(metadata)
 
-      TupleType.new(heading, name)
+      TupleType.new(heading, name, meta)
     end
 
-    def relation(heading, name = nil)
+    def multi_tuple(heading, name = nil, metadata = nil)
       heading = heading(heading)
       name    = name(name)
+      meta    = metadata(metadata)
 
-      RelationType.new(heading, name)
+      MultiTupleType.new(heading, name, meta)
+    end
+
+    def relation(heading, name = nil, metadata = nil)
+      heading = heading(heading)
+      name    = name(name)
+      meta    = metadata(metadata)
+
+      RelationType.new(heading, name, meta)
+    end
+
+    def multi_relation(heading, name = nil, metadata = nil)
+      heading = heading(heading)
+      name    = name(name)
+      meta    = metadata(metadata)
+
+      MultiRelationType.new(heading, name, meta)
+    end
+
+    def proxy(target_name)
+      ProxyType.new(target_name)
     end
 
   private
 
+    def alias_type(type, name, metadata)
+      raise "Type expected `#{type}`" unless type.is_a?(Type)
+      if (name && type.named?) or (metadata && type.metadata?)
+        AliasType.new(type, name, metadata)
+      else
+        type.name = name         if name
+        type.metadata = metadata if metadata
+        type
+      end
+    end
+
     def fail!(message)
       raise ArgumentError, message, caller
     end