fancy 0.3.3 → 0.4.0

data/README.md

@@ -3,9 +3,12 @@
 (C) 2010, 2011 Christopher Bertels chris@fancy-lang.org
 http://www.fancy-lang.org
 
+[![Build Status](https://secure.travis-ci.org/bakkdoor/fancy.png)](http://travis-ci.org/bakkdoor/fancy)
+
+
 ----------------------------------------------------------------------
 Fancy is a dynamic, object-oriented programming language heavily
-inspired by Smalltalk, Ruby and Erlang. It supports dynamic code
+inspired by Smalltalk, Ruby, Io and Erlang. It supports dynamic code
 evaluation (as in Ruby & Smalltalk), class-based mixins, (simple)
 pattern matching, runtime introspection & reflection, "monkey
 patching" and much more. It runs on Rubinius, the Ruby VM, and thus
@@ -13,16 +16,19 @@ has first-class integration with Ruby's core library and any
 additional Ruby libraries that run on Rubinius, including most
 C-extensions.
 
-It will support concurrency via the actor-model, including first-class
-futures and async operation semantics built into the language.
+It supports concurrency via the actor-model, including first-class
+futures and async message send semantics built into the language,
+similar to Io.
 
 For a quick feature overview, have a look at `doc/features.md`
-For a recent version of the code with syntax highlighting look here:
-http://fancy-lang.org/code/
 There's also a work-in-progress tutorial/book on Fancy here:
 https://github.com/fancy-lang/infancy
 
-It’s still in development, the implementation has evolved from an
+Fancy's standard library is all written in Fancy (with some minor
+exceptions written in Ruby - see `boot/fancy_ext`).
+Have a look at the `lib/` directory.
+
+Fancy is still in development, the implementation has evolved from an
 interpreter written in C++ to a fully bootstrapped bytecode compiler
 for the Rubinius VM (http://www.rubini.us).
 You can see the self-hosted compiler implementation in `lib/compiler/`.
@@ -123,7 +129,7 @@ Ruby method invocation supports passing a block variable to Ruby as a proc.
   - Method & Operator calls
   - Instance & class variable access
   - Dynamic getter and setter method definitions (similar to Ruby's attr_acessor)
-  - Loops
+  - Loops (including `next` & `break`)
   - Support for closures via Blocks
   - Local & non-local returns from Blocks & Methods
   - File reading and writing
@@ -137,17 +143,11 @@ Ruby method invocation supports passing a block variable to Ruby as a proc.
   - Async message sends (`object @@ message`)
 
 
-##What's still missing?
-  - Some concurrency stuff (e.g. language syntax for actors)
-  - Some more advanced stuff, e.g. runtime inspection of method calls
-    via MethodContext etc. (saved for later)
-
-
 ##How is it implemented?
   - The lexer & parser are built with GNU Flex & GNU Bison.
     And used as a Ruby c-extension from Rubinius.
     The parser simply invokes methods on Fancy::Parser to build the AST.
-    See: `rbx/parser/parser.y` & `rbx/parser/parser.rb`
+    See: `lib/parser/ext/parser.y` & `lib/parser/methods.fy`
 
   - Once the AST is built, we use Rubinius' excellent compiler chain
     to compile it to bytecode.

data/Rakefile

@@ -162,7 +162,7 @@ namespace :compiler do
   end
 
   task :bootstrap => ["parser:generate", "rbx_parser:ext", file(boot_parser_e)] do
-    ["compiler:rootstrap", "compiler:compile", "compiler:wootstrap", "compiler:compile_tests"].each do |t|
+    ["compiler:rootstrap", "compiler:compile", "compiler:wootstrap"].each do |t|
       task(t).reenable
       task(t).execute
     end
@@ -250,9 +250,7 @@ task :compile => compiled
 
 desc "Runs the test suite."
 task :test do
-  sh! _('bin/fancy'),
-  '-e', 'ARGV rest rest each: |f| { require: f }',
-  *Dir.glob(_("tests/*.fy"))
+  sh! _('bin/fspec')
 end
 
 task :tests do
@@ -266,3 +264,17 @@ end
 task :bootstrap => ["compiler:bootstrap"]
 
 task :default => [:bootstrap_if_needed, :compile]
+
+desc "Runs all example files in examples/ dir"
+task :examples do
+  Dir.glob(_("examples/*.fy")).each do |f|
+    puts "Running #{f}"
+    puts
+    sh! _('bin/fancy'), f
+    puts
+  end
+end
+
+task "examples/" do
+  task(:examples).invoke
+end

data/bin/fancy

@@ -37,4 +37,7 @@ rescue RuntimeError => e
   else
     raise e
   end
+rescue Interrupt => e
+  puts e
+  exit
 end

data/bin/fspec

@@ -0,0 +1,20 @@
+#!/usr/bin/env fancy
+
+test_dir = "tests"
+{ test_dir = ARGV[1] } if: $ ARGV[1]
+
+test_files = Directory list: "#{test_dir}/**/*.fy"
+if: (test_files empty?) then: {
+  if: (Directory exists?: test_dir) then: {
+    "No test files found. Add them to the tests/ directory." println
+  } else: {
+    "No tests/ directory found. Create it!" println
+  }
+
+} else: {
+  test_files each: |f| {
+    require: f
+  }
+  Console newline
+  FancySpec SpecTest print_failures
+}

data/bin/fyi

@@ -2,19 +2,35 @@
 # -*- fancy -*-
 
 try {
-  if: (ARGV[1]) then: |ident| {
+  if: (ARGV[1]) then: {
+    ident = ARGV rest join: " "
     documentation = nil
-    if: (ident includes?: "#") then: {
-      parts = ident split: "#"
-      obj = parts[0] eval
-      if: (parts[1]) then: |method_name| {
-        method = obj instance_method: $ parts[1]
-        documentation = method documentation
-      }
+    match ident {
+      case /##/ ->
+        parts = ident split: "##"
+        obj = parts[0] eval
+        if: (parts[1]) then: |method_name| {
+          method = obj method: method_name
+          documentation = method documentation
+        }
+      case /#/ ->
+        parts = ident split: "#"
+        obj = parts[0] eval
+        if: (parts[1]) then: |method_name| {
+          method = nil
+          try {
+            method = obj instance_method: method_name
+          } catch NoMethodError {
+            # handle singleton methods if ARGV[1] is a singleton
+            method = obj method: method_name
+          }
+          documentation = method documentation
+        }
+      case _ ->
+        obj = ident eval
+        documentation = obj documentation
     }
-    # just print documentation for class here
-    obj = ident eval
-    documentation = obj documentation
+
     "Documentation for: '#{ident}':" println
     documentation println
   } else: {

data/bin/ifancy

@@ -45,7 +45,7 @@ def save_history {
   puts("saving history")
   unless: @history_saved do: {
     File open: HISTORY_FILE modes: ['write] with: |f| {
-      HISTORY each: |l| {
+      HISTORY last: 100 . each: |l| {
         f writeln: l
       }
     }

data/boot/fancy_ext.rb

@@ -12,3 +12,4 @@ require base + "block_env"
 require base + "class"
 require base + "string_helper"
 require base + "console"
+require base + "delegator"

data/boot/fancy_ext/block_env.rb

@@ -6,14 +6,6 @@ class Block
   alias_method :":call", :call
 
   define_method("call:") do |args|
-    unless args.is_a? Array
-      raise ArgumentError, "Expecting Array of arguments for Block"
-    end
-    if args.size < self.arity
-      raise ArgumentError, "Too few arguments for block: #{args.size} - Minimum of #{self.arity} expected"
-    else
-      args = args.first(self.arity) if args.size > self.arity
-      call *args
-    end
+    call *args
   end
 end

data/boot/fancy_ext/delegator.rb

@@ -0,0 +1,64 @@
+require "delegate"
+
+def DelegateClass(superclass)
+  klass = Class.new
+  methods = superclass.public_instance_methods(true)
+  methods -= ::Kernel.public_instance_methods(false)
+  methods -= %w[
+    __verify_metaclass__
+    copy_from
+    singleton_class
+    to_marshal
+  ]
+  methods |= ["to_s","to_a","inspect","==","=~","==="]
+
+  klass.module_eval do
+    def initialize(obj)  # :nodoc:
+      @_dc_obj = obj
+    end
+
+    def method_missing(m, *args)  # :nodoc:
+      unless @_dc_obj.respond_to?(m)
+        super(m, *args)
+      end
+      @_dc_obj.__send__(m, *args)
+    end
+
+    def respond_to?(m, include_private=false)  # :nodoc:
+      return true if super
+      return @_dc_obj.respond_to?(m, include_private)
+    end
+
+    def __getobj__  # :nodoc:
+      @_dc_obj
+    end
+
+    def __setobj__(obj)  # :nodoc:
+      raise ArgumentError, "cannot delegate to self" if self.equal?(obj)
+      @_dc_obj = obj
+    end
+
+    def clone  # :nodoc:
+      new = super
+      new.__setobj__(__getobj__.clone)
+      new
+    end
+
+    def dup  # :nodoc:
+      new = super
+      new.__setobj__(__getobj__.dup)
+      new
+    end
+  end
+
+  methods.each do |method|
+    begin
+      klass.__send__(:define_method, method) do |*args, &block|
+        @_dc_obj.__send__(method, *args, &block)
+      end
+    rescue SyntaxError
+      raise NameError, "invalid identifier #{method}"
+    end
+  end
+  return klass
+end

data/boot/fancy_ext/object.rb

@@ -15,6 +15,10 @@ class Object
     return self.to_s
   end
 
+  define_method("require:") do |path|
+    Fancy::CodeLoader.send "require:", path
+  end
+
   # HACK:
   # When we define private/protected/public methods, we usually use
   # Module#private, Module#protected & Module#public methods to set the

data/boot/fancy_ext/thread.rb

@@ -0,0 +1,4 @@
+class Thread
+  alias_method :thread_local, :[]
+  alias_method :set_thread_local, :[]=
+end

data/boot/load.rb

@@ -36,7 +36,11 @@ class Fancy
         raise "File not found #{file}" unless File.exist?(file)
 
         cl = Rubinius::CodeLoader.new(file)
-        cm = cl.load_compiled_file(file, 0)
+        begin
+          cm = cl.load_compiled_file(file, 0)
+        rescue ArgumentError
+          cm = cl.load_compiled_file(file, 0, 0)
+        end
 
         source = file.sub(/\.fyc/, ".fy")
 

data/boot/rbx-compiler/compiler/ast.rb

@@ -9,7 +9,6 @@ require base + '/ast/identifier'
 require base + '/ast/string_literal'
 require base + '/ast/method_def'
 require base + '/ast/singleton_method_def'
-require base + '/ast/require'
 require base + '/ast/class_def'
 require base + '/ast/block'
 require base + '/ast/assign'

data/boot/rbx-compiler/compiler/ast/class_def.rb

@@ -3,6 +3,8 @@ class Fancy
 
     class ClassDef < Rubinius::AST::Class
       def initialize(line, name, parent, body)
+        body = AST::ExpressionList.new(line) unless body
+
         if name.kind_of?(Fancy::AST::Identifier)
           name = name.name
         end

data/boot/rbx-compiler/compiler/ast/method_def.rb

@@ -3,6 +3,8 @@ class Fancy
 
     class MethodDef < Rubinius::AST::Define
       def initialize(line, method_ident, args, body, access = :public)
+        body = AST::ExpressionList.new(line) unless body
+
         @line = line
         @name = method_ident.method_name
         @arguments = args

data/boot/rbx-compiler/compiler/ast/node.rb

@@ -4,3 +4,13 @@ class Fancy
       each { |n| const_set(n, Rubinius::AST.const_get(n)) }
   end
 end
+
+class Rubinius::AST::Self
+  def method_name(receiver = nil, with_ruby_args = false)
+    if with_ruby_args
+      "self".to_sym
+    else
+      ":self".to_sym
+    end
+  end
+end

data/boot/rbx-compiler/compiler/ast/ruby_args.rb

@@ -12,6 +12,14 @@ class Fancy
           block = args.array.pop
           block = Fancy::AST::Identifier.new(block.line, block.identifier[1..-1])
         end
+
+        if @args.array.last.kind_of? Fancy::AST::Identifier
+          if @args.array.last.identifier =~ /^\*\w/
+            @splat = @args.array.pop()
+            @splat = Fancy::AST::Identifier.new(@splat.line, @splat.identifier[1..-1])
+          end
+        end
+
         @block = block
       end
 
@@ -19,6 +27,10 @@ class Fancy
         @args.array.each do |a|
           a.bytecode(g)
         end
+        if @splat
+          @splat.bytecode(g)
+          g.cast_array
+        end
         @block.bytecode(g) if @block
       end
 

data/boot/rbx-compiler/compiler/ast/singleton_method_def.rb

@@ -3,6 +3,8 @@ class Fancy
 
     class SingletonMethodDef < Rubinius::AST::DefineSingleton
       def initialize(line, obj_ident, method_ident, args, body, access = :public)
+        body = AST::ExpressionList.new(line) unless body
+
         @line = line
         @receiver = obj_ident
         @name = method_ident.method_name(@receiver)

data/boot/rbx-compiler/parser/lexer.lex

@@ -16,7 +16,7 @@ lower           [a-z]
 letter          [A-Za-z]
 special         [-+?!=*/^><%&~]
 special_under   ({special}|"_")
-operator        ({special}+|"||"{special_under}*)
+operator        ({special}+|" | "|"||"{special_under}*)
 int_lit 	[-+]?{digit}({digit}|_{digit})*
 double_lit      {int_lit}\.{digit}+
 hex_lit         0[xX]{hexdigit}+
@@ -38,22 +38,19 @@ thin_arrow      "->"
 delimiter       [ \n\r\t\(\)]
 return_local    "return_local"
 return          "return"
-require         "require:"
 try             "try"
 catch           "catch"
 finally         "finally"
 retry           "retry"
 super           "super"
-private         "private"
-protected       "protected"
 self            "self"
 match           "match"
 case            "case"
 identifier      @?@?({lower}|[_&*])({letter}|{digit}|{special_under})*
 constant        {capital}({letter}|{digit}|{special_under})*
 nested_constant ({constant}::)+{constant}
-symbol_lit      \'({identifier}|{operator}|:|"[]")+
-ruby_send_open  {identifier}{lparen}
+symbol_lit      \'({identifier}|{operator}|{constant}|:|"[]"|"|")+
+ruby_send_open  ({constant}|{identifier}){lparen}
 ruby_oper_open  {operator}{lparen}
 regexp_lit      "/".*"/"
 comma           ,
@@ -106,8 +103,8 @@ escaped_newline "\\".*\n
 {rcurly}        { return RCURLY; }
 {lbracket}      { return LBRACKET; }
 {rbracket}      { return RBRACKET; }
-{lhash}         { return LHASH; }
-{rhash}         { return RHASH; }
+{lhash}         { return LEFTHASH; }
+{rhash}         { return RIGHTHASH; }
 {stab}          { return STAB; }
 {arrow}         { return ARROW; }
 {thin_arrow}    { return THIN_ARROW; }
@@ -118,14 +115,11 @@ escaped_newline "\\".*\n
                 }
 {return_local}  { return RETURN_LOCAL; }
 {return}        { return RETURN; }
-{require}       { return REQUIRE; }
 {try}           { return TRY; }
 {catch}         { return CATCH; }
 {finally}       { return FINALLY; }
 {retry}         { return RETRY; }
 {super}         { return SUPER; }
-{private}       { return PRIVATE; }
-{protected}     { return PROTECTED; }
 {self}          {
                   yylval.object = rb_str_new2(yytext);
                   return IDENTIFIER;