fancy 0.4.0 → 0.5.0

data/lib/rbx/fixnum.fy

@@ -7,22 +7,10 @@ class Fixnum {
 
   include: Number
 
-  ruby_alias: '==
-  ruby_alias: '-
-  ruby_alias: '+
-  ruby_alias: '*
-  ruby_alias: '/
-  ruby_alias: '<
-  ruby_alias: '>
-  ruby_alias: '<=
-  ruby_alias: '>=
-  ruby_alias: '===
-  ruby_alias: 'chr
-  ruby_alias: 'to_i
-  ruby_alias: 'to_f
-  ruby_alias: '**
-  ruby_alias: '&
-  ruby_alias: '|
+  ruby_aliases: [
+    '==, '-, '+, '*, '/, '<, '>, '<=, '>=,
+    '===, 'chr, 'to_i, 'to_f, '**, '&, '|
+  ]
 
   alias_method: 'to_s: for: 'to_s
   alias_method: 'modulo: for: 'modulo

data/lib/rbx/float.fy

@@ -7,16 +7,7 @@ class Float {
 
   forwards_unary_ruby_methods
 
-  ruby_alias: '+
-  ruby_alias: '-
-  ruby_alias: '*
-  ruby_alias: '/
-  ruby_alias: '==
-  ruby_alias: '>=
-  ruby_alias: '<=
-  ruby_alias: '**
-  ruby_alias: '<
-  ruby_alias: '>
+  ruby_aliases: [ '+, '-, '*, '/, '==, '<, '>, '<=, '>=, '**]
 
   alias_method: 'modulo: for: 'modulo
   alias_method: ":%" for: "modulo:" # use a : so we dont overwrite ruby's % operator

data/lib/rbx/integer.fy

@@ -2,7 +2,19 @@ class Integer {
   # common ruby-forwarding methods used by Fixnum & Bignum classes
 
   def times: block {
-    # this version gets replaced in lib/integer.fy with a native one
-    times(&block)
+    """
+    @block @Block@ to be called with each number between 0 and @self.
+    @return @self
+
+    Calls a given @Block@ with each number between 0 and @self.
+    """
+
+    try {
+      times(&block)
+    } catch Fancy BreakIteration => b {
+      return b result
+    } catch Fancy StopIteration => s {
+      return s result
+    }
   }
 }

data/lib/rbx/io.fy

@@ -30,11 +30,7 @@ class IO {
 
   include: IOMixin
 
-  ruby_alias: 'readlines
-  ruby_alias: 'readline
-  ruby_alias: 'read
-  ruby_alias: 'close
-  ruby_alias: 'eof?
+  ruby_aliases: [ 'readlines, 'readline, 'read, 'close, 'eof? ]
 
   forwards_unary_ruby_methods
 }

data/lib/rbx/mutex.fy

@@ -0,0 +1,30 @@
+class Mutex {
+  forwards_unary_ruby_methods
+
+  def initialize {
+    initialize()
+  }
+
+  def synchronize: block {
+    synchronize(&block)
+  }
+}
+
+class ConditionVariable {
+  forwards_unary_ruby_methods
+  def initialize {
+    initialize()
+  }
+
+  def wait: mutex {
+    wait(mutex)
+  }
+
+  def signal {
+    signal()
+  }
+
+  def broadcast {
+    broadcast()
+  }
+}

data/lib/rbx/object.fy

@@ -1,10 +1,5 @@
 class Object {
-  ruby_alias: '==
-  ruby_alias: '===
-  ruby_alias: 'class
-  ruby_alias: 'inspect
-  ruby_alias: 'object_id
-  ruby_alias: 'instance_variables
+  ruby_aliases: [ '==, '===, 'class, 'inspect, 'object_id, 'instance_variables ]
 
   def initialize {
     initialize()
@@ -118,11 +113,10 @@ class Object {
 
   def message_name: symbol {
     symbol = symbol to_s
-    match symbol =~ /:/ {
-      case nil ->
-        ":" ++ symbol
-      case _ ->
-        symbol
+    val = symbol include?(":")
+    match val {
+      case true -> symbol
+      case false -> ":" <<(symbol)
     }
   }
 

data/lib/rbx/process.fy

@@ -0,0 +1,13 @@
+RbxProcess = Process
+
+class send('remove_const, 'Process)
+
+class Process {
+  include: RbxProcess
+  metaclass include: (RbxProcess metaclass)
+  forwards_unary_ruby_methods
+  metaclass forwards_unary_ruby_methods
+}
+
+Process pid println
+Process instance_methods sort println

data/lib/rbx/range.fy

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

data/lib/rbx/string.fy

@@ -1,17 +1,10 @@
 class String {
 
   # prepend a : to fancy version of ruby methods.
-  ruby_alias: '==
-  ruby_alias: 'upcase
-  ruby_alias: 'downcase
-  ruby_alias: '=~
-  ruby_alias: 'to_i
-  ruby_alias: 'to_f
-  ruby_alias: 'chomp
-  ruby_alias: 'inspect
-  ruby_alias: 'to_sym
-  ruby_alias: '<
-  ruby_alias: '>
+  ruby_aliases: [
+    '==, 'upcase, 'downcase, '=~, 'to_i, 'to_f,
+    'chomp, 'inspect, 'to_sym, '<, '>
+  ]
 
   alias_method: '[]: for_ruby: '[]=
   alias_method: 'scan: for_ruby: 'scan

data/lib/rbx/thread.fy

@@ -35,6 +35,15 @@ class Thread {
   Thread metaclass ruby_alias: 'main
   Thread metaclass ruby_alias: 'pass
   Thread metaclass ruby_alias: 'stop
+  ruby_alias: 'dynamic_vars
+
+  def [dynamic_var_name] {
+    send('[], dynamic_var_name)
+  }
+
+  def [dynamic_var_name]: value {
+    send('[]=, dynamic_var_name, value)
+  }
 
   def priority: new_prio {
     priority=(new_prio)

data/lib/rbx/time.fy

@@ -6,13 +6,7 @@ class Time {
   forwards_unary_ruby_methods
 
   metaclass ruby_alias: 'now
-  ruby_alias: '==
-  ruby_alias: '-
-  ruby_alias: '+
-  ruby_alias: '>
-  ruby_alias: '<
-  ruby_alias: '>=
-  ruby_alias: '<=
+  ruby_aliases: [ '==, '-, '+, '<, '>, '<=, '>= ]
 
   def != other {
     self == other not

data/lib/stack.fy

@@ -77,6 +77,6 @@ class Stack {
     Calls a given @Block@ with each element in @self, starting with the top of stack element.
     """
 
-    @arr reverse each: block
+    @arr reverse_each: block
   }
 }

data/lib/string.fy

@@ -16,7 +16,7 @@ class String {
     @return Concatenation of @self with @other.
 
     Concatenate @self with another Object's @String@ representation.
-        \"foo\” ++ 42 # => \”foo42\”
+          \"foo\” ++ 42 # => \”foo42\”
     """
 
     self + (other to_s)
@@ -52,7 +52,7 @@ class String {
     @return @String@ that is the num-fold concatenation of @self.
 
     Returns a @String@ that is the num-fold concatenation of itself.
-        \"foo\" * 3 # => \”foofoofoo\"
+          \"foo\" * 3 # => \”foofoofoo\"
     """
 
     str = ""
@@ -66,7 +66,7 @@ class String {
     """
     @return @Array@ of all the whitespace seperated words in @self.
 
-        \"hello world\" words  # => [\"hello\", \"world\"]
+          \"hello world\" words  # => [\"hello\", \"world\"]
     """
 
     split
@@ -85,7 +85,7 @@ class String {
     @return @String@ containing all but the first character.
 
     Returns a @String@ containing all but the first character.
-        \"hello\" rest # => \"ello\"
+          \"hello\" rest # => \"ello\"
     """
 
     from: 1 to: -1
@@ -108,11 +108,11 @@ class String {
 
     Appends @object's @String@ representation to @self.
 
-    Example usage:
-        str = \"hello\"
-        str << \" \"
-        str << 42
-        str # => \"hello 42\"
+    Example:
+          str = \"hello\"
+          str << \" \"
+          str << 42
+          str # => \"hello 42\"
     """
 
     append: $ object to_s

data/lib/symbol.fy

@@ -10,7 +10,8 @@ class Symbol {
     """
     This allows Symbols to be used like Blocks
     (e.g. in all methods of Enumerable).
-    Example: [1, 2, 3] map: 'squared # => [1, 4, 9]
+    Example:
+          [1, 2, 3] map: 'squared # => [1, 4, 9]
     """
 
     if: (arg is_a?: Array) then: {
@@ -24,13 +25,13 @@ class Symbol {
     """
     Sends @self as message to the sender in its context.
     Example:
-        'foo call
-         # => same as
-         self foo
+          'foo call
+           # => same as
+           self foo
 
-         if: x then: 'foo else: 'bar
-         # same as:
-         if: x then: { self foo } else: { self bar }
+           if: x then: 'foo else: 'bar
+           # same as:
+           if: x then: { self foo } else: { self bar }
     """
 
     binding = Binding setup(Rubinius VariableScope of_sender(),
@@ -39,4 +40,8 @@ class Symbol {
     recv = binding self()
     recv receive_message: self
   }
+
+  def arity {
+    1
+  }
 }

data/lib/tuple.fy

@@ -54,11 +54,26 @@ class Tuple {
     Calls a given @Block@ with each element in the @Tuple@.
     """
 
-    val = nil
     size times: |i| {
-      val = block call: [at: i]
+      block call: [at: i]
     }
-    val
+    self
+  }
+
+  def reverse_each: block {
+    """
+    @block @Block@ to be called for each element (in reverse order).
+    @return @self.
+
+    Example:
+          (1,2,3) reverse_each: @{print}
+          # prints: 321
+    """
+
+    size - 1 downto: 0 do: |i| {
+      block call: [at: i]
+    }
+    self
   }
 
   def == other {

data/lib/vars.fy

@@ -0,0 +1,3 @@
+*stdin* = STDIN
+*stdout* = STDOUT
+*stderr* = STDERR

data/ruby_lib/fspec

@@ -1,3 +1,3 @@
-#!/usr/bin/env rbx
+#!/usr/bin/env ruby
 base = File.expand_path("../bin", File.dirname(__FILE__))
-system("/usr/bin/env fancy #{base}/fspec #{ARGV.join(' ')}")
+system("/usr/bin/env fancy #{base}/fspec #{ARGV.join(' ')}")

data/ruby_lib/fyi

@@ -1,3 +1,3 @@
-#!/usr/bin/env rbx
+#!/usr/bin/env ruby
 base = File.expand_path("../bin", File.dirname(__FILE__))
-system("/usr/bin/env fancy #{base}/fyi #{ARGV.join(' ')}")
+system("/usr/bin/env fancy #{base}/fyi #{ARGV.join(' ')}")

data/ruby_lib/ifancy

@@ -1,3 +1,3 @@
-#!/usr/bin/env rbx
+#!/usr/bin/env ruby
 base = File.expand_path("../bin", File.dirname(__FILE__))
-system("/usr/bin/env fancy #{base}/ifancy #{ARGV.join(' ')}")
+system("/usr/bin/env fancy #{base}/ifancy #{ARGV.join(' ')}")

data/tests/array.fy

@@ -388,7 +388,31 @@ FancySpec describe: Array with: {
     a is: []
   }
 
-  it: "appends a value at the front" with: 'unshift: when: {
+  it: "appends another Array onto self" with: 'append: when: {
+    a = [1,2,3]
+    a append: [4,5,6] . is: a
+    a is: [1,2,3,4,5,6]
+
+    a append: []
+    a is: [1,2,3,4,5,6]
+
+    [] append: [] . is: []
+    [] append: (1,2,3) . is: [1,2,3] # works with any Enumerable
+  }
+
+  it: "prepends another Array onto self" with: 'prepend: when: {
+    a = [1,2,3]
+    a prepend: [4,5,6]
+    a is: [4,5,6,1,2,3]
+
+    a prepend: []
+    a is: [4,5,6,1,2,3]
+
+    [] prepend: [] . is: []
+    [] prepend: (1,2,3) . is: [1,2,3] # works with any Enumerable
+  }
+
+  it: "prepends a value at the front" with: 'unshift: when: {
     a = []
     a unshift: 1 . is: a # is return self
     a is: [1]

data/tests/assignment.fy

@@ -50,4 +50,59 @@ FancySpec describe: "Assignment" with: {
     _,_,*z = "hello, world!" # ignore first 2 characters
     z is: "llo, world!"
   }
+
+  it: "sets dynamic vars accordingly" when: {
+    let: '*foo* be: 10 in: {
+      *foo* is: 10
+    }
+  }
+
+  it: "sets a dynamic var with proper nesting" when: {
+    def use_foo: expected {
+      *foo* is: expected
+    }
+
+    def use_nested_foo: expected {
+      use_foo: expected
+      let: '*foo* be: -10 in: {
+        use_foo: -10
+      }
+    }
+
+    let: '*foo* be: 10 in: {
+      *foo* is: 10
+      use_foo: 10
+      use_nested_foo: 10
+      let: '*foo* be: 100 in: {
+        *foo* is: 100
+        use_foo: 100
+        use_nested_foo: 100
+      }
+    }
+  }
+
+  it: "allows assigning dynamic vars without a scope" when: {
+    *foo* = "hello, world"
+    *foo* is: "hello, world"
+    let: '*foo* be: "byebye, world" in: {
+      *foo* is: "byebye, world"
+      use_foo: "byebye, world"
+      use_nested_foo: "byebye, world"
+    }
+    *foo* is: "hello, world"
+    use_foo: "hello, world"
+    use_nested_foo: "hello, world"
+    *foo* = nil
+    *foo* is: nil
+    use_foo: nil
+    use_nested_foo: nil
+  }
+
+  it: "preserves the current value of a dynvar when creating a new thread" when: {
+    *foo* = 100
+    *foo* is: 100
+    Thread new: {
+      *foo* is: 100
+    } . join
+  }
 }