sbyc 0.1.1 → 0.1.3

data/README.textile

@@ -26,6 +26,27 @@ Marshal.dump(code)
 
 "Learn more about CodeTree":http://blambeau.github.com/sbyc/codetree.html
 
+h2. TypeSystem
+
+This part of SByC implements a TypeSystem abstraction. A type is simply collection of values. A type system is to generate and parse literals and to coerce from String values.
+
+<pre>
+TypeSystem::Ruby::type_of(-125)
+# => Fixnum
+
+lit = TypeSystem::Ruby::to_literal(-125)
+# => "-125"
+
+TypeSystem::Ruby::parse_literal("-125")
+# => -125
+
+TypeSystem::Ruby::coerce('-125', Integer)
+# => -125
+</pre>
+
+"Learn more about TypeSystem":http://blambeau.github.com/sbyc/type_system.html
+
+
 h2. INSTALL
 
 bc. gem install sbyc

data/lib/sbyc.rb

@@ -1,14 +1,22 @@
 module SByC
 
   # Version
-  VERSION = "0.1.1".freeze
+  VERSION = "0.1.3".freeze
   
   # Provides tools around functional source code trees.
   module CodeTree
     
   end # module CodeTree
+
+  # Provides tools around type system abstractions
+  module TypeSystem
+    
+  end # module CodeTree
   
 end # module SByC
 
 CodeTree = ::SByC::CodeTree
-require 'sbyc/codetree'
+require 'sbyc/codetree'
+
+TypeSystem = ::SByC::TypeSystem
+require 'sbyc/type_system'

data/lib/sbyc/codetree/ast_node.rb

@@ -121,10 +121,14 @@ module CodeTree
           arg
         when Array
           name, children = arg
-          if name == :_ and children.size == 1
-            AstNode.new(:_, children)
+          if name.kind_of?(Symbol) and children.kind_of?(Array)
+            if name == :_ and children.size == 1
+              AstNode.new(:_, children)
+            else
+              AstNode.new(name, children.collect{|c| AstNode.coerce(c)})
+            end
           else
-            AstNode.new(name, children.collect{|c| AstNode.coerce(c)})
+            AstNode.new(:_, [ arg ])
           end
         else
           AstNode.new(:_, [ arg ])

data/lib/sbyc/codetree/proc_parser.rb

@@ -89,7 +89,8 @@ module CodeTree
       collector = options[:multiline] ? Collector.new : nil
       e = case block.arity
         when -1, 0
-          Expr.new(nil, nil, collector).instance_eval(&block)
+          expr = Expr.new(nil, nil, collector)
+          expr.instance_eval(&block)
         when 1
           block.call(Expr.new(nil, nil, collector))
         else

data/lib/sbyc/type_system.rb

@@ -0,0 +1,8 @@
+#
+# Implements a type system abstraction.
+#
+module TypeSystem
+end # module TypeSystem
+require 'sbyc/type_system/contract'
+require 'sbyc/type_system/errors'
+require 'sbyc/type_system/ruby'

data/lib/sbyc/type_system/contract.rb

@@ -0,0 +1,42 @@
+module TypeSystem
+  #
+  # Defines the abstract contract that a TypeSystem should implement.
+  #
+  module Contract
+    
+    #
+    # Returns the type of a value
+    #
+    def type_of(value)
+    end
+    
+    #
+    # Converts _value_ to a literal and returns it.
+    #
+    # This method should always be such that:
+    #   v == parse_literal(to_literal(v))
+    #
+    # @raise NoSuchLiteralError if value cannot be expressed as a literal
+    #
+    def to_literal(value)
+    end
+    
+    #
+    # Parse _str_ value literal and returns real value.
+    #
+    # @raise InvalidValueLiteralError if str does not look like a valid 
+    #        value literal
+    #
+    def parse_literal(str)
+    end
+    
+    #
+    # Coerces a string to a given class.
+    #
+    # @raise CoercionError if something goes wrong
+    #
+    def coerce(str, clazz)
+    end
+    
+  end # module Contract
+end # module TypeSystem

