finitio 0.4.1 → 0.5.0

data/lib/finitio/syntax/node.rb

@@ -0,0 +1,53 @@
+module Finitio
+  module Syntax
+    module Node
+
+      def resolve_ruby_const(name)
+        name.split('::').inject(::Kernel){|mod,const|
+          mod.const_get(const)
+        }
+      end
+
+      def metadata
+        m = captures[:metadata].first
+        m && m.value
+      end
+
+      def unique_names!(cs, kind = "constraint")
+        names = {}
+        cs.map(&:name).compact.each do |n|
+          names.merge!(n => true) do |k,_,_|
+            raise Error, "Duplicate #{kind} name `#{k}`"
+          end
+        end
+        cs
+      end
+
+      def self.included(by)
+        by.extend(ClassHelpers)
+      end
+
+      module ClassHelpers
+
+        def capture(*names)
+          names.each do |name|
+            define_method(name) do
+              captures[name].first
+            end
+          end
+        end
+
+        def capture_str(*names)
+          names.each do |name|
+            define_method(name) do
+              x = captures[name].first
+              x && x.to_s
+            end
+          end
+        end
+
+      end # module ClassHelpers
+
+    end # module Node
+  end # module Syntax
+end # module AstNode

data/lib/finitio/syntax/type.rb

@@ -0,0 +1,28 @@
+require_relative 'type/system'
+require_relative 'type/definitions'
+require_relative 'type/type_def'
+require_relative 'type/main_type'
+require_relative 'type/expression'
+require_relative 'type/attribute'
+require_relative 'type/heading'
+require_relative 'type/any_type'
+require_relative 'type/builtin_type'
+require_relative 'type/sub_type'
+require_relative 'type/constraint_def'
+require_relative 'type/constraints'
+require_relative 'type/named_constraint'
+require_relative 'type/unnamed_constraint'
+require_relative 'type/seq_type'
+require_relative 'type/set_type'
+require_relative 'type/struct_type'
+require_relative 'type/tuple_type'
+require_relative 'type/relation_type'
+require_relative 'type/union_type'
+require_relative 'type/type_ref'
+require_relative 'type/ad_type'
+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'

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

@@ -0,0 +1,29 @@
+module Finitio
+  module Syntax
+    module AdType
+      include Node
+
+      capture :builtin_type_name
+
+      def compile(factory)
+        name      = builtin_type_name
+        clazz     = name ? resolve_ruby_const(name.to_s) : nil
+        contracts = compile_contracts(factory, clazz)
+        contracts = unique_names!(contracts, "contract")
+        factory.adt(clazz, contracts)
+      end
+
+      def compile_contracts(factory, clazz)
+        captures[:contract].map{|c| c.compile(factory, clazz) }
+      end
+
+      def to_ast
+        [ 
+          :ad_type,
+          builtin_type_name ? builtin_type_name.to_s : nil
+        ] + captures[:contract].map(&:to_ast)
+      end
+
+    end # module AdType
+  end # module Syntax
+end # module Finitio

data/lib/finitio/syntax/{any_type.rb → type/any_type.rb}

@@ -1,7 +1,7 @@
 module Finitio
   module Syntax
     module AnyType
-      include Support
+      include Node
 
       def compile(factory)
         factory.any

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

@@ -0,0 +1,33 @@
+module Finitio
+  module Syntax
+    module Attribute
+      include Node
+
+      capture :type, :multiplicity
+      capture_str :attribute_name
+
+      def optional?
+        multiplicity == ':?'
+      end
+
+      def required?
+        multiplicity == ':'
+      end
+
+      def compile(factory)
+        n = attribute_name.to_sym
+        t = type.compile(factory)
+        r = required?
+        m = metadata
+        factory.attribute(n, t, r, m)
+      end
+
+      def to_ast
+        ast = [:attribute, attribute_name, type.to_ast]
+        ast << false unless required?
+        ast
+      end
+
+    end # module BuiltinType
+  end # module Syntax
+end # module Finitio

