finitio 0.7.0.pre.rc4 → 0.10.0

data/lib/finitio/json_schema/alias_type.rb

@@ -0,0 +1,9 @@
+module Finitio
+  class AliasType
+
+    def to_json_schema(*args, &bl)
+      target.to_json_schema(*args, &bl)
+    end
+
+  end # class AliasType
+end # module Finitio

data/lib/finitio/json_schema/any_type.rb

@@ -0,0 +1,9 @@
+module Finitio
+  class AnyType
+
+    def to_json_schema(*args, &bl)
+      {}
+    end
+
+  end # class AnyType
+end # module Finitio

data/lib/finitio/json_schema/builtin_type.rb

@@ -0,0 +1,27 @@
+module Finitio
+  module JsonSchema
+
+    BUILTIN_MAPPING = {
+      NilClass => "null",
+      String => "string",
+      Integer => "integer",
+      Fixnum => "integer",
+      Bignum => "integer",
+      Float => "number",
+      Numeric => "number"
+    }
+
+  end
+  class BuiltinType
+
+    def to_json_schema(*args, &bl)
+      mapped = JsonSchema::BUILTIN_MAPPING[ruby_type]
+      if mapped
+        { type: mapped }
+      else
+        raise JsonSchema::Error, "Unable to map #{ruby_type} to json-schema"
+      end
+    end
+
+  end # class BuiltinType
+end # module Finitio

data/lib/finitio/json_schema/hash_based_type.rb

@@ -0,0 +1,25 @@
+module Finitio
+  module HashBasedType
+
+    def to_json_schema(*args, &bl)
+      base = {
+        type: "object"
+      }
+      unless heading.empty?
+        base[:properties] = heading.inject({}){|ps,a|
+            ps.merge(a.name => a.type.to_json_schema(*args, &bl))
+        }
+      end
+      unless (reqs = heading.select{|a| a.required? }).empty?
+        base[:required] = reqs.map{|a| a.name }
+      end
+      base[:additionalProperties] = if heading.allow_extra?
+        heading.allow_extra.to_json_schema(*args, &bl)
+      else
+        false
+      end
+      base
+    end
+
+  end # module HashBasedType
+end # module UnionType

data/lib/finitio/json_schema/rel_based_type.rb

@@ -0,0 +1,13 @@
+module Finitio
+  module RelBasedType
+
+    def to_json_schema(*args, &bl)
+      {
+        type: "array",
+        items: tuple_type.to_json_schema(*args, &bl),
+        uniqueItems: true
+      }
+    end
+
+  end # module RelBasedType
+end # module Finitio

data/lib/finitio/json_schema/seq_type.rb

@@ -0,0 +1,12 @@
+module Finitio
+  class SeqType
+
+    def to_json_schema(*args, &bl)
+      {
+        type: "array",
+        items: elm_type.to_json_schema(*args, &bl)
+      }
+    end
+
+  end # class SeqType
+end # module Finitio

data/lib/finitio/json_schema/set_type.rb

@@ -0,0 +1,13 @@
+module Finitio
+  class SetType
+
+    def to_json_schema(*args, &bl)
+      {
+        type: "array",
+        items: elm_type.to_json_schema(*args, &bl),
+        uniqueItems: true
+      }
+    end
+
+  end # class SetType
+end # module Finitio

data/lib/finitio/json_schema/struct_type.rb

@@ -0,0 +1,12 @@
+module Finitio
+  class StructType
+
+    def to_json_schema(*args, &bl)
+      {
+        type: "array",
+        items: component_types.map{|c| c.to_json_schema(*args, &bl) }
+      }
+    end
+
+  end # class StructType
+end # module Finitio

data/lib/finitio/json_schema/sub_type.rb

@@ -0,0 +1,10 @@
+module Finitio
+  class SubType
+
+    def to_json_schema(*args, &bl)
+      # TODO: add support for constraints here...
+      super_type.to_json_schema(*args, &bl)
+    end
+
+  end # class SubType
+end # module Finitio

data/lib/finitio/json_schema/union_type.rb

@@ -0,0 +1,11 @@
+module Finitio
+  class UnionType
+
+    def to_json_schema(*args, &bl)
+      {
+        anyOf: candidates.map{|c| c.to_json_schema(*args, &bl) }
+      }
+    end
+
+  end # class UnionType
+end # module Finitio

data/lib/finitio/support.rb

