finitio 0.4.1 → 0.5.0

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

@@ -0,0 +1,17 @@
+module Finitio
+  module Syntax
+    module StructType
+      include Node
+
+      def compile(factory)
+        component_types = captures[:type].map{|x| x.compile(factory) }
+        factory.struct(component_types)
+      end
+
+      def to_ast
+        captures[:type].map(&:to_ast).unshift(:struct_type)
+      end
+
+    end # module StructType
+  end # module Syntax
+end # module Finitio

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

@@ -1,6 +1,9 @@
 module Finitio
   module Syntax
     module SubType
+      include Node
+
+      capture :rel_type, :constraint_def
 
       def compile(factory)
         s = rel_type.compile(factory)

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

@@ -1,18 +1,19 @@
 module Finitio
   module Syntax
     module System
+      include Node
+
+      capture :definitions, :main_type
 
       def compile(system)
         definitions.compile(system)
-        if type
-          system.main = type.compile(system)
-        end
+        main_type.compile(system) if main_type
         system
       end
 
       def to_ast
         ast = [ :system ] + definitions.to_ast
-        ast << type.to_ast if type
+        ast << main_type.to_ast if main_type
         ast
       end
 

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

@@ -0,0 +1,24 @@
+module Finitio
+  module Syntax
+    module TupleType
+      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_tuple : :tuple
+      end
+
+    end # module TupleType
+  end # module Syntax
+end # module Finitio

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

@@ -1,16 +1,21 @@
 module Finitio
   module Syntax
     module TypeDef
+      include Node
+
+      capture :type
+      capture :type_name
 
       def compile(system)
         t = type.compile(system)
-        t.name = type_name.to_s
-        system.add_type(t)
+        n = type_name && type_name.to_str
+        m = metadata
+        system.add_type(t, n, m)
         t
       end
 
       def to_ast
-        [:type_def, type_name.to_s, type.to_ast]
+        [:type_def, type_name, type.to_ast]
       end
 
     end # module TypeDef

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

@@ -1,10 +1,13 @@
 module Finitio
   module Syntax
     module TypeRef
+      include Node
+
+      capture :type_name
 
       def compile(factory)
         factory.fetch(type_name.to_s) do |n|
-          raise Error, "Unknown type `#{n}`"
+          factory.proxy(n)
         end
       end
 

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

@@ -1,6 +1,7 @@
 module Finitio
   module Syntax
     module UnionType
+      include Node
 
       def compile(factory)
         cds = captures[:sub_type].map{|x| x.compile(factory) }

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

@@ -1,9 +1,15 @@
 module Finitio
   module Syntax
     module UnnamedConstraint
+      include Node
+
+      capture :expression
 
       def compile(var_name)
-        { predicate: expression.compile(var_name) }
+        p = expression.compile(var_name)
+        n = nil
+        m = metadata
+        Constraint.new(p, n, m)
       end
 
       def to_ast(var_name)

data/lib/finitio/syntax/types.citrus