data/lib/sbyc/type_system/errors.rb

@@ -0,0 +1,6 @@
+module TypeSystem
+  class Error < StandardError; end
+  class InvalidValueLiteralError < Error; end
+  class NoSuchLiteralError < Error; end
+  class CoercionError < Error; end
+end # module TypeSystem

data/lib/sbyc/type_system/ruby.rb

@@ -0,0 +1,135 @@
+require 'date'
+require 'time'
+module TypeSystem
+  # 
+  # Implements a basic TypeSystem that mimics Ruby's type system.
+  #
+  module Ruby
+    
+    # Methods
+    module Methods
+      
+      # Ruby classes for which value.inspect will work for returning
+      # a valid literal
+      SAFE_LITERAL_CLASSES = {}
+      [NilClass, TrueClass, FalseClass,
+       Fixnum, Bignum,
+       Float, 
+       String,
+       Symbol,
+       Class, 
+       Module,
+       Regexp].each{|c| SAFE_LITERAL_CLASSES[c] = true}
+    
+      #
+      # Returns value.class
+      #
+      # @see TypeSystem::Contract#type_of
+      #
+      def type_of(value)
+        value.class
+      end
+  
+      #
+      # Converts _value_ to a ruby literal and returns it.
+      #
+      # Behavior of the algorithm when th value cannot be recognized depends
+      # on the :fallback option:
+      #   * when set to :fail, it raises a NoSuchLiteralError
+      #   * when set to :inspect, it returns <code>value.inspect</code>
+      #   * when set to :marshal it uses <code>Marshal::dump(value)</code>
+      #   * when set to :json it uses <code>JSON::generate(value)</code>
+      #
+      # @see TypeSystem::Contract#to_literal(value)
+      #
+      def to_literal(value, options = {:fallback => :fail})
+        if value.respond_to?(:to_ruby_literal)
+          value.to_ruby_literal
+        elsif value == (1.0/0)
+          return '(1.0/0)'
+        elsif value == -(1.0/0)
+          return '(-1.0/0)'
+        elsif SAFE_LITERAL_CLASSES.key?(type_of(value))
+          value.inspect
+        elsif value.kind_of?(Array)
+          "[" + value.collect{|v| to_literal(v, options)}.join(', ') + "]"
+        elsif value.kind_of?(Hash)
+          "{" + value.collect{|pair| "#{to_literal(pair[0], options)} => #{to_literal(pair[1], options)}"}.join(', ') + "}"
+        elsif value.kind_of?(Date)
+          "Date::parse(#{value.to_s.inspect})"
+        elsif value.kind_of?(Time)
+          "Time::parse(#{value.inspect.inspect})"
+        else
+          case options[:fallback]
+            when :inspect
+              value.inspect
+            when :marshal
+              "Marshal::load(#{Marshal::dump(value).inspect})"
+            when :json
+              require 'json'
+              JSON::generate(value)
+            when :fail, nil
+              raise NoSuchLiteralError, "Unable to convert #{value.inspect} to a ruby literal"
+            else
+              raise ArgumentError, "Invalid fallback option #{options[:fallback]}"
+          end
+        end
+      end
+    
+      #
+      # Returns result of Kernel.eval(str)
+      #
+      # @see TypeSystem::Contract#parse_literal(str)
+      #
+      def parse_literal(str)
+        Kernel.eval(str)
+      rescue Exception => ex
+        raise TypeSystem::InvalidValueLiteralError, "Invalid ruby value literal #{str.inspect}", ex.backtrace
+      end
+
+      #
+      # Coerces a string to a given class.
+      #
+      # @see TypeSystem::Contract#coerce(str)
+      #
+      def coerce(str, clazz)
+        if clazz == NilClass
+          return nil if str.empty? or str == "nil"
+        elsif clazz == TrueClass
+          return true if str == "true"
+        elsif clazz == FalseClass
+          return false if str == "false"
+        elsif [Fixnum, Bignum, Integer].include?(clazz)
+          if str =~ /^[-+]?[0-9]+$/
+            i = str.to_i
+            return i if i.kind_of?(clazz)
+          end
+        elsif clazz == Float 
+          if str =~ /^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$/
+            return str.to_f
+          end
+        elsif clazz == String
+          return str
+        elsif clazz == Symbol
+          return str.to_sym
+        elsif clazz == Class or clazz == Module
+          parts, current = str.split("::"), Kernel
+          parts.each{|part| current = current.const_get(part.to_sym)}
+          return current if current.kind_of?(clazz)
+        elsif clazz == Regexp
+          return Regexp::compile(str)
+        elsif clazz.respond_to?(:parse)
+          return clazz.parse(str)
+        end
+        raise TypeSystem::CoercionError, "Unable to coerce #{str} to a #{clazz}"
+      rescue TypeSystem::CoercionError
+        raise
+      rescue StandardError => ex
+        raise TypeSystem::CoercionError, "Unable to coerce #{str} to a #{clazz}: #{ex.message}"
+      end
+
+    end # module Methods
+    extend(Methods)
+    
+  end # class Ruby
+end # module TypeSystem

