qrb 0.1.0

data/lib/qrb/support.rb

@@ -0,0 +1,5 @@
+require_relative 'support/attribute'
+require_relative 'support/heading'
+require_relative 'support/dress_helper'
+require_relative 'support/collection_type'
+require_relative 'support/type_factory'

data/lib/qrb/syntax/ad_type.rb

@@ -0,0 +1,25 @@
+module Qrb
+  module Syntax
+    module AdType
+      include Support
+
+      def compile(factory)
+        name  = builtin_type_name
+        clazz = name ? resolve_ruby_const(name.to_s) : nil
+        factory.adt(clazz, compile_contracts(factory, clazz))
+      end
+
+      def compile_contracts(factory, clazz)
+        contracts = {}
+        captures[:contract].each do |node|
+          contract = node.compile(factory, clazz)
+          contracts.merge!(contract) do |k,_,_|
+            raise Error, "Duplicate contract name `#{k}`"
+          end
+        end
+        contracts
+      end
+
+    end # module AdType
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/attribute.rb

@@ -0,0 +1,11 @@
+module Qrb
+  module Syntax
+    module Attribute
+
+      def compile(factory)
+        factory.attribute(attribute_name.to_sym, type.compile(factory))
+      end
+
+    end # module BuiltinType
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/builtin_type.rb

@@ -0,0 +1,13 @@
+module Qrb
+  module Syntax
+    module BuiltinType
+      include Support
+
+      def compile(factory)
+        clazz = resolve_ruby_const(builtin_type_name.to_s)
+        factory.builtin(clazz)
+      end
+
+    end # module BuiltinType
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/constraint_def.rb

@@ -0,0 +1,11 @@
+module Qrb
+  module Syntax
+    module ConstraintDef
+
+      def compile(factory)
+        constraints.compile(var_name.to_s)
+      end
+
+    end # module ConstraintDef
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/constraints.rb

@@ -0,0 +1,18 @@
+module Qrb
+  module Syntax
+    module Constraints
+
+      def compile(var_name)
+        constraints = {}
+        captures[:named_constraint].each do |node|
+          compiled = node.compile(var_name)
+          constraints.merge!(compiled) do |k,_,_|
+            raise Error, "Duplicate constraint name `#{k}`"
+          end
+        end
+        constraints
+      end
+
+    end # module Constraints
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/contract.rb

@@ -0,0 +1,25 @@
+module Qrb
+  module Syntax
+    module Contract
+
+      def compile(factory, clazz)
+        contract = [
+          type.compile(factory),
+          compile_upper(factory, clazz)
+        ]
+        { contract_name.to_sym => contract }
+      end
+
+      def compile_upper(factory, clazz)
+        if up
+          up.compile(factory)
+        elsif clazz
+          clazz.method(contract_name.to_sym)
+        else
+          Qrb::IDENTITY
+        end
+      end
+
+    end # module Contract
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/definitions.rb

@@ -0,0 +1,14 @@
+module Qrb
+  module Syntax
+    module Definitions
+
+      def compile(system)
+        captures[:type_def].each do |node|
+          node.compile(system)
+        end
+        system
+      end
+
+    end # module Definitions
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/expression.rb

@@ -0,0 +1,12 @@
+module Qrb
+  module Syntax
+    module Expression
+
+      def compile(var_name)
+        expr = "->(#{var_name}){ #{self} }"
+        ::Kernel.eval(expr)
+      end
+
+    end # module Expression
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/heading.rb

@@ -0,0 +1,15 @@
+module Qrb
+  module Syntax
+    module Heading
+
+      def attributes(factory)
+        captures[:attribute].map{|x| x.compile(factory) }
+      end
+
+      def compile(factory)
+        Qrb::Heading.new(attributes(factory))
+      end
+
+    end # module Heading
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/lambda_expr.rb

@@ -0,0 +1,11 @@
+module Qrb
+  module Syntax
+    module LambdaExpr
+
+      def compile(factory)
+        expression.compile(var_name)
+      end
+
+    end # module LambdaExpr
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/named_constraint.rb

@@ -0,0 +1,11 @@
+module Qrb
+  module Syntax
+    module NamedConstraint
+
+      def compile(var_name)
+        { constraint_name.to_sym => expression.compile(var_name) }
+      end
+
+    end # module NamedConstraint
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/q.citrus