@@ -0,0 +1,196 @@
+require 'finitio/syntax/lexer'
+require 'finitio/syntax/literals'
+
+grammar Finitio::Syntax::Types
+  include Finitio::Syntax::Lexer
+  include Finitio::Syntax::Literals
+
+  rule type_def
+    (metadata? type_name equal type)
+    <Finitio::Syntax::TypeDef>
+  end
+
+  rule main_type
+    (metadata? type)
+    <Finitio::Syntax::MainType>
+  end
+
+  rule type
+    union_type
+  end
+
+  # union and sub types
+
+  rule union_type
+      (sub_type (pipe sub_type)+)
+      <Finitio::Syntax::UnionType>
+    | sub_type
+  end
+
+  rule sub_type
+      (rel_type constraint_def)
+      <Finitio::Syntax::SubType>
+    | rel_type
+  end
+
+  rule constraint_def
+    ('(' spacing var_name pipe constraints spacing ')')
+    <Finitio::Syntax::ConstraintDef>
+  end
+
+  rule constraints
+      (constraint:named_constraint (opt_comma constraint:named_constraint)* opt_comma)
+      <Finitio::Syntax::Constraints>
+    | (spacing constraint:unnamed_constraint)
+      <Finitio::Syntax::Constraints>
+  end
+
+  rule named_constraint
+    (metadata? constraint_name colon expression)
+    <Finitio::Syntax::NamedConstraint>
+  end
+
+  rule unnamed_constraint
+    (metadata? expression)
+    <Finitio::Syntax::UnnamedConstraint>
+  end
+
+  # relational types
+
+  rule rel_type
+      relation_type
+    | tuple_type
+    | collection_type
+  end
+
+  rule relation_type
+    ('{{' spacing heading spacing '}}')
+    <Finitio::Syntax::RelationType>
+  end
+
+  rule tuple_type
+    ('{' spacing heading spacing '}')
+    <Finitio::Syntax::TupleType>
+  end
+
+  rule heading
+    (attribute? (opt_comma attribute)* (opt_comma allow_extra:dots)? opt_comma?)
+    <Finitio::Syntax::Heading>
+  end
+
+  rule attribute
+    (metadata? attribute_name spacing multiplicity:(':?' | ':') spacing type)
+    <Finitio::Syntax::Attribute>
+  end
+
+  # collection types
+
+  rule collection_type
+      set_type
+    | seq_type
+    | struct_type
+    | term_type
+  end
+
+  rule set_type
+    ('{' type '}')
+    <Finitio::Syntax::SetType>
+  end
+
+  rule seq_type
+    ('[' type ']')
+    <Finitio::Syntax::SeqType>
+  end
+
+  rule struct_type
+    ('<' type (comma type)* '>')
+    <Finitio::Syntax::StructType>
+  end
+
+  # terminal forms
+
+  rule term_type
+      ad_type
+    | builtin_type
+    | any_type
+    | type_ref
+  end
+
+  # ad type
+
+  rule ad_type
+    (('.' builtin_type_name)? spacing contract (opt_comma contract)* opt_comma)
+    <Finitio::Syntax::AdType>
+  end
+
+  rule contract
+    (metadata? '<' contract_name '>' spacing type spacing pair?)
+    <Finitio::Syntax::Contract>
+  end
+
+  rule pair
+      inline_pair
+    | external_pair
+  end
+
+  rule inline_pair
+    ('\\' dress:lambda_expr spacing '\\' undress:lambda_expr)
+    <Finitio::Syntax::InlinePair>
+  end
+
+  rule external_pair
+    ('.' builtin_type_name)
+    <Finitio::Syntax::ExternalPair>
+  end
+
+  # any
+
+  rule any_type
+    '.'
+    <Finitio::Syntax::AnyType>
+  end
+
+  # builtin and refs
+
+  rule builtin_type
+    ('.' builtin_type_name)
+    <Finitio::Syntax::BuiltinType>
+  end
+
+  rule type_ref
+    (type_name spacing)
+    <Finitio::Syntax::TypeRef>
+  end
+
+  # metadata
+
+  rule metadata
+    (open_metadata metadata_attr (opt_comma metadata_attr)* opt_comma close_metadata)
+    <Finitio::Syntax::Metadata>
+  | (open_metadata description:(!'-/' .)+ close_metadata)
+    <Finitio::Syntax::Metadata>
+  end
+
+  rule metadata_attr
+    (attribute_name colon literal)
+    <Finitio::Syntax::MetadataAttr>
+  end
+
+  # lambda and expressions
+
+  rule lambda_expr
+    ('(' spacing var_name pipe expression spacing ')')
+    <Finitio::Syntax::LambdaExpr>
+  end
+
+  rule expression
+    expression_part+
+    <Finitio::Syntax::Expression>
+  end
+
+  rule expression_part
+      ('(' expression ')')
+    | (![\(,\)\n] .)+
+  end
+
+end

data/lib/finitio/system.rb