data/test/spec/documentation/type_system/example.spec

@@ -0,0 +1,21 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'sbyc/type_system/ruby'
+describe "Gh-Pages documentation: type_system/home.redcloth" do
+  
+  describe "What is said in README" do
+    specify{
+      TypeSystem::Ruby::type_of(-125).should == Fixnum
+      # => Fixnum
+
+      lit = TypeSystem::Ruby::to_literal(-125).should == "-125"
+      # => "-125"
+
+      TypeSystem::Ruby::parse_literal("-125").should == -125
+      # => -125
+
+      TypeSystem::Ruby::coerce('-125', Integer).should == -125
+      # => -125
+    }
+  end
+  
+end

data/test/spec/unit/sbyc/codetree/ast_node/coerce.spec

@@ -57,4 +57,13 @@ describe "CodeTree::AstNode#coerce" do
     }
   end
   
+  context("with array a single literal") do
+    subject { CodeTree::AstNode.coerce([{:id => 1}, {:id => 2}]) }
+    specify { 
+      subject.should be_kind_of(CodeTree::AstNode) 
+      subject.leaf?.should be_true
+      subject.literal.should == [{:id => 1}, {:id => 2}]
+    }
+  end
+  
 end 

data/test/spec/unit/sbyc/codetree/parse.spec

@@ -28,5 +28,32 @@ describe "CodeTree::parse" do
     }
   end
   
+  context "when called with an array of hashes as parameter" do
+    subject{ CodeTree::parse{
+      insert [{:id => 1}, {:id => 2}]
+    }}
+    specify{
+      subject.should be_kind_of(CodeTree::AstNode)
+      subject.name.should == :insert
+      subject.children[0].should be_kind_of(CodeTree::AstNode)
+      subject.children[0].literal.should == [{:id => 1}, {:id => 2}]
+    }
+  end
+  
+  context "when called with an array of hashes as parameter" do
+    subject{ CodeTree::parse{
+      (key! :table_name, [:col1, :col2])
+    }}
+    specify{
+      subject.should be_kind_of(CodeTree::AstNode)
+      subject.name.should == :key!
+      subject.children[0].should be_kind_of(CodeTree::AstNode)
+      subject.children[0].literal.should == :table_name
+      subject.children[1].should be_kind_of(CodeTree::AstNode)
+      subject.children[1].leaf?.should be_true
+      subject.children[1].literal.should == [:col1, :col2]
+    }
+  end
+  
 end
   