@@ -0,0 +1,195 @@
+grammar Qrb::Syntax::Parser
+
+  rule system
+    (spacing definitions spacing type? spacing eof)
+    <Qrb::Syntax::System>
+  end
+
+  rule definitions
+    (type_def (spacing type_def)*)?
+    <Qrb::Syntax::Definitions>
+  end
+
+  ###################################################################### Types
+  rule type_def
+    (type_name spacing '=' spacing type)
+    <Qrb::Syntax::TypeDef>
+  end
+
+  rule type
+    union_type
+  end
+
+  # union and sub types
+
+  rule union_type
+      (sub_type ('|' sub_type)+)
+      <Qrb::Syntax::UnionType>
+    | sub_type
+  end
+
+  rule sub_type
+      (rel_type constraint_def)
+      <Qrb::Syntax::SubType>
+    | rel_type
+  end
+
+  rule constraint_def
+    ('(' spacing var_name spacing '|' spacing constraints spacing ')')
+    <Qrb::Syntax::ConstraintDef>
+  end
+
+  rule constraints
+      (named_constraint (spacing ',' spacing named_constraint)*)
+      <Qrb::Syntax::Constraints>
+    | unnamed_constraint
+  end
+
+  rule named_constraint
+    (constraint_name ':' spacing expression)
+    <Qrb::Syntax::NamedConstraint>
+  end
+
+  rule unnamed_constraint
+    (spacing expression)
+    <Qrb::Syntax::UnnamedConstraint>
+  end
+
+  # relational types
+
+  rule rel_type
+      relation_type
+    | tuple_type
+    | collection_type
+  end
+
+  rule relation_type
+    ('{{' spacing heading spacing '}}')
+    <Qrb::Syntax::RelationType>
+  end
+
+  rule tuple_type
+    ('{' spacing heading spacing '}')
+    <Qrb::Syntax::TupleType>
+  end
+
+  rule heading
+      (attribute (',' spacing attribute)*)
+      <Qrb::Syntax::Heading>
+    | spacing
+      <Qrb::Syntax::Heading>
+  end
+
+  rule attribute
+    (attribute_name spacing ':' spacing type)
+    <Qrb::Syntax::Attribute>
+  end
+
+  # collection types
+
+  rule collection_type
+      set_type
+    | seq_type
+    | term_type
+  end
+
+  rule set_type
+    ('{' type '}')
+    <Qrb::Syntax::SetType>
+  end
+
+  rule seq_type
+    ('[' type ']')
+    <Qrb::Syntax::SeqType>
+  end
+
+  # terminal forms
+
+  rule term_type
+      ad_type
+    | builtin_type
+    | type_ref
+  end
+
+  # ad type
+
+  rule ad_type
+    (('.' builtin_type_name)? spacing contract (spacing ',' spacing contract)*)
+    <Qrb::Syntax::AdType>
+  end
+
+  rule contract
+    ('<' contract_name '>' spacing type (spacing ('\\' up:lambda_expr) spacing ('\\' down:lambda_expr))?)
+    <Qrb::Syntax::Contract>
+  end
+
+  # builtin and refs
+
+  rule builtin_type
+    ('.' builtin_type_name)
+    <Qrb::Syntax::BuiltinType>
+  end
+
+  rule type_ref
+    (type_name spacing)
+    <Qrb::Syntax::TypeRef>
+  end
+
+  # lambda and expressions
+
+  rule lambda_expr
+    ('(' spacing var_name spacing '|' spacing expression spacing ')')
+    <Qrb::Syntax::LambdaExpr>
+  end
+
+  rule expression
+    (
+        ('(' spacing expression spacing ')')
+      | (![\(,\)] .)+ expression?
+    )
+    <Qrb::Syntax::Expression>
+  end
+
+  # lexer
+
+  rule var_name
+    /[a-z]+/
+  end
+
+  rule contract_name
+    /[a-z][a-z0-9]*/
+  end
+
+  rule constraint_name
+    /[a-z][a-z_]*/
+  end
+
+  rule attribute_name
+    /[a-z][a-zA-Z0-9_]*/
+  end
+
+  rule type_name
+    /[A-Z][a-zA-Z]+/
+  end
+
+  rule builtin_type_name
+    /[a-zA-Z0-9:]/+
+  end
+
+  rule spacing
+    (spaces | comment)*
+  end
+
+  rule comment
+    '#' (![\n] .)* [\n]?
+  end
+
+  rule spaces
+    /[ \t\n]+/
+  end
+
+  rule eof
+    !.
+  end
+
+end

data/lib/qrb/syntax/relation_type.rb

@@ -0,0 +1,11 @@
+module Qrb
+  module Syntax
+    module RelationType
+
+      def compile(factory)
+        factory.relation(heading.compile(factory))
+      end
+
+    end # module RelationType
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/seq_type.rb

@@ -0,0 +1,12 @@
+module Qrb
+  module Syntax
+    module SeqType
+
+      def compile(factory)
+        elm_type = type.compile(factory)
+        factory.seq(elm_type)
+      end
+
+    end # module SeqType
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/set_type.rb

@@ -0,0 +1,12 @@
+module Qrb
+  module Syntax
+    module SetType
+
+      def compile(factory)
+        elm_type = type.compile(factory)
+        factory.set(elm_type)
+      end
+
+    end # module SetType
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/sub_type.rb