data/lib/finitio/syntax/{builtin_type.rb → type/builtin_type.rb}

@@ -1,7 +1,9 @@
 module Finitio
   module Syntax
     module BuiltinType
-      include Support
+      include Node
+
+      capture :builtin_type_name
 
       def compile(factory)
         clazz = resolve_ruby_const(builtin_type_name.to_s)

data/lib/finitio/syntax/{constraint_def.rb → type/constraint_def.rb}

@@ -1,15 +1,16 @@
 module Finitio
   module Syntax
     module ConstraintDef
+      include Node
+
+      capture :var_name, :constraints
 
       def compile(factory)
         constraints.compile(var_name.to_s)
       end
 
       def to_ast
-        ast = constraints.to_ast(var_name.to_s)
-        ast = [ast] if ast.first.is_a?(Symbol)
-        ast
+        constraints.to_ast(var_name.to_s)
       end
 
     end # module ConstraintDef

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

@@ -0,0 +1,17 @@
+module Finitio
+  module Syntax
+    module Constraints
+      include Node
+
+      def compile(var_name)
+        cs = captures[:constraint].map{|c| c.compile(var_name) }
+        unique_names!(cs, 'constraint')
+      end
+
+      def to_ast(var_name)
+        captures[:constraint].map{|c| c.to_ast(var_name) }
+      end
+
+    end # module Constraints
+  end # module Syntax
+end # module Finitio

data/lib/finitio/syntax/{contract.rb → type/contract.rb}

@@ -1,10 +1,16 @@
 module Finitio
   module Syntax
     module Contract
+      include Node
+
+      capture :type, :pair
+      capture_str :contract_name
 
       def compile(factory, clazz)
-        contract = [ type.compile(factory) ] + compile_pair(factory, clazz)
-        { contract_name.to_sym => contract }
+        name = contract_name.to_sym
+        infotype = type.compile(factory)
+        dresser, undresser  = compile_pair(factory, clazz)
+        factory.contract(infotype, dresser, undresser, name, metadata)
       end
 
       def compile_pair(factory, clazz)
@@ -25,7 +31,7 @@ module Finitio
       def to_ast
         ast = [
           :contract,
-          contract_name.to_s,
+          contract_name,
           (type && type.to_ast) 
         ]
         ast << pair.to_ast if pair

data/lib/finitio/syntax/{definitions.rb → type/definitions.rb}

@@ -1,6 +1,7 @@
 module Finitio
   module Syntax
     module Definitions
+      include Node
 
       def compile(system)
         captures[:type_def].each do |node|

data/lib/finitio/syntax/{expression.rb → type/expression.rb}

@@ -1,9 +1,10 @@
 module Finitio
   module Syntax
     module Expression
+      include Node
 
       def compile(var_name)
-        expr = "->(#{var_name}){ #{self} }"
+        expr = "->(#{var_name}){ #{to_str} }"
         ::Kernel.eval(expr)
       end
 

data/lib/finitio/syntax/{external_pair.rb → type/external_pair.rb}

@@ -1,7 +1,9 @@
 module Finitio
   module Syntax
     module ExternalPair
-      include Support
+      include Node
+
+      capture :builtin_type_name
 
       def compile(factory)
         clazz = resolve_ruby_const(builtin_type_name.to_s)

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

@@ -0,0 +1,30 @@
+module Finitio
+  module Syntax
+    module Heading
+      include Node
+
+      capture :allow_extra
+
+      def allow_extra?
+        !allow_extra.nil?
+      end
+
+      def multi?
+        captures[:attribute].any?{|a| a.optional? } or allow_extra?
+      end
+
+      def attributes(factory)
+        captures[:attribute].map{|a| a.compile(factory) }
+      end
+
+      def compile(factory)
+        Finitio::Heading.new(attributes(factory), allow_extra: allow_extra?)
+      end
+
+      def to_ast
+        captures[:attribute].map(&:to_ast).unshift(:heading)
+      end
+
+    end # module Heading
+  end # module Syntax
+end # module Finitio