@@ -4,22 +4,12 @@ module Finitio
   #
   class System
 
-    def initialize(types = {}, main = nil)
+    def initialize(types = {})
       @types = types
-      @main  = main
     end
-    attr_accessor :main
 
-    DSL_METHODS.each do |dsl_method|
-      define_method(dsl_method){|*args, &bl|
-        factory.public_send(dsl_method, *args, &bl)
-      }
-    end
-
-    def add_type(type)
-      unless type.is_a?(Type)
-        raise ArgumentError, "Finitio::Type expected, got `#{type}`"
-      end
+    def add_type(type, name = nil, metadata = nil)
+      type = factory.type(type, name, metadata)
 
       if @types.has_key?(type.name)
         raise Error, "Duplicate type name `#{type.name}`"
@@ -29,10 +19,14 @@ module Finitio
     end
 
     def get_type(name)
-      @types[name]
+      @types[name] || @types[name.to_s]
     end
     alias :[] :get_type
 
+    def main
+      self['Main']
+    end
+
     def fetch(name, &bl)
       @types.fetch(name, &bl)
     end
@@ -41,6 +35,12 @@ module Finitio
       @factory ||= TypeFactory.new
     end
 
+    TypeFactory::DSL_METHODS.each do |dsl_method|
+      define_method(dsl_method){|*args, &bl|
+        factory.public_send(dsl_method, *args, &bl)
+      }
+    end
+
     def dress(*args, &bl)
       raise Error, "No main type." unless main
       main.dress(*args, &bl)
@@ -56,7 +56,7 @@ module Finitio
     end
 
     def dup
-      System.new(@types.dup, @main)
+      System.new(@types.dup)
     end
 
   end # class System

data/lib/finitio/type.rb

@@ -3,12 +3,29 @@ module Finitio
   # Abstract class for Finitio type (generators).
   #
   class Type
+    include Metadata
 
-    def initialize(name)
+    def initialize(name, metadata)
       unless name.nil? or name.is_a?(String)
         raise ArgumentError, "String expected for type name, got `#{name}`"
       end
-      @name = name
+      unless metadata.nil? or metadata.is_a?(Hash)
+        raise ArgumentError, "Hash expected for metadata, got `#{metadata}`"
+      end
+      @name     = name
+      @metadata = metadata
+    end
+
+    def anonymous?
+      @name.nil?
+    end
+
+    def named?
+      !anonymous?
+    end
+
+    def default_name
+      raise NotImplementedError, "Missing #{self.class.name}#default_name"
     end
 
     def name
@@ -20,10 +37,6 @@ module Finitio
       @name = n
     end
 
-    def to_s
-      name.to_s
-    end
-
     # Check if `value` belongs to this type. Returns true if it's the case,
     # false otherwise.
     #
@@ -41,6 +54,16 @@ module Finitio
       raise NotImplementedError, "Missing #{self.class.name}#dress"
     end
 
+    def to_s
+      name.to_s
+    end
+
+    def ==(other)
+      super || [ProxyType, AliasType].any?{|t|
+        other.is_a?(t) && other == self
+      }
+    end
+
   protected
 
     def set_equal?(s1, s2)
@@ -53,12 +76,21 @@ module Finitio
 
   end # class Type
 end # module Finitio
+require_relative 'type/collection_type'
+require_relative 'type/heading_based_type'
+require_relative 'type/hash_based_type'
+require_relative 'type/rel_based_type'
+require_relative 'type/proxy_type'
+require_relative 'type/alias_type'
 require_relative 'type/any_type'
 require_relative 'type/builtin_type'
 require_relative 'type/union_type'
 require_relative 'type/sub_type'
 require_relative 'type/seq_type'
 require_relative 'type/set_type'
+require_relative 'type/struct_type'
 require_relative 'type/tuple_type'
+require_relative 'type/multi_tuple_type'
 require_relative 'type/relation_type'
+require_relative 'type/multi_relation_type'
 require_relative 'type/ad_type'