qrb 0.2.0 → 0.3.0

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+# 0.3.0 / 2014-03-09
+
+* Added AnyType abstraction, aka '.'
+* Added support for external contracts in ADTs
+* Added support for extracting an Abstract Syntax Tree from parsing result
+* Allows camelCasing in constraint names
+
 # 0.2.0 / 2014-03-04
 
 * Fix dependencies in gemspec (judofyr)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    qrb (0.2.0)
+    qrb (0.3.0)
       citrus (~> 2.4)
 
 GEM

data/README.md

@@ -34,7 +34,7 @@ JSON
 puts schema.dress(data)
 ```
 
-## About this Q binding
+## ADTs with internal contracts
 
 Qrb tries to provide an idiomatic binding for ruby developers. In particular,
 it uses a simple convention-over-configuration protocol for information
@@ -71,12 +71,41 @@ class Color
 end
 ```
 
+## ADTs with external contracts
+
+When the scenario above is not possible or not wanted (would require core
+extensions for instance), Qrb allows defining ADTs with external contracts.
+The following ADT definition:
+
+```ruby
+Color = .Color <rgb> {r: Byte, g: Byte, b: Byte} ColorContract
+```
+
+expected the following ruby module:
+
+```ruby
+module ColorContract
+
+  def self.dress(tuple)
+    Color.new(tuple[:r], tuple[:g], tuple[:b])
+  end
+
+  def self.undress(color)
+    { r: color.r, g: color.g, b: color.b }
+  end
+
+end
+```
+
 ## About representations
 
 The `Rep` representation function mapping Q types to ruby classes is as
 follows:
 
 ```ruby
+# Any type is represented by Ruby's Object class
+Rep(.) = Object
+
 # Builtins are represented by the corresponding ruby class
 Rep(.Builtin) = Builtin
 

data/lib/qrb.rb

@@ -10,6 +10,7 @@ module Qrb
     :attribute,
     :heading,
     :constraints,
+    :any,
     :builtin,
     :adt,
     :subtype,
@@ -43,6 +44,11 @@ module Qrb
     Syntax.compile(source)
   end
 
+  def ast(source)
+    require "qrb/syntax"
+    Syntax.ast(source)
+  end
+
   def system(identifier)
     f = File.expand_path("../qrb/#{identifier}.q", __FILE__)
     if File.exists?(f)

data/lib/qrb/data_type.rb

@@ -6,7 +6,13 @@ module Qrb
     end
 
     def contract(name, infotype)
-      ad_contracts[name] = [ Qrb.type(infotype) , method(name) ]
+      dresser   = method(name)
+      undresser = instance_method(:"to_#{name}")
+      ad_contracts[name] = [
+        Qrb.type(infotype),
+        dresser,
+        ->(d){ undresser.bind(d).call }
+      ]
     end
 
   private

data/lib/qrb/support/dress_helper.rb

@@ -54,7 +54,7 @@ module Qrb
   private
 
     def value_to_s(value)
-      return 'nil' if value.nil?
+      return 'null' if value.nil?
       s = value.to_s
       s = "#{s[0..25]}..." if s.size>25
       s

data/lib/qrb/support/type_factory.rb

@@ -97,6 +97,12 @@ module Qrb
 
     ########################################################## Type generators
 
+    def any(name = nil)
+      name = name(name)
+
+      AnyType.new(name)
+    end
+
     def builtin(ruby_type, name = nil)
       ruby_type = ruby_type(ruby_type)
       name      = name(name)

data/lib/qrb/syntax.rb

@@ -6,6 +6,7 @@ require_relative 'syntax/type_def'
 require_relative 'syntax/expression'
 require_relative 'syntax/attribute'
 require_relative 'syntax/heading'
+require_relative 'syntax/any_type'
 require_relative 'syntax/builtin_type'
 require_relative 'syntax/sub_type'
 require_relative 'syntax/constraint_def'
@@ -20,6 +21,8 @@ require_relative 'syntax/union_type'
 require_relative 'syntax/type_ref'
 require_relative 'syntax/ad_type'
 require_relative 'syntax/contract'
+require_relative 'syntax/inline_pair'
+require_relative 'syntax/external_pair'
 require_relative 'syntax/lambda_expr'
 module Qrb
   module Syntax
@@ -30,6 +33,10 @@ module Qrb
       Parser.parse(*args, &bl)
     end
 
+    def self.ast(source)
+      Parser.parse(source, root: "system").to_ast
+    end
+
     def self.compile(source, system = Qrb::System.new)
       Parser.parse(source, root: "system").compile(system)
     end

data/lib/qrb/syntax/ad_type.rb

@@ -20,6 +20,13 @@ module Qrb
         contracts
       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 Qrb

data/lib/qrb/syntax/any_type.rb

@@ -0,0 +1,16 @@
+module Qrb
+  module Syntax
+    module AnyType
+      include Support
+
+      def compile(factory)
+        factory.any
+      end
+
+      def to_ast
+        [:any_type]
+      end
+
+    end # module AnyType
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/attribute.rb

@@ -6,6 +6,10 @@ module Qrb
         factory.attribute(attribute_name.to_sym, type.compile(factory))
       end
 
+      def to_ast
+        [:attribute, attribute_name.to_s, type.to_ast]
+      end
+
     end # module BuiltinType
   end # module Syntax
 end # module Qrb

data/lib/qrb/syntax/builtin_type.rb

@@ -8,6 +8,10 @@ module Qrb
         factory.builtin(clazz)
       end
 
+      def to_ast
+        [:builtin_type, builtin_type_name.to_s]
+      end
+
     end # module BuiltinType
   end # module Syntax
 end # module Qrb

data/lib/qrb/syntax/constraint_def.rb

@@ -6,6 +6,12 @@ module Qrb
         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
+      end
+
     end # module ConstraintDef
   end # module Syntax
 end # module Qrb

data/lib/qrb/syntax/constraints.rb

@@ -13,6 +13,10 @@ module Qrb
         constraints
       end
 
+      def to_ast(var_name)
+        captures[:named_constraint].map{|c| c.to_ast(var_name) }
+      end
+
     end # module Constraints
   end # module Syntax
 end # module Qrb

data/lib/qrb/syntax/contract.rb

@@ -3,23 +3,35 @@ module Qrb
     module Contract
 
       def compile(factory, clazz)
-        contract = [
-          type.compile(factory),
-          compile_upper(factory, clazz)
-        ]
+        contract = [ type.compile(factory) ] + compile_pair(factory, clazz)
         { contract_name.to_sym => contract }
       end
 
-      def compile_upper(factory, clazz)
-        if up
-          up.compile(factory)
+      def compile_pair(factory, clazz)
+        if pair
+          pair.compile(factory)
         elsif clazz
-          clazz.method(contract_name.to_sym)
+          dresser   = clazz.method(contract_name.to_sym)
+          undresser = clazz.instance_method(:"to_#{contract_name}")
+          [
+            dresser,
+            ->(d){ undresser.bind(d).call }
+          ]
         else
-          Qrb::IDENTITY
+          [ Qrb::IDENTITY, Qrb::IDENTITY ]
         end
       end
 
+      def to_ast
+        ast = [
+          :contract,
+          contract_name.to_s,
+          (type && type.to_ast) 
+        ]
+        ast << pair.to_ast if pair
+        ast
+      end
+
     end # module Contract
   end # module Syntax
 end # module Qrb

data/lib/qrb/syntax/definitions.rb

@@ -9,6 +9,10 @@ module Qrb
         system
       end
 
+      def to_ast
+        captures[:type_def].map(&:to_ast)
+      end
+
     end # module Definitions
   end # module Syntax
 end # module Qrb

data/lib/qrb/syntax/external_pair.rb

@@ -0,0 +1,17 @@
+module Qrb
+  module Syntax
+    module ExternalPair
+      include Support
+
+      def compile(factory)
+        clazz = resolve_ruby_const(builtin_type_name.to_s)
+        [ clazz.method(:dress), clazz.method(:undress) ]
+      end
+
+      def to_ast
+        [ :external_pair, builtin_type_name.to_s ]
+      end
+
+    end # module ExternalPair
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/heading.rb

@@ -10,6 +10,10 @@ module Qrb
         Qrb::Heading.new(attributes(factory))
       end
 
+      def to_ast
+        captures[:attribute].map(&:to_ast).unshift(:heading)
+      end
+
     end # module Heading
   end # module Syntax
 end # module Qrb

data/lib/qrb/syntax/inline_pair.rb

@@ -0,0 +1,16 @@
+module Qrb
+  module Syntax
+    module InlinePair
+      include Support
+
+      def compile(factory)
+        [ dress.compile(factory), undress.compile(factory) ]
+      end
+
+      def to_ast
+        [ :inline_pair, dress.to_ast, undress.to_ast ]
+      end
+
+    end # module InlinePair
+  end # module Syntax
+end # module Qrb

data/lib/qrb/syntax/lambda_expr.rb

@@ -6,6 +6,10 @@ module Qrb
         expression.compile(var_name)
       end
 
+      def to_ast
+        [:fn, [:parameters, var_name.to_s], [:source, expression.to_s.strip]]
+      end
+
     end # module LambdaExpr
   end # module Syntax
 end # module Qrb

data/lib/qrb/syntax/named_constraint.rb

@@ -6,6 +6,12 @@ module Qrb
         { constraint_name.to_sym => expression.compile(var_name) }
       end
 
+      def to_ast(var_name)
+        [ :constraint,
+          constraint_name.to_s,
+          [:fn, [:parameters, var_name], [:source, expression.to_s.strip]] ]
+      end
+
     end # module NamedConstraint
   end # module Syntax
 end # module Qrb

data/lib/qrb/syntax/q.citrus

@@ -108,6 +108,7 @@ grammar Qrb::Syntax::Parser
   rule term_type
       ad_type
     | builtin_type
+    | any_type
     | type_ref
   end
 
@@ -119,10 +120,32 @@ grammar Qrb::Syntax::Parser
   end
 
   rule contract
-    ('<' contract_name '>' spacing type (spacing ('\\' up:lambda_expr) spacing ('\\' down:lambda_expr))?)
+    ('<' contract_name '>' spacing type spacing pair?)
     <Qrb::Syntax::Contract>
   end
 
+  rule pair
+      inline_pair
+    | external_pair
+  end
+
+  rule inline_pair
+    ('\\' dress:lambda_expr spacing '\\' undress:lambda_expr)
+    <Qrb::Syntax::InlinePair>
+  end
+
+  rule external_pair
+    ('.' builtin_type_name)
+    <Qrb::Syntax::ExternalPair>
+  end
+
+  # any
+
+  rule any_type
+    '.'
+    <Qrb::Syntax::AnyType>
+  end
+
   # builtin and refs
 
   rule builtin_type
@@ -150,7 +173,7 @@ grammar Qrb::Syntax::Parser
     <Qrb::Syntax::Expression>
   end
 
-  # lexer
+  # LEXER (names)
 
   rule var_name
     /[a-z]+/
@@ -161,7 +184,7 @@ grammar Qrb::Syntax::Parser
   end
 
   rule constraint_name
-    /[a-z][a-z_]*/
+    /[a-z][a-zA-Z_]*/
   end
 
   rule attribute_name
@@ -173,9 +196,11 @@ grammar Qrb::Syntax::Parser
   end
 
   rule builtin_type_name
-    /[a-zA-Z0-9:]/+
+    /[a-zA-Z0-9:]+/
   end
 
+  # LEXER (spacing & comments)
+
   rule spacing
     (spaces | comment)*
   end