data/lib/finitio/syntax/{inline_pair.rb → type/inline_pair.rb}

@@ -1,7 +1,9 @@
 module Finitio
   module Syntax
     module InlinePair
-      include Support
+      include Node
+
+      capture :dress, :undress
 
       def compile(factory)
         [ dress.compile(factory), undress.compile(factory) ]

data/lib/finitio/syntax/{lambda_expr.rb → type/lambda_expr.rb}

@@ -1,6 +1,9 @@
 module Finitio
   module Syntax
     module LambdaExpr
+      include Node
+
+      capture :var_name, :expression
 
       def compile(factory)
         expression.compile(var_name)

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

@@ -0,0 +1,18 @@
+module Finitio
+  module Syntax
+    module MainType
+      include Node
+
+      capture :type
+
+      def compile(system)
+        system.add_type(type.compile(system), 'Main', metadata)
+      end
+
+      def to_ast
+        type.to_ast
+      end
+
+    end # module MainType
+  end # module Syntax
+end # module Finitio

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

@@ -0,0 +1,18 @@
+module Finitio
+  module Syntax
+    module Metadata
+      include Node
+
+      capture :description
+
+      def value
+        if description
+          { description: description.to_str.strip }
+        else
+          Hash[captures[:metadata_attr].map(&:value)]
+        end
+      end
+
+    end # module Metadata
+  end # module Syntax
+end # module Metadata

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

@@ -0,0 +1,15 @@
+module Finitio
+  module Syntax
+    module MetadataAttr
+      include Node
+
+      capture_str :attribute_name
+      capture :literal
+
+      def value
+        [ attribute_name.to_sym, literal.value ]
+      end
+
+    end # module MetadataAttr
+  end # module Syntax
+end # module Metadata

data/lib/finitio/syntax/{named_constraint.rb → type/named_constraint.rb}

@@ -1,15 +1,22 @@
 module Finitio
   module Syntax
     module NamedConstraint
+      include Node
+
+      capture :expression
+      capture_str :constraint_name
 
       def compile(var_name)
-        { constraint_name.to_sym => expression.compile(var_name) }
+        p = expression.compile(var_name)
+        n = constraint_name.to_sym
+        m = metadata
+        Constraint.new(p, n, metadata)
       end
 
       def to_ast(var_name)
         [ :constraint,
-          constraint_name.to_s,
-          [:fn, [:parameters, var_name], [:source, expression.to_s.strip]] ]
+          constraint_name,
+          [:fn, [:parameters, var_name], [:source, expression.to_str.strip]] ]
       end
 
     end # module NamedConstraint

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

@@ -0,0 +1,24 @@
+module Finitio
+  module Syntax
+    module RelationType
+      include Node
+
+      capture :heading
+
+      def compile(factory)
+        factory.send(kind, heading.compile(factory))
+      end
+
+      def to_ast
+        [ :"#{kind}_type", heading.to_ast ]
+      end
+
+    private
+
+      def kind
+        heading.multi? ? :multi_relation : :relation
+      end
+
+    end # module RelationType
+  end # module Syntax
+end # module Finitio

data/lib/finitio/syntax/{seq_type.rb → type/seq_type.rb}

@@ -1,6 +1,9 @@
 module Finitio
   module Syntax
     module SeqType
+      include Node
+
+      capture :type
 
       def compile(factory)
         elm_type = type.compile(factory)

data/lib/finitio/syntax/{set_type.rb → type/set_type.rb}

@@ -1,6 +1,9 @@
 module Finitio
   module Syntax
     module SetType
+      include Node
+
+      capture :type
 
       def compile(factory)
         elm_type = type.compile(factory)