data/test/spec/unit/sbyc/type_system/ruby/coerce.spec

@@ -0,0 +1,97 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+require 'sbyc/type_system/ruby'
+
+describe "TypeSystem::Ruby#coerce" do
+  
+  ##################################################################################
+  ### SAFE CLASSES REPRESENTORS
+  ##################################################################################
+  
+  safe_representors = {
+    NilClass   => [ nil ],
+    TrueClass  => [ true ],
+    FalseClass => [ false ],
+    Fixnum     => [ -(2**(0.size * 8 - 2)), -1, 0, 1, 10, (2**(0.size * 8 - 2) - 1)],
+    Bignum     => [ -(2**(0.size * 8 - 2)) - 1, (2**(0.size * 8 - 2)) ],
+    Float      => [ -0.10, 0.0, 0.10 ],
+    String     => ['', 'hello'],
+    Symbol     => [ :hello, :"s-b-y-c", :"12" ],
+    Class      => [ Integer, ::Struct::Tms ],
+    Module     => [ Kernel, TypeSystem, TypeSystem::Ruby ],
+    Regexp     => [ /a-z/, /^$/, /\s*/, /[a-z]{15}/ ]
+  }
+  
+  safe_representors.each_pair do |clazz, values|
+    values.each do |value|
+      describe "When coercing #{value} to a #{clazz}" do
+        it "should return #{value}" do
+          str = value.kind_of?(Regexp) ? value.inspect[1..-2] : value.to_s
+          TypeSystem::Ruby::coerce(str, clazz).should == value
+        end  
+      end
+    end
+  end 
+
+
+  ##################################################################################
+  ### User defined objects
+  ##################################################################################
+  class TypeSystem::Ruby::Bar
+    attr_accessor :id
+    def initialize(id = 1); @id = id; end
+    def ==(other); other.kind_of?(TypeSystem::Ruby::Bar) and other.id == id; end
+    def self.parse(str)
+      TypeSystem::Ruby::Bar.new(TypeSystem::Ruby::coerce(str, Integer))
+    end
+    def inspect
+      id.inspect
+    end
+  end
+  
+  describe "when called with a user-defined class that respond to parse" do
+    
+    subject{ TypeSystem::Ruby::coerce(str, TypeSystem::Ruby::Bar) }
+
+    describe "when given a valid value" do
+      let(:value){ TypeSystem::Ruby::Bar.new(10) }
+      let(:str){ value.inspect }
+      it{ should == value }
+    end
+    
+    describe "when given an invalid values" do
+      let(:str){ "hello" }
+      specify{
+        lambda{ subject }.should raise_error(TypeSystem::CoercionError)
+      }
+    end
+    
+  end
+  
+  
+  ##################################################################################
+  ### Invalid values
+  ##################################################################################
+  
+  invalid_values = {
+    NilClass   => [ "hello", "false" ],
+    TrueClass  => [ "false", "nil" ],
+    FalseClass => [ "true", "nil" ],
+    Fixnum     => [ "hello", "1hello", "hello1", "1.0" ],
+    Bignum     => [ "hello", "1hello", "hello1", "1.0" ],
+    Float      => [ "hello", "1hello", "hello1", "1.0qsjh" ],
+    Class      => [ "hello" ],
+    Module     => [ "hello" ],
+    Regexp     => [ "[a-" ]
+  }
+  
+  invalid_values.each_pair do |clazz, values|
+    values.each do |value|
+      describe "When coercing #{value} to a #{clazz}" do
+        it "should raise an exception" do
+          lambda{ TypeSystem::Ruby::coerce(value, clazz) }.should raise_error(TypeSystem::CoercionError)
+        end  
+      end
+    end
+  end 
+  
+end

data/test/spec/unit/sbyc/type_system/ruby/parse_literal.spec

