fancy 0.9.0 → 0.10.0

data/lib/rbx/hash.fy

@@ -72,9 +72,15 @@ class Hash {
     """
 
     match default_value {
-      case Block -> @default_proc = true
+      case Block ->
+        @got_default_proc = true
+        @default = nil
+        @default_proc = default_value
+      case _ ->
+        @got_default_proc = false
+        @default = default_value
+        @default_proc = nil
     }
-    @default = default_value
   }
 
   def default {
@@ -82,7 +88,11 @@ class Hash {
     @return Default value for @self.
     """
 
-    @default
+    if: @got_default_proc then: {
+      @default_proc
+    } else: {
+      @default
+    }
   }
 
   def default_for: key {

data/lib/rbx/method.fy

@@ -98,6 +98,7 @@ class UnboundMethod {
   }
 
   def selector_with_args {
+    name = name to_s
     match name {
       case ":[]" -> return "[arg_0]"
       case "[]:" -> return "[arg_0]: arg_1"

data/lib/rbx/object.fy

@@ -1,10 +1,14 @@
 class Object {
-  ruby_aliases: [ '==, '===, 'class, 'inspect, 'object_id, 'instance_variables, 'methods, 'instance_variable_get, 'instance_variable_set ]
+  ruby_aliases: [ '==, '===, 'class, 'inspect, 'object_id, 'instance_variables, 'methods, 'instance_variable_get, 'instance_variable_set, 'singleton_methods ]
 
   def initialize {
     initialize()
   }
 
+  def to_a {
+    [self]
+  }
+
   def require: file_path {
     """
     Loads and evaluates a given Fancy source file by trying to find the specified

data/lib/rbx/range.fy

@@ -1,5 +1,5 @@
 class Range {
-  ruby_aliases: [ 'to_a, '==, '===, 'first, 'last ]
+  ruby_aliases: [ '==, '===, 'first, 'last ]
 
   def initialize: @start to: @end {
     """

data/lib/rbx/scopes.fy

@@ -0,0 +1,15 @@
+class Rubinius VariableScope {
+  forwards_unary_ruby_methods
+
+  def receiver {
+    @self
+  }
+
+  def receiver: recv {
+    @self = recv
+  }
+}
+
+class Rubinius ConstantScope {
+  forwards_unary_ruby_methods
+}

data/lib/rbx/symbol.fy

@@ -36,4 +36,8 @@ class Symbol {
   def to_fancy_message {
     to_s to_fancy_message to_sym
   }
+
+  def =~ regexp {
+    to_s =~ regexp
+  }
 }

data/lib/rbx/thread.fy

@@ -29,7 +29,7 @@ class Thread {
 
   Thread metaclass ruby_alias: 'abort_on_exception
   Thread metaclass ruby_alias: 'current
-  Thread metaclass ruby_alias: 'critical
+#  Thread metaclass ruby_alias: 'critical
   Thread metaclass ruby_alias: 'exit
   Thread metaclass ruby_alias: 'list
   Thread metaclass ruby_alias: 'main

data/lib/set.fy

@@ -150,6 +150,17 @@ class Set {
     @hash delete: obj
   }
 
+  def clear {
+    """
+    @return @self.
+
+    Removes all elements from @self.
+    """
+
+    @hash = <[]>
+    self
+  }
+
   def + other {
     """
     @other Other Set to use for creating union Set.

data/lib/string.fy

@@ -10,23 +10,23 @@ class String {
 
   include: Fancy Enumerable
 
-  instance_method: '== . documentation: """
-    Compares @self to another @String@ and returns @true, if equal, @false otherwise.
-  """
-
-  instance_method: 'uppercase . documentation: """
-    @return Uppercased version of @self.
-
-    Example:
-          \"hello world\" uppercase # => \"HELLO WORLD\"
-  """
-
-  instance_method: 'lowercase . documentation: """
-    @return Lowercased version of @self.
-
-    Example:
-          \"HELLO WORLD\" lowercase # => \"hello world\"
-  """
+  method_documentation: <[
+    '== => """
+      Compares @self to another @String@ and returns @true, if equal, @false otherwise.
+    """,
+    'uppercase => """
+      @return Uppercased version of @self.
+
+      Example:
+            \"hello world\" uppercase # => \"HELLO WORLD\"
+    """,
+    'lowercase => """
+      @return Lowercased version of @self.
+
+      Example:
+            \"HELLO WORLD\" lowercase # => \"hello world\"
+    """
+  ]>
 
   def ++ other {
     """

data/lib/symbol.fy

@@ -56,13 +56,17 @@ class Symbol {
   def arity {
     m = message_name to_s
     match m {
-      case /^:[a-zA-Z0-9_]+$/ -> m count: |c| { c == ":" }
-      case /^:\W+$/ -> 2
-      case _ -> m count: |c| { c == ":" } + 1
+      case /^:[a-zA-Z0-9_]+$/ -> m count: |c| { c == ":" } # unary message
+      case /^:\W+$/ -> 2 # binary operator
+      case _ -> m count: |c| { c == ":" } + 1 # multi-arg message
     }
   }
 
   def to_sym {
+    """
+    @return @self.
+    """
+
     self
   }
 

data/lib/tuple.fy

@@ -59,19 +59,14 @@ class Tuple {
     Returns sub-array starting at from: and going to to:
     """
 
-    if: (from < 0) then: {
-      from = size + from
-    }
-    if: (to < 0) then: {
-      to = size + to
-    }
+    { from = size + from } if: $ from < 0
+    { to = size + to } if: $ to < 0
     subarr = []
     try {
       from upto: to do: |i| {
         subarr << (at: i)
       }
-    } catch ObjectBoundsExceededError {
-    }
+    } catch ObjectBoundsExceededError {}
     subarr
   }
 

data/lib/version.fy

@@ -1,6 +1,6 @@
 class Fancy {
   VERSION_MAJOR = 0
-  VERSION_MINOR = 9
+  VERSION_MINOR = 10
   VERSION_PATCH = 0
 
   VERSION = [VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH] join: "."

data/ruby_lib/fancy

@@ -25,7 +25,7 @@ begin
   Fancy::CodeLoader.push_loadpath File.expand_path("../lib", base)
 
   # Load compiler+eval support
-  Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/eval", base)
+  Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/rbx/eval", base)
 
   # Run main
   Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/main", base)

data/ruby_lib/fancy.rb

@@ -12,28 +12,15 @@ bcl.load_compiled_file File.expand_path("../lib/rbx/code_loader", base)
 Fancy::CodeLoader.push_loadpath File.expand_path("../lib", base)
 
 # Load compiler+eval support
-Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/eval", base)
+Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/rbx/eval", base)
 
 class Object
-  def fancy_message_args name_and_args
-    method_name = []
-    args = []
-    name_and_args.each_with_index do |a, i|
-      if i % 2 == 0
-        method_name << a
-      else
-        args << a
-      end
-    end
-    return [method_name.join(":") + ":", args]
-  end
-
-  def fy(*array_or_name)
-    if array_or_name.size > 1
-      message_name, args = fancy_message_args array_or_name
-      self.send(message_name, *args)
+  def fy(message)
+    case message
+    when Hash
+      __send__(message.keys.join(":") << ":", *message.values)
     else
-      self.send(":#{array_or_name}")
+      __send__(":#{message}")
     end
   end
 

data/ruby_lib/interactive/hilight.rb

@@ -9,7 +9,8 @@ module CodeRay
       file_extension 'fy'
 
       SPECIAL_FORMS = %w[
-        def throw try catch class
+        self super return return_local def class
+        throw try catch finally retry match case
       ]  # :nodoc:
 
       CORE_FORMS = %w[
@@ -26,14 +27,13 @@ module CodeRay
         add(PREDEFINED_CONSTANTS, :predefined_constant)
 
       KEYWORD_NEXT_TOKEN_KIND = WordList.new(nil).
-        add(%w[ def defn defn- definline defmacro defmulti defmethod defstruct defonce declare ], :function).
-        add(%w[ ns ], :namespace).
-        add(%w[ defprotocol defrecord ], :class)
+        add(%w[ def ], :function).
+        add(%w[ class ], :class)
 
       BASIC_IDENTIFIER = /[a-zA-Z$%*\/_+!?&<>\-=]=?[a-zA-Z0-9$&*+!\/_?<>\-\#]*/
       CLASS_IDENTIFIER = /[A-Z]+[A-Za-z0-9]*|[A-Z]+[A-Za-z0-9]\:\:|\:\:[A-Z]+[A-Za-z0-9]*/
       IDENTIFIER = /(?!-\d)(?:(?:#{BASIC_IDENTIFIER}\.)*#{BASIC_IDENTIFIER}(?:\/#{BASIC_IDENTIFIER})?\.?)|\.\.?/
-      SYMBOL = /\'[A-z]+[A-z0-9\:\!\%\^\&\*\_\-\+\=\|\?\\\/\>\<\.]*/o
+      SYMBOL = /\'[A-z0-9\:\!\%\^\&\*\_\-\+\=\|\?\\\/\>\<\~\.]+/o
       DIGIT = /\d+/
       DIGIT10 = DIGIT
       DIGIT16 = /[0-9a-f]/i

data/tests/block.fy

@@ -359,26 +359,24 @@ FancySpec describe: Block with: {
     a is: [2,1,2,1]
   }
 
-  it: "calls itself while logging errors to *stdout*" with: 'call_with_errors_logged when: {
+  it: "calls itself while logging errors to *stderr*" with: 'call_with_errors_logged when: {
     io = StringIO new
-    let: '*stdout* be: io in: {
+    let: '*stderr* be: io in: {
       {
-        "hello" println
         2 / 0
       } call_with_errors_logged
     }
-    io string is: "hello\ndivided by 0\n"
+    io string is: "divided by 0\n"
   }
 
-  it: "calls itself with arguments while logging errors to *stdout*" with: 'call_with_errors_logged: when: {
+  it: "calls itself with arguments while logging errors to *stderr*" with: 'call_with_errors_logged: when: {
     io = StringIO new
-    let: '*stdout* be: io in: {
+    let: '*stderr* be: io in: {
       |x y| {
-        "x: #{x} y: #{y}" println
         2 / 0
       } call_with_errors_logged: [10, 20]
     }
-    io string is: "x: 10 y: 20\ndivided by 0\n"
+    io string is: "divided by 0\n"
   }
 
   it: "calls itself while logging errors to a given IO object" with: 'call_with_errors_logged_to: when: {
@@ -389,16 +387,41 @@ FancySpec describe: Block with: {
     io string is: "divided by 0\n"
 
     io = StringIO new
-    { "fail!" raise! } call_with_errors_logged_to: io
+    {
+      { "fail!" raise! } call_with_errors_logged_to: io
+    } does_not raise: StandardError
+    io string is: "fail!\n"
+  }
+
+  it: "calls itself while logging errors to a given IO object and reraising exceptions" with: 'call_with_errors_logged_to:reraise: when: {
+    io = StringIO new
+    {
+      {
+        "fail!" raise!
+      } call_with_errors_logged_to: io reraise: true
+    } raises: StandardError
     io string is: "fail!\n"
   }
 
   it: "calls itself with arguments while logging errors to a given IO object" with: 'call:with_errors_logged_to: when: {
     io = StringIO new
-    |x y| {
-      io println: "x: #{x} y: #{y}"
-      2 / 0
-    } call: [10, 20] with_errors_logged_to: io
+    {
+      |x y| {
+        io println: "x: #{x} y: #{y}"
+        2 / 0
+      } call: [10, 20] with_errors_logged_to: io
+    } does_not raise: ZeroDivisionError
+    io string is: "x: 10 y: 20\ndivided by 0\n"
+  }
+
+  it: "calls itself with arguments while logging errors to a given IO object and reraising exceptions" with: 'call:with_errors_logged_to:reraise: when: {
+    io = StringIO new
+    {
+      |x y| {
+        io println: "x: #{x} y: #{y}"
+        2 / 0
+      } call: [10, 20] with_errors_logged_to: io reraise: true
+    } raises: ZeroDivisionError
     io string is: "x: 10 y: 20\ndivided by 0\n"
   }
 }

data/tests/class.fy

@@ -36,6 +36,8 @@ class ClassWithPrivate {
   private: 'private_method
 }
 
+require: "stringio"
+
 FancySpec describe: Class with: {
   it: "does NOT find the method when not mixed-in" with: 'responds_to?: when: {
     instance = ClassWithMixin new
@@ -208,7 +210,8 @@ FancySpec describe: Class with: {
     Symbol superclass is: Object
     StdError superclass is: Exception
     Class superclass is: Module
-    Object superclass is: nil
+    Object superclass is: BasicObject
+    BasicObject superclass is: nil
 
     IOError superclass is: StandardError
     NoMethodError superclass is: NameError
@@ -438,7 +441,7 @@ FancySpec describe: Class with: {
     try {
       [] equal?: [1,2] . is: true # is fail
     } catch NoMethodError => e {
-      e method_name is: 'equal?:
+      e message does =~ /equal\?:/
     }
 
     class Array {
@@ -453,9 +456,9 @@ FancySpec describe: Class with: {
     class B : A
     class C : B
 
-    A ancestors is: [A, Object, Kernel]
-    B ancestors is: [B, A, Object, Kernel]
-    C ancestors is: [C, B, A, Object, Kernel]
+    A ancestors is: [A, Object, Kernel, BasicObject]
+    B ancestors is: [B, A, Object, Kernel, BasicObject]
+    C ancestors is: [C, B, A, Object, Kernel, BasicObject]
   }
 
   it: "makes methods private" with: 'private: when: {
@@ -605,7 +608,7 @@ FancySpec describe: Class with: {
   }
 
   it: "returns its nested constants" with: 'constants when: {
-    WithConstants constants =? ["Foo", "Bar", "Nested"] is: true
+    WithConstants constants =? ['Foo, 'Bar, 'Nested] is: true
   }
 
   it: "returns a constants value" with: '[] when: {
@@ -684,7 +687,8 @@ FancySpec describe: Class with: {
     Fixnum inspect is: "Fixnum : Integer"
     MySuperClass inspect is: "MySuperClass : Object"
     MySubClass inspect is: "MySubClass : MySuperClass"
-    Object inspect is: "Object"
+    Object inspect is: "Object : BasicObject"
+    BasicObject inspect is: "BasicObject"
   }
 
   it: "returns the right amount of instance methods" with: 'instance_methods: when: {
@@ -700,156 +704,156 @@ FancySpec describe: Class with: {
     Set[OneMethod instance_methods] is: $ Set[Object instance_methods + (OneMethod instance_methods: false)]
   }
 
-  it: "defines a before_method handler" with: 'before_method:run: when: {
-    class BeforeMethodClass {
-      read_slot: 'x
-      def initialize: @x
-      def before: arr {
-        arr << "Before Method: #{@x}"
-      }
-      def my_method: arr {
-        arr << "My Method: #{@x}"
-      }
+  # it: "defines a before_method handler" with: 'before_method:run: when: {
+  #   class BeforeMethodClass {
+  #     read_slot: 'x
+  #     def initialize: @x
+  #     def before: arr {
+  #       arr << "Before Method: #{@x}"
+  #     }
+  #     def my_method: arr {
+  #       arr << "My Method: #{@x}"
+  #     }
 
-      before_method: 'my_method: run: 'before:
-    }
+  #     before_method: 'my_method: run: 'before:
+  #   }
 
-    b1 = BeforeMethodClass new: 1
-    b2 = BeforeMethodClass new: 2
+  #   b1 = BeforeMethodClass new: 1
+  #   b2 = BeforeMethodClass new: 2
 
-    array = []
+  #   array = []
 
-    b1 my_method: array
-    b2 my_method: array
+  #   b1 my_method: array
+  #   b2 my_method: array
 
-    array is: [
-      "Before Method: 1", "My Method: 1",
-      "Before Method: 2", "My Method: 2"
-    ]
+  #   array is: [
+  #     "Before Method: 1", "My Method: 1",
+  #     "Before Method: 2", "My Method: 2"
+  #   ]
 
-    # we can also pass blocks
+  #   # we can also pass blocks
 
-    BeforeMethodClass before_method: 'my_method: run: |receiver array| {
-      array << "Before Block: #{receiver x}"
-    }
+  #   BeforeMethodClass before_method: 'my_method: run: |receiver array| {
+  #     array << "Before Block: #{receiver x}"
+  #   }
 
-    array = []
+  #   array = []
 
-    b1 my_method: array
-    b2 my_method: array
+  #   b1 my_method: array
+  #   b2 my_method: array
 
-    array is: [
-      "Before Block: 1", "Before Method: 1", "My Method: 1",
-      "Before Block: 2", "Before Method: 2", "My Method: 2"
-    ]
-  }
+  #   array is: [
+  #     "Before Block: 1", "Before Method: 1", "My Method: 1",
+  #     "Before Block: 2", "Before Method: 2", "My Method: 2"
+  #   ]
+  # }
 
-  it: "defines an after_method handler" with: 'after_method:run: when: {
-    class AfterMethodClass {
-      read_slot: 'x
-      def initialize: @x
-      def after: arr {
-        arr << "After Method: #{@x}"
-      }
-      def my_method: arr {
-        arr << "My Method: #{@x}"
-      }
+  # it: "defines an after_method handler" with: 'after_method:run: when: {
+  #   class AfterMethodClass {
+  #     read_slot: 'x
+  #     def initialize: @x
+  #     def after: arr {
+  #       arr << "After Method: #{@x}"
+  #     }
+  #     def my_method: arr {
+  #       arr << "My Method: #{@x}"
+  #     }
 
-      after_method: 'my_method: run: 'after:
-    }
+  #     after_method: 'my_method: run: 'after:
+  #   }
 
-    b1 = AfterMethodClass new: 1
-    b2 = AfterMethodClass new: 2
+  #   b1 = AfterMethodClass new: 1
+  #   b2 = AfterMethodClass new: 2
 
-    array = []
+  #   array = []
 
-    b1 my_method: array
-    b2 my_method: array
+  #   b1 my_method: array
+  #   b2 my_method: array
 
-    array is: [
-      "My Method: 1", "After Method: 1",
-      "My Method: 2", "After Method: 2"
-    ]
+  #   array is: [
+  #     "My Method: 1", "After Method: 1",
+  #     "My Method: 2", "After Method: 2"
+  #   ]
 
-    AfterMethodClass after_method: 'my_method: run: |receiver array| {
-      "block getting called yo"
-      array << "After Block: #{receiver x}"
-    }
+  #   AfterMethodClass after_method: 'my_method: run: |receiver array| {
+  #     "block getting called yo"
+  #     array << "After Block: #{receiver x}"
+  #   }
 
-    array = []
+  #   array = []
 
-    b1 my_method: array
-    b2 my_method: array
+  #   b1 my_method: array
+  #   b2 my_method: array
 
-    array is: [
-      "My Method: 1", "After Method: 1", "After Block: 1",
-      "My Method: 2", "After Method: 2", "After Block: 2"
-    ]
-  }
+  #   array is: [
+  #     "My Method: 1", "After Method: 1", "After Block: 1",
+  #     "My Method: 2", "After Method: 2", "After Block: 2"
+  #   ]
+  # }
 
 
-  it: "defines an around_method handler" with: 'around_method:run: when: {
-    class AroundMethodClass {
-      read_slot: 'x
-      def initialize: @x
-      def around: arr {
-        arr << "Around Method: #{@x}"
-      }
-      def my_method: arr {
-        arr << "My Method: #{@x}"
-      }
+  # it: "defines an around_method handler" with: 'around_method:run: when: {
+  #   class AroundMethodClass {
+  #     read_slot: 'x
+  #     def initialize: @x
+  #     def around: arr {
+  #       arr << "Around Method: #{@x}"
+  #     }
+  #     def my_method: arr {
+  #       arr << "My Method: #{@x}"
+  #     }
 
-      around_method: 'my_method: run: 'around:
-    }
+  #     around_method: 'my_method: run: 'around:
+  #   }
 
-    b1 = AroundMethodClass new: 1
-    b2 = AroundMethodClass new: 2
+  #   b1 = AroundMethodClass new: 1
+  #   b2 = AroundMethodClass new: 2
 
-    array = []
+  #   array = []
 
-    b1 my_method: array
-    b2 my_method: array
+  #   b1 my_method: array
+  #   b2 my_method: array
 
-    array is: [
-      "Around Method: 1", "My Method: 1", "Around Method: 1",
-      "Around Method: 2", "My Method: 2", "Around Method: 2"
-    ]
+  #   array is: [
+  #     "Around Method: 1", "My Method: 1", "Around Method: 1",
+  #     "Around Method: 2", "My Method: 2", "Around Method: 2"
+  #   ]
 
 
-    AroundMethodClass around_method: 'my_method: run: |receiver array| {
-      array << "Around Block: #{receiver x}"
-    }
+  #   AroundMethodClass around_method: 'my_method: run: |receiver array| {
+  #     array << "Around Block: #{receiver x}"
+  #   }
 
-    array = []
+  #   array = []
 
-    b1 my_method: array
-    b2 my_method: array
+  #   b1 my_method: array
+  #   b2 my_method: array
 
-    array is: [
-      "Around Block: 1", "Around Method: 1", "My Method: 1", "Around Method: 1", "Around Block: 1",
-      "Around Block: 2", "Around Method: 2", "My Method: 2", "Around Method: 2", "Around Block: 2"
-    ]
-  }
+  #   array is: [
+  #     "Around Block: 1", "Around Method: 1", "My Method: 1", "Around Method: 1", "Around Block: 1",
+  #     "Around Block: 2", "Around Method: 2", "My Method: 2", "Around Method: 2", "Around Block: 2"
+  #   ]
+  # }
 
-  it: "defines a custom calling chain for a method" with: 'define_calling_chain:for_method: when: {
-    class CallingChainClass {
-      def foo: arr { arr << "foo" }
-      def bar: arr { arr << "bar" }
-      def baz: arr { arr << "baz" }
+  # it: "defines a custom calling chain for a method" with: 'define_calling_chain:for_method: when: {
+  #   class CallingChainClass {
+  #     def foo: arr { arr << "foo" }
+  #     def bar: arr { arr << "bar" }
+  #     def baz: arr { arr << "baz" }
 
-      define_calling_chain: ('foo:, 'bar:, 'baz:) for_method: 'foo:
-    }
+  #     define_calling_chain: ('foo:, 'bar:, 'baz:) for_method: 'foo:
+  #   }
 
-    arr = []
-    CallingChainClass new foo: arr
-    arr is: ["foo", "bar", "baz"]
+  #   arr = []
+  #   CallingChainClass new foo: arr
+  #   arr is: ["foo", "bar", "baz"]
 
-    CallingChainClass define_calling_chain: [|receiver arr|{ receiver baz: arr }, 'bar:] for_method: 'bar:
+  #   CallingChainClass define_calling_chain: [|receiver arr|{ receiver baz: arr }, 'bar:] for_method: 'bar:
 
-    arr = []
-    CallingChainClass new bar: arr
-    arr is: ["baz", "bar"]
-  }
+  #   arr = []
+  #   CallingChainClass new bar: arr
+  #   arr is: ["baz", "bar"]
+  # }
 
   it: "exposes a Fancy method as a Ruby method to Ruby" with: 'expose_to_ruby:as: when: {
     class ExposeToRuby {