@@ -1,3 +1,20 @@
+module Finitio
+  module Support
+
+    def compare_attrs(h1, h2, &bl)
+      mine, yours = if bl
+        [h1.map(&bl), h2.map(&bl)]
+      elsif h1.is_a?(Hash)
+        [h1.keys, h2.keys]
+      else
+        [h1, h2]
+      end
+      [ mine & yours, mine - yours, yours - mine ]
+    end
+    module_function :compare_attrs
+
+  end # module Support
+end # module Finitio
 require_relative 'support/proc_with_code'
 require_relative 'support/metadata'
 require_relative 'support/attribute'
@@ -6,4 +23,5 @@ require_relative 'support/contract'
 require_relative 'support/heading'
 require_relative 'support/dress_helper'
 require_relative 'support/type_factory'
+require_relative 'support/fetch_scope'
 require_relative 'support/compilation'

data/lib/finitio/support/attribute.rb

@@ -55,5 +55,13 @@ module Finitio
       name.hash ^ type.hash ^ required.hash
     end
 
+    def resolve_proxies(system)
+      Attribute.new(name, type.resolve_proxies(system), required, metadata)
+    end
+
+    def unconstrained
+      Attribute.new(name, type.unconstrained, required, metadata)
+    end
+
   end # class Attribute
 end # module Finitio

data/lib/finitio/support/compilation.rb

@@ -1,19 +1,19 @@
 module Finitio
   class Compilation
 
-    def initialize(system = System.new, factory = TypeFactory.new, source = nil)
+    def initialize(system = System.new, factory = TypeFactory.new, scope = nil, source = nil)
       @system  = system
       @factory = factory
-      @proxies = []
+      @scope = scope || FetchScope.new(system, {})
       @source = source
     end
-    attr_reader :system, :factory, :proxies, :source
+    attr_reader :system, :factory, :scope, :source
 
     def self.coerce(arg, source = nil)
       case arg
-      when NilClass    then new(System.new, TypeFactory.new, source)
-      when System      then new(arg, arg.factory, source)
-      when TypeFactory then new(System.new, arg, source)
+      when NilClass    then new(System.new, TypeFactory.new, nil, source)
+      when System      then new(arg, arg.factory, nil, source)
+      when TypeFactory then new(System.new, arg, nil, source)
       else
         raise ArgumentError, "Unable to coerce `#{arg}`"
       end
@@ -48,11 +48,8 @@ module Finitio
       Pathname.new(file)
     end
 
-    def resolve_proxies!
-      proxies.each do |p|
-        p.resolve(system)
-      end
-      self
+    def resolve_proxies
+      system.resolve_proxies
     end
 
     # Delegation to Factory
@@ -63,17 +60,10 @@ module Finitio
       }
     end
 
-    def proxy(*args, &bl)
-      proxy = factory.proxy(*args, &bl)
-      proxies << proxy
-      proxy
-    end
-
     # Delegation to System
 
     [
       :add_type,
-      :fetch,
       :main,
     ].each do |meth|
       define_method(meth) do |*args, &bl|
@@ -81,5 +71,15 @@ module Finitio
       end
     end
 
+    # Delegation to FetchScope
+
+    def fetch(type_name, &bl)
+      scope.fetch(type_name, &bl)
+    end
+
+    def with_scope(overrides)
+      Compilation.new(system, factory, scope.with(overrides), source)
+    end
+
   end # class Compilation
 end # module Finitio

data/lib/finitio/support/contract.rb

@@ -30,7 +30,7 @@ module Finitio
     end
 
     def hash
-      [infotype, dresser, undresser].hash
+      infotype.hash ^ dresser.hash ^ undresser.hash
     end
 
     def ==(other)
@@ -38,11 +38,19 @@ module Finitio
         other.is_a?(Contract) &&
         name == other.name &&
         infotype == other.infotype &&
-        dresser == other.dresser && 
+        dresser == other.dresser &&
         undresser == other.undresser
       )
     end
     alias :eql? :==
 
+    def resolve_proxies(system)
+      Contract.new(infotype.resolve_proxies(system), dresser, undresser, name, metadata)
+    end
+
+    def unconstrained
+      Contract.new(infotype.unconstrained, dresser, undresser, name, metadata)
+    end
+
   end # class Contract
 end # module Finitio

data/lib/finitio/support/fetch_scope.rb

@@ -0,0 +1,19 @@
+module Finitio
+  class FetchScope
+
+    def initialize(parent, overrides)
+      @parent, @overrides = parent, overrides
+    end
+
+    def fetch(name, &bl)
+      @overrides.fetch(name) do
+        @parent.fetch(name, &bl)
+      end
+    end
+
+    def with(overrides)
+      FetchScope.new(self, overrides)
+    end
+
+  end # class FetchScope
+end # module Finitio