@@ -0,0 +1,26 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+require 'sbyc/type_system/ruby'
+
+describe "TypeSystem::Ruby#parse_literal" do
+  
+  describe "when called on a String value" do
+    subject{ TypeSystem::Ruby.parse_literal("'string'") }
+    it{ should == 'string' }
+  end
+  
+  describe "when called on a Fixnum value" do
+    subject{ TypeSystem::Ruby.parse_literal('10') }
+    it{ should == 10 }
+  end
+  
+  describe "when called on true" do
+    subject{ TypeSystem::Ruby.parse_literal('true') }
+    it{ should == true }
+  end
+  
+  describe "when called on false" do
+    subject{ TypeSystem::Ruby.parse_literal('false') }
+    it{ should == false }
+  end
+  
+end

data/test/spec/unit/sbyc/type_system/ruby/to_literal.spec

@@ -0,0 +1,116 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+require 'sbyc/type_system/ruby'
+
+describe "TypeSystem::Ruby#to_literal" do
+  
+  ##################################################################################
+  ### SAFE CLASSES REPRESENTORS
+  ##################################################################################
+  
+  safe_representors = {
+    NilClass   => [ nil ],
+    TrueClass  => [ true ],
+    FalseClass => [ false ],
+    Fixnum     => [ -(2**(0.size * 8 - 2)), -1, 0, 1, 10, (2**(0.size * 8 - 2) - 1)],
+    Bignum     => [ -(2**(0.size * 8 - 2)) - 1, (2**(0.size * 8 - 2)) ],
+    Float      => [ -0.10, 0.0, 0.10 ],
+    String     => ['', 'hello'],
+    Symbol     => [ :hello, :"s-b-y-c", :"12" ],
+    Class      => [ Integer, ::Struct::Tms ],
+    Module     => [ Kernel, TypeSystem, TypeSystem::Ruby ],
+    Regexp     => [ /a-z/, /^$/, /\s*/, /[a-z]{15}/ ]
+  }
+  
+  TypeSystem::Ruby::Methods::SAFE_LITERAL_CLASSES.keys.each do |clazz|
+    describe("SAFE_LITERAL_CLASS #{clazz} is covered by spec tests") do
+      subject{ safe_representors.key?(clazz) }
+      it{ should be_true }
+    end
+  end
+  
+  safe_representors.each_pair{|clazz, values|
+    values.each do |value|
+      describe("Safe representor #{value} is of good type #{clazz} natively") do
+        subject{ value.class }
+        it{ should == clazz }
+      end
+
+      describe("Safe representor #{value} is of good type #{clazz} through Ruby::type_of") do
+        subject{ TypeSystem::Ruby::type_of(value) }
+        it{ should == clazz }
+      end
+
+      describe("to_literal on safe representor #{clazz} / #{value} is equal to inspect") do
+        subject{ TypeSystem::Ruby::to_literal(value) }
+        it{ should == value.inspect }
+      end
+
+      describe("to_literal invariant is respected on safe representor #{clazz} / #{value}") do
+        subject{ TypeSystem::Ruby::parse_literal(TypeSystem::Ruby::to_literal(value)) }
+        it{ should == value }
+      end
+    end
+  }
+  
+  ##################################################################################
+  ### SPECIAL VALUES
+  ##################################################################################
+  
+  special_values = [
+    1.0/0, -1.0/0,
+    Time::parse(Time.now.inspect), Date::parse(Date.today.to_s)
+  ]
+  
+  special_values.each{|value|
+    describe("When called on special value #{value}") do
+      subject{ TypeSystem::Ruby::parse_literal(TypeSystem::Ruby::to_literal(value)) }
+      it{ should == value }
+    end
+  }
+  
+  ##################################################################################
+  ### ARRAY AND HASH
+  ##################################################################################
+  
+  describe "When called on an array with safe class instances" do
+    let(:value){ (safe_representors.values + special_values).flatten }
+    subject{ TypeSystem::Ruby::parse_literal(TypeSystem::Ruby::to_literal(value)) }
+    it{ should == value }
+  end
+
+  describe "When called on a hash with safe class instances" do
+    let(:value){ safe_representors }
+    subject{ TypeSystem::Ruby::parse_literal(TypeSystem::Ruby::to_literal(value)) }
+    it{ should == value }
+  end
+
+
+  ##################################################################################
+  ### User defined objects
+  ##################################################################################
+  
+  class TypeSystem::Ruby::Foo
+    attr_accessor :id
+    def initialize(id = 1); @id = id; end
+    def ==(other); other.kind_of?(TypeSystem::Ruby::Foo) and other.id == id; end
+    def inspect
+      "TypeSystem::Ruby::Foo.new(#{id.inspect})"
+    end
+  end
+  
+  non_failing_fallbacks = [:inspect, :marshal]
+  non_failing_fallbacks.each do |fallback|
+    describe "When called on a user-defined object with a #{fallback.inspect} fallback option" do
+      let(:value){ TypeSystem::Ruby::Foo.new(10) }
+      subject{ TypeSystem::Ruby::parse_literal(TypeSystem::Ruby::to_literal(value, :fallback => fallback)) }
+      it{ should == value }
+    end
+  end
+  
+  describe 'When called on a user-defined object with a :fail fallback option' do
+    let(:value){ TypeSystem::Ruby::Foo.new(10) }
+    subject{ Kernel::lambda{ TypeSystem::Ruby::to_literal(value, :fallback => :fail) } }
+    it{ should raise_error(TypeSystem::NoSuchLiteralError) }
+  end
+  
+end

