qrb 0.2.0 → 0.3.0

data/lib/qrb/syntax/q.sexp

@@ -0,0 +1,114 @@
+### system
+
+system:
+  - [ type_def* type ]
+
+type_def:
+  - [ type_name type ]
+
+### types
+
+type:
+  - any_type
+  - builtin_type
+  - sub_type
+  - union_type
+  - set_type
+  - seq_type
+  - tuple_type
+  - relation_type
+  - ad_type
+  - type_ref
+
+any_type:
+  - [ ]
+
+builtin_type:
+  - [ ruby_module_name ]
+
+sub_type:
+  - [ type, constraint+ ]
+
+union_type:
+  - [ type+ ]
+
+set_type:
+  - [ type ]
+
+seq_type:
+  - [ type ]
+
+tuple_type:
+  - [ heading ]
+
+relation_type:
+  - [ heading ]
+
+ad_type:
+  - [ ruby_module_name_or_nil, contract+ ]
+
+type_ref:
+  - [ type_name ]
+
+### heading
+
+heading:
+  [ attribute+ ]
+
+attribute:
+  [ attribute_name, type ]
+
+### constraints
+
+constraint:
+  - [ constraint_name, fn ]
+
+### contracts
+
+contract:
+  - [ contract_name, type, pair? ]
+
+pair:
+  - external_pair
+  - inline_pair
+
+inline_pair:
+  - [ fn, fn ]
+
+external_pair:
+  - [ ruby_module_name ]
+
+### functions/expressions
+
+fn:
+  - [ parameters, source ]
+
+parameters:
+  - [ parameter_name+ ]
+
+source:
+  - [ String ]
+
+### names
+
+attribute_name:
+  !ruby/regexp /^[a-z][a-zA-Z0-9_]*$/
+
+ruby_module_name:
+  !ruby/regexp /^[a-zA-Z0-9:]+$/
+
+ruby_module_name_or_nil:
+  - ruby_module_name
+  - ~
+
+contract_name:
+  !ruby/regexp /^[a-z][a-z0-9]*$/
+
+constraint_name:
+  !ruby/regexp /^[a-z][a-zA-Z_]*$/
+
+parameter_name:
+  !ruby/regexp /^[a-z]+$/
+
+type_name:
+  !ruby/regexp /^[A-Z][a-zA-Z]+$/

data/lib/qrb/syntax/relation_type.rb

@@ -6,6 +6,10 @@ module Qrb
         factory.relation(heading.compile(factory))
       end
 
+      def to_ast
+        [:relation_type, heading.to_ast]
+      end
+
     end # module RelationType
   end # module Syntax
 end # module Qrb

data/lib/qrb/syntax/seq_type.rb

@@ -7,6 +7,10 @@ module Qrb
         factory.seq(elm_type)
       end
 
+      def to_ast
+        [:seq_type, type.to_ast]
+      end
+
     end # module SeqType
   end # module Syntax
 end # module Qrb

data/lib/qrb/syntax/set_type.rb

@@ -7,6 +7,10 @@ module Qrb
         factory.set(elm_type)
       end
 
+      def to_ast
+        [:set_type, type.to_ast]
+      end
+
     end # module SetType
   end # module Syntax
 end # module Qrb

data/lib/qrb/syntax/sub_type.rb

@@ -8,6 +8,10 @@ module Qrb
         factory.subtype(s, c)
       end
 
+      def to_ast
+        [:sub_type, rel_type.to_ast] + constraint_def.to_ast
+      end
+
     end # module SubType
   end # module Syntax
 end # module Qrb

data/lib/qrb/syntax/system.rb

@@ -10,6 +10,12 @@ module Qrb
         system
       end
 
+      def to_ast
+        ast = [ :system ] + definitions.to_ast
+        ast << type.to_ast if type
+        ast
+      end
+
     end # module System
   end # module Syntax
 end # module Qrb

data/lib/qrb/syntax/tuple_type.rb

@@ -6,6 +6,10 @@ module Qrb
         factory.tuple(heading.compile(factory))
       end
 
+      def to_ast
+        [:tuple_type, heading.to_ast]
+      end
+
     end # module TupleType
   end # module Syntax
 end # module Qrb

data/lib/qrb/syntax/type_def.rb

@@ -9,6 +9,10 @@ module Qrb
         t
       end
 