data/lib/finitio/support/heading.rb

@@ -61,6 +61,32 @@ module Finitio
       name
     end
 
+    def looks_similar?(other)
+      return self if other == self
+      shared, mine, yours = Support.compare_attrs(attributes, other.attributes)
+      shared.length >= mine.length && shared.length >= yours.length
+    end
+
+    def suppremum(other)
+      raise ArgumentError unless other.is_a?(Heading)
+      return self if other == self
+      options = { allow_extra: allow_extra? || other.allow_extra? }
+      shared, mine, yours = Support.compare_attrs(attributes, other.attributes)
+      attributes = shared.map{|attr|
+        a1, o1 = self[attr], other[attr]
+        Attribute.new(attr, a1.type.suppremum(o1.type), a1.required && o1.required)
+      }
+      attributes += mine.map{|attrname|
+        attr = self[attrname]
+        Attribute.new(attr.name, attr.type, false)
+      }
+      attributes += yours.map{|attrname|
+        attr = other[attrname]
+        Attribute.new(attr.name, attr.type, false)
+      }
+      Heading.new(attributes, options)
+    end
+
     def ==(other)
       return nil unless other.is_a?(Heading)
       attributes == other.attributes && options == other.options
@@ -73,6 +99,21 @@ module Finitio
     attr_reader :attributes, :options
     protected   :attributes, :options
 
+    def resolve_proxies(system)
+      as = attributes.map{|k,a|
+        a.resolve_proxies(system)
+      }
+      opts = options.dup
+      if options[:allow_extra] && options[:allow_extra].is_a?(Type)
+        opts[:allow_extra] = opts[:allow_extra].resolve_proxies(system)
+      end
+      Heading.new(as, opts)
+    end
+
+    def unconstrained
+      Heading.new(attributes.values.map{|a| a.unconstrained }, options)
+    end
+
   private
 
     def normalize_attributes(attrs)
@@ -83,7 +124,7 @@ module Finitio
       attributes = {}
       attrs.each do |attr|
         unless attr.is_a?(Attribute)
-          raise ArgumentError, "Enumerable[Attribute] expected"
+          raise ArgumentError, "Enumerable[Attribute] expected, got a `#{attr.inspect}`"
         end
         if attributes[attr.name]
           raise ArgumentError, "Attribute names must be unique"

data/lib/finitio/syntax.rb

@@ -27,7 +27,7 @@ module Finitio
     def self.compile(source, cpl = nil)
       cpl = Compilation.coerce(cpl, source)
       parse(source, root: "system").compile(cpl)
-      cpl.resolve_proxies!.system
+      cpl.resolve_proxies
     end
 
     def self.compile_type(source, cpl = nil)

data/lib/finitio/syntax/lexer.citrus

@@ -25,7 +25,7 @@ grammar Finitio::Syntax::Lexer
   end
 
   rule type_name
-    /[A-Z][a-zA-Z]+(\.[A-Z][a-zA-Z]+)*/
+    /[A-Z][a-zA-Z]*(\.[A-Z][a-zA-Z]+)*/
   end
 
   rule builtin_type_name

data/lib/finitio/syntax/type.rb

@@ -19,9 +19,11 @@ require_relative 'type/relation_type'
 require_relative 'type/union_type'
 require_relative 'type/type_ref'
 require_relative 'type/ad_type'
+require_relative 'type/high_order_type_instantiation'
 require_relative 'type/contract'
 require_relative 'type/inline_pair'
 require_relative 'type/external_pair'
 require_relative 'type/lambda_expr'
 require_relative 'type/metadata'
 require_relative 'type/metadata_attr'
+require_relative 'type/high_order_vars'

data/lib/finitio/syntax/type/high_order_type_instantiation.rb

@@ -0,0 +1,29 @@
+module Finitio
+  module Syntax
+    module HighOrderTypeInstantiation
+      include Node
+
+      capture :high
+      capture :vars
+
+      def compile(system)
+        target = system.fetch(high.to_s){
+          raise Error, "No such type `#{high.to_s}`"
+        }
+        raise "#{high} is not a high order type" unless target.is_a?(HighOrderType)
+
+        subs = vars.compile(system).map{|low|
+          system.fetch(low.to_s) {
+            raise Error, "No such type `#{low.to_s}`"
+          }
+        }
+        target.instantiate(system, subs)
+      end
+
+      def to_ast
+        [:high_order_type_instantiation, high.to_s, lows.to_s]
+      end
+
+    end # module HighOrderTypeInstantiation
+  end # module Syntax
+end # module Finitio