data/test/spec/unit/sbyc/type_system/ruby/type_of.spec

@@ -0,0 +1,16 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+require 'sbyc/type_system/ruby'
+
+describe "TypeSystem::Ruby#type_of" do
+  
+  describe "when called on a String value" do
+    subject{ TypeSystem::Ruby.type_of("string") }
+    it{ should == String }
+  end
+  
+  describe "when called on a Fixnum value" do
+    subject{ TypeSystem::Ruby.type_of(10) }
+    it{ should == Fixnum }
+  end
+  
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sbyc
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 29
   prerelease: false
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
 - Bernard Lambeau
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-14 00:00:00 +02:00
+date: 2010-07-19 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -51,6 +51,10 @@ files:
 - lib/sbyc/codetree/rewriting/match.rb
 - lib/sbyc/codetree/rewriting.rb
 - lib/sbyc/codetree.rb
+- lib/sbyc/type_system/contract.rb
+- lib/sbyc/type_system/errors.rb
+- lib/sbyc/type_system/ruby.rb
+- lib/sbyc/type_system.rb
 - lib/sbyc.rb
 - test/spec/documentation/codetree/production.spec
 - test/spec/documentation/readme/assumptions.spec
@@ -60,6 +64,7 @@ files:
 - test/spec/documentation/readme/semantics.spec
 - test/spec/documentation/readme/synopsis.spec
 - test/spec/documentation/readme/syntax.spec
+- test/spec/documentation/type_system/example.spec
 - test/spec/spec_helper.rb
 - test/spec/test_all.rb
 - test/spec/unit/sbyc/codetree/ast_node/code_inject.spec
@@ -108,6 +113,10 @@ files:
 - test/spec/unit/sbyc/codetree/rewriting/match/apply.spec
 - test/spec/unit/sbyc/codetree/rewriting/match/coerce.spec
 - test/spec/unit/sbyc/codetree/rewriting/match/matches.spec
+- test/spec/unit/sbyc/type_system/ruby/coerce.spec
+- test/spec/unit/sbyc/type_system/ruby/parse_literal.spec
+- test/spec/unit/sbyc/type_system/ruby/to_literal.spec
+- test/spec/unit/sbyc/type_system/ruby/type_of.spec
 - README.textile
 - LICENCE.textile
 has_rdoc: true