+      def to_ast
+        [:type_def, type_name.to_s, type.to_ast]
+      end
+
     end # module TypeDef
   end # module Syntax
 end # module Qrb

data/lib/qrb/syntax/type_ref.rb

@@ -8,6 +8,10 @@ module Qrb
         end
       end
 
+      def to_ast
+        [:type_ref, type_name.to_s]
+      end
+
     end # module TypeRef
   end # module Syntax
 end # module Qrb

data/lib/qrb/syntax/union_type.rb

@@ -7,6 +7,10 @@ module Qrb
         factory.union(cds)
       end
 
+      def to_ast
+        captures[:sub_type].map(&:to_ast).unshift(:union_type)
+      end
+
     end # module UnionType
   end # module Syntax
 end # module Qrb

data/lib/qrb/syntax/unnamed_constraint.rb

@@ -6,6 +6,12 @@ module Qrb
         { predicate: expression.compile(var_name) }
       end
 
+      def to_ast(var_name)
+        [ :constraint,
+          "default",
+          [:fn, [:parameters, var_name], [:source, expression.to_s.strip]] ]
+      end
+
     end # module UnnamedConstraint
   end # module Syntax
 end # module Qrb

data/lib/qrb/type.rb

@@ -53,6 +53,7 @@ module Qrb
 
   end # class Type
 end # module Qrb
+require_relative 'type/any_type'
 require_relative 'type/builtin_type'
 require_relative 'type/union_type'
 require_relative 'type/sub_type'

data/lib/qrb/type/ad_type.rb

@@ -56,7 +56,8 @@ module Qrb
         raise ArgumentError, "Hash expected, got `#{contracts}`"
       end
       invalid = contracts.values.reject{|v|
-        v.is_a?(Array) and v.size == 2 and v.first.is_a?(Type) and v.last.respond_to?(:call)
+        v.is_a?(Array) and v.size == 3 and v[0].is_a?(Type) and \
+        v[1].respond_to?(:call) and v[2].respond_to?(:call)
       }
       unless invalid.empty?
         raise ArgumentError, "Invalid contracts `#{invalid}`"
@@ -86,20 +87,20 @@ module Qrb
 
       # Try each contract in turn. Do nothing on TypeError as
       # the next candidate could be the good one! Return the
-      # first successfully uped.
-      contracts.each_pair do |name, (infotype,upper)|
+      # first successfully dressed.
+      contracts.each_pair do |name, (infotype, dresser, _)|
 
         # First make the dress transformation on the information type
-        success, uped = handler.just_try do
+        success, dressed = handler.just_try do
           infotype.dress(value, handler)
         end
         next unless success
 
         # Seems nice, just try to get one stage higher now
-        success, uped = handler.just_try(StandardError) do
-          upper.call(uped)
+        success, dressed = handler.just_try(StandardError) do
+          dresser.call(dressed)
         end
-        return uped if success
+        return dressed if success
 
       end
 

data/lib/qrb/type/any_type.rb

@@ -0,0 +1,47 @@
+module Qrb
+  #
+  # An AnyType generator allows capuring the set of every ruby citizen as a Q
+  # type.
+  #
+  #     Any := .
+  #
+  # Object is used as concrete representation of the information type as the
+  # Ruby `Object` class already captures everything.
+  #
+  #     R(.) = Object
+  #
+  # Accordingly, the `dress` transformation function has the signature below.
+  # Note that dress always succeeds and returns its first argument.
+  #
+  #     dress :: Alpha  -> Object throws TypeError
+  #     dress :: Object -> Object throws TypeError
+  #
+  class AnyType < Type
+
+    def initialize(name = nil)
+      super(name)
+    end
+
+    def default_name
+      "Any"
+    end
+
+    def include?(value)
+      true
+    end
+
+    def dress(value, handler = nil)
+      value
+    end
+
+    def ==(other)
+      other.is_a?(AnyType)
+    end
+    alias :eql? :==
+
+    def hash
+      self.class.hash ^ 37
+    end
+
+  end # class AnyType
+end # module Qrb

data/lib/qrb/version.rb

@@ -2,7 +2,7 @@ module Qrb
   module Version
 
     MAJOR = 0
-    MINOR = 2
+    MINOR = 3
     TINY  = 0
 
     def self.to_s

data/spec/spec_helper.rb

@@ -35,6 +35,13 @@ class Color
 
 end
 