@@ -0,0 +1,13 @@
+module Qrb
+  module Syntax
+    module SubType
+
+      def compile(factory)
+        s = rel_type.compile(factory)
+        c = constraint_def.compile(factory)
+        factory.subtype(s, c)
+      end
+
+    end # module SubType
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/support.rb

@@ -0,0 +1,13 @@
+module Qrb
+  module Syntax
+    module Support
+
+      def resolve_ruby_const(name)
+        name.split('::').inject(::Kernel){|mod,const|
+          mod.const_get(const)
+        }
+      end
+
+    end # module Support
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/system.rb

@@ -0,0 +1,15 @@
+module Qrb
+  module Syntax
+    module System
+
+      def compile(system)
+        definitions.compile(system)
+        if type
+          system.main = type.compile(system)
+        end
+        system
+      end
+
+    end # module System
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/tuple_type.rb

@@ -0,0 +1,11 @@
+module Qrb
+  module Syntax
+    module TupleType
+
+      def compile(factory)
+        factory.tuple(heading.compile(factory))
+      end
+
+    end # module TupleType
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/type_def.rb

@@ -0,0 +1,14 @@
+module Qrb
+  module Syntax
+    module TypeDef
+
+      def compile(system)
+        t = type.compile(system)
+        t.name = type_name.to_s
+        system.add_type(t)
+        t
+      end
+
+    end # module TypeDef
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/type_ref.rb

@@ -0,0 +1,13 @@
+module Qrb
+  module Syntax
+    module TypeRef
+
+      def compile(factory)
+        factory.fetch(type_name.to_s) do |n|
+          raise Error, "Unknown type `#{n}`"
+        end
+      end
+
+    end # module TypeRef
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/union_type.rb

@@ -0,0 +1,12 @@
+module Qrb
+  module Syntax
+    module UnionType
+
+      def compile(factory)
+        cds = captures[:sub_type].map{|x| x.compile(factory) }
+        factory.union(cds)
+      end
+
+    end # module UnionType
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/unnamed_constraint.rb

@@ -0,0 +1,11 @@
+module Qrb
+  module Syntax
+    module UnnamedConstraint
+
+      def compile(var_name)
+        { predicate: expression.compile(var_name) }
+      end
+
+    end # module UnnamedConstraint
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax.rb

@@ -0,0 +1,42 @@
+require 'citrus'
+require_relative 'syntax/support'
+require_relative 'syntax/system'
+require_relative 'syntax/definitions'
+require_relative 'syntax/type_def'
+require_relative 'syntax/expression'
+require_relative 'syntax/attribute'
+require_relative 'syntax/heading'
+require_relative 'syntax/builtin_type'
+require_relative 'syntax/sub_type'
+require_relative 'syntax/constraint_def'
+require_relative 'syntax/constraints'
+require_relative 'syntax/named_constraint'
+require_relative 'syntax/unnamed_constraint'
+require_relative 'syntax/seq_type'
+require_relative 'syntax/set_type'
+require_relative 'syntax/tuple_type'
+require_relative 'syntax/relation_type'
+require_relative 'syntax/union_type'
+require_relative 'syntax/type_ref'
+require_relative 'syntax/ad_type'
+require_relative 'syntax/contract'
+require_relative 'syntax/lambda_expr'
+module Qrb
+  module Syntax
+
+    Citrus.load File.expand_path('../syntax/q.citrus', __FILE__)
+
+    def self.parse(*args, &bl)
+      Parser.parse(*args, &bl)
+    end
+
+    def self.compile(source, system = Qrb::System.new)
+      Parser.parse(source, root: "system").compile(system)
+    end
+
+    def self.compile_type(str)
+      Parser.parse(str.strip, root: "type").compile(TypeFactory.new)
+    end
+
+  end
+end

data/lib/qrb/system.rb

@@ -0,0 +1,63 @@
+module Qrb
+  #
+  # A System is a collection of named Q types.
+  #
+  class System
+
+    def initialize(types = {}, main = nil)
+      @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, "Qrb::Type expected, got `#{type}`"
+      end
+
+      if @types.has_key?(type.name)
+        raise Error, "Duplicate type name `#{type.name}`"
+      end
+
+      @types[type.name] = type
+    end
+
+    def get_type(name)
+      @types[name]
+    end
+    alias :[] :get_type
+
+    def fetch(name, &bl)
+      @types.fetch(name, &bl)
+    end
+
+    def factory
+      @factory ||= TypeFactory.new
+    end
+
+    def dress(*args, &bl)
+      raise Error, "No main type." unless main
+      main.dress(*args, &bl)
+    end
+
+    def parse(source)
+      require "qrb/syntax"
+      Syntax.compile(source, self.dup)
+    end
+
+    def inspect
+      @types.each_pair.map{|k,v| "#{k} = #{v}" }.join("\n")
+    end
+
+    def dup
+      System.new(@types.dup, @main)
+    end
+
+  end # class System
+end # module Qrb