+module ExternalContract
+  def self.dress(x)
+  end
+  def self.undress(y)
+  end
+end
+
 module SpecHelpers
 
   def intType
@@ -57,6 +64,10 @@ module SpecHelpers
     Qrb::TypeFactory.new
   end
 
+  def system
+    Qrb::System.new
+  end
+
   def blueviolet
     Color.new(138, 43, 226)
   end

data/spec/unit/qrb/test_ast.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+describe Qrb, "ast" do
+
+  subject{
+    Qrb.ast <<-EOF
+      Posint = .Fixnum( i | i>=0 )
+      Point  = { x: Posint, y: Posint }
+      {{ p: Point }}
+    EOF
+  }
+
+  let(:expected){
+    [ :system,
+      [ :type_def,
+        "Posint",
+        [ :sub_type,
+          [:builtin_type, "Fixnum"],
+          [ :constraint,
+            "default",
+            [:fn, [:parameters, "i"], [:source, "i>=0"] ]
+          ]
+        ]
+      ],
+      [ :type_def,
+        "Point",
+        [ :tuple_type,
+          [ :heading,
+            [:attribute, "x", [:type_ref, "Posint"]],
+            [:attribute, "y", [:type_ref, "Posint"]]
+          ]
+        ]
+      ],
+      [ :relation_type,
+        [ :heading,
+          [:attribute, "p", [:type_ref, "Point"]]
+        ]
+      ]
+    ]
+  }
+
+  it{ should eq(expected) }
+
+end

data/spec/unit/syntax/nodes/test_ad_type.rb

@@ -10,6 +10,10 @@ module Qrb
       subject.compile(type_factory)
     }
 
+    let(:ast){
+      subject.to_ast
+    }
+
     context 'One contract' do
       let(:input){ '.Color <rgb> {r: .Integer, g: .Integer, b: .Integer}' }
 
@@ -22,6 +26,23 @@ module Qrb
       it 'should behave as expected' do
         compiled.dress(r: 138, g: 43, b: 226).should eq(blueviolet)
       end
+
+      it 'has expected AST' do
+        ast.should eq([
+          :ad_type,
+          "Color",
+          [:contract,
+            "rgb",
+            [:tuple_type,
+              [:heading,
+                [:attribute, "r", [:builtin_type, "Integer"]],
+                [:attribute, "g", [:builtin_type, "Integer"]],
+                [:attribute, "b", [:builtin_type, "Integer"]]
+              ]
+            ]
+          ]
+        ])
+      end
     end
 
     context 'Two contracts' do
@@ -41,6 +62,27 @@ module Qrb
       it 'should behave as expected' do
         compiled.dress("#8A2BE2").should eq(blueviolet)
       end
+
+      it 'has expected AST' do
+        ast.should eq([
+          :ad_type,
+          "Color",
+          [:contract,
+            "rgb",
+            [:tuple_type,
+              [:heading,
+                [:attribute, "r", [:builtin_type, "Integer"]],
+                [:attribute, "g", [:builtin_type, "Integer"]],
+                [:attribute, "b", [:builtin_type, "Integer"]]
+              ]
+            ]
+          ],
+          [:contract,
+            "hex",
+            [:builtin_type, "String"]
+          ]
+        ])
+      end
     end
 
     context 'No ruby class' do
@@ -58,6 +100,21 @@ module Qrb
           compiled.dress("foo")
         }.should raise_error(TypeError)
       end
+
+      it 'has expected AST' do
+        ast.should eq([
+          :ad_type,
+          nil,
+          [:contract,
+            "as",
+            [:tuple_type,
+              [:heading,
+                [:attribute, "r", [:builtin_type, "Integer"]],
+              ]
+            ]
+          ]
+        ])
+      end
     end
 
     context 'Duplicate contract name' do
@@ -88,6 +145,21 @@ module Qrb
         err.should be_a(TypeError)
         err.message.should eq("Invalid value `foo` for DateTime")
       end
+
+      it 'has expected AST' do
+        ast.should eq([
+          :ad_type,
+          "DateTime",
+          [:contract,
+            "iso",
+            [:builtin_type, "String"],
+            [:inline_pair,
+              [:fn, [:parameters, "s"], [:source, "DateTime.parse(s)"]],
+              [:fn, [:parameters, "d"], [:source, "d.to_s"]],
+            ]
+          ]
+        ])
+      end
     end
 
   end