fancy 0.3.0 → 0.3.1

data/lib/rbx/symbol.fy

@@ -3,7 +3,7 @@ class Symbol {
     binding = Binding setup(Rubinius VariableScope of_sender(),
                             Rubinius CompiledMethod of_sender(),
                             Rubinius StaticScope of_sender())
-    Fancy eval: (self to_s) binding: binding
+    Fancy eval: to_s binding: binding
   }
 
   def inspect {

data/lib/rbx/system.fy

@@ -28,10 +28,4 @@ class System {
 
     IO popen(command_str)
   }
-
-  def System sleep: n_ms {
-    "Sets the Fancy process for a given amount of milliseconds to sleep."
-
-    Kernel sleep(n_ms / 1000)
-  }
 }

data/lib/rbx/thread.fy

@@ -72,4 +72,9 @@ class Thread {
     start(&block)
   }
 
+  def Thread sleep: seconds {
+    "Sets the Fancy process for a given amount of seconds to sleep."
+
+    Kernel sleep(seconds)
+  }
 }

data/lib/rbx/time.fy

@@ -0,0 +1,14 @@
+class Time {
+  metaclass ruby_alias: 'now
+  ruby_alias: '==
+  ruby_alias: '-
+  ruby_alias: '+
+  ruby_alias: '>
+  ruby_alias: '<
+  ruby_alias: '>=
+  ruby_alias: '<=
+
+  def != other {
+    self == other not
+  }
+}

data/lib/rbx/tuple.fy

@@ -1,6 +1,7 @@
 Tuple = Rubinius Tuple
 class Tuple {
   ruby_alias: 'size
+  ruby_alias: 'to_a
 
   def initialize: size {
     """

data/lib/set.fy

@@ -56,6 +56,6 @@ class Set {
 
   def inspect {
     "Returns a detailed String representation of a Set."
-    self to_s ++ " : Set"
+    to_s ++ " : Set"
   }
 }

data/lib/stack.fy

@@ -28,7 +28,7 @@ class Stack {
   def pop {
     "Pops the top-of-stack element from the Stack and returns it."
 
-    @arr remove_at: (self size - 1)
+    @arr remove_at: (size - 1)
   }
 
   def top {

data/lib/string.fy

@@ -19,7 +19,7 @@ class String {
   def whitespace? {
     "Indicates, if a String is empty or a single whitespace character."
 
-    self empty? or: (self == " ")
+    empty? or: (self == " ")
   }
 
   def blank? {
@@ -43,7 +43,7 @@ class String {
   }
 
   def words {
-    self split
+    split
   }
 
   def raise! {

data/lib/thread_pool.fy

@@ -0,0 +1,101 @@
+# This ThreadPool class is adapted from the Ruby code at:
+# https://github.com/fizx/thread_pool/
+
+class ThreadPool {
+  class Executor {
+    read_slot: 'active
+
+    def initialize: queue mutex: mutex {
+      @thread = Thread new: {
+        loop: {
+          mutex synchronize() { @tuple = queue shift() }
+          if: @tuple then: {
+            args, block = @tuple
+            @active = true
+            val = nil
+            try {
+              val = block call: args
+            } catch Exception => e {
+              e message println
+              e backtrace() join: "\n" . println
+            }
+            block complete: true
+            block completed_value: val
+          } else: {
+            @active = false
+            Thread sleep: 0.1
+          }
+        }
+      }
+    }
+
+    def close {
+      @thread exit
+    }
+  }
+
+  read_write_slot: 'queue_limit
+
+  # Initialize with number of threads to run
+  def initialize: @count limit: @queue_limit (0) {
+    @mutex = Mutex new()
+    @executors = []
+    @queue = []
+    @count times: { @executors << (Executor new: @queue mutex: @mutex) }
+  }
+
+  # Runs the block at some time in the near future
+  def execute: block with_args: args ([]) {
+    init_completable: block
+
+    if: (@queue_limit > 0) then: {
+      { Thread sleep: 0.1 } until: { @queue size < @queue_limit }
+    }
+
+    @mutex synchronize() {
+      @queue << [args, block]
+    }
+  }
+
+  # Runs the block at some time in the near future, and blocks until complete
+  def execute_synchronous: block with_args: args ([]) {
+    execute: block with_args: args
+    { Thread sleep: 0.1 } until: { block complete? }
+    block completed_value
+  }
+
+  # Size of the task queue
+  def waiting {
+    @queue size
+  }
+
+  # Size of the thread pool
+  def size {
+    @count
+  }
+
+  # Kills all threads
+  def close {
+    @executors each: |e| { e close }
+  }
+
+  # Sleeps and blocks until the task queue is finished executing
+  def join {
+    { Thread sleep: 0.1 } until: { { @queue empty? } && { @executors all?: |e| { e active not } } }
+  }
+
+  class Completable {
+    read_write_slot: 'completed_value
+    def complete: @complete {
+    }
+
+    def complete? {
+      @complete not not
+    }
+  }
+
+  def protected init_completable: block {
+    block extend(Completable)
+    block complete: false
+  }
+}

data/lib/tuple.fy

@@ -8,16 +8,45 @@ class Tuple {
 
   def [] idx {
     """
-    Forwards to @Tuple#at:@.
+    Forwards to @Tuple@#at:.
     """
 
     at: idx
   }
 
+  def first {
+    "Returns the first element in the @Tuple@."
+    at: 0
+  }
+
+  def second {
+    "Returns the second element in the @Tuple@."
+    at: 1
+  }
+
+  def third {
+    "Returns the third element in the @Tuple@."
+    at: 2
+  }
+
+  def fourth {
+    "Returns the fourth element in the @Tuple@"
+    at: 3
+  }
+
   def each: block {
-    self size times: |i| {
-      block call: [self at: i]
+    """
+    @block @Block@ to be called for each element in @self.
+    @return Return value of calling @block on the last item in @self.
+
+    Calls a given @Block@ with each element in the @Tuple@.
+    """
+
+    val = nil
+    size times: |i| {
+      val = block call: [at: i]
     }
+    val
   }
 
   def == other {
@@ -29,8 +58,8 @@ class Tuple {
     """
 
     if: (other is_a?: Tuple) then: {
-      if: (self size == (other size)) then: {
-        self size times: |i| {
+      if: (size == (other size)) then: {
+        size times: |i| {
           unless: (self[i] == (other[i])) do: {
             return false
           }
@@ -42,8 +71,10 @@ class Tuple {
   }
 
   def inspect {
+    "Returns a @String@ representation of a @Tuple@"
+
     str = "("
-    self each: |v| {
+    each: |v| {
       str = str ++ v
     } in_between: {
       str = str ++ ", "

data/ruby_lib/fancy.rb

@@ -0,0 +1,46 @@
+base = File.dirname(__FILE__)
+require File.expand_path("../boot/fancy_ext", base)
+require File.expand_path("../boot/load", base)
+
+do_retry = true
+begin
+  Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/boot", base)
+rescue RuntimeError => e
+  # need to bootstrap first time
+  if e.message =~ /File not found (.*)lib\/boot.fyc/
+    if do_retry
+      puts "Fancy hasn't been bootstrapped yet. Doing that now.\n\n"
+      `cd #{base}/../ && rbx -S rake clean && rbx -S rake`
+      do_retry = false
+      retry
+    else
+      raise e
+    end
+  else
+    raise e
+  end
+end
+
+# Remove the bootstrapping code loader
+bcl = Fancy.send :remove_const, :CodeLoader
+bcl.load_compiled_file File.expand_path("../lib/rbx/code_loader", base)
+
+# Initialize the load path
+Fancy::CodeLoader.push_loadpath File.expand_path("../lib", base)
+
+# Load compiler+eval support
+Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/eval", base)
+
+class Object
+  def fy(hash_or_name)
+    if hash_or_name.is_a? Hash
+      self.send("#{hash_or_name.keys.join(':')}:", *hash_or_name.values)
+    else
+      self.send(":#{hash_or_name}")
+    end
+  end
+
+  def fancy_require(fancy_file)
+    Fancy::CodeLoader.load_compiled_file fancy_file
+  end
+end

data/tests/block.fy

@@ -57,6 +57,18 @@ FancySpec describe: Block with: {
     }
   }
 
+  it: "should call another block while a block yields false" for: 'until_do: when: {
+    i = 0
+    { i > 10 } until_do: { i <= 10 should == true; i = i + 1 }
+    i should == 11
+  }
+
+  it: "should call a block until another yields true" for: 'until: when: {
+    i = 0
+    { i <= 10 should == true; i = i + 1 } until: { i > 10 }
+    i should == 11
+  }
+
   it: "should call itself only when the argument is nil" for: 'unless: when: {
     try {
       { StdError new: "got_run!" . raise! } unless: nil
@@ -100,4 +112,31 @@ FancySpec describe: Block with: {
     [1,2,3] map: @{to_s} . should == ["1", "2", "3"]
     [1,2,3] map: @{to_s * 3} . should == ["111", "222", "333"]
   }
+
+  it: "should execute a match clause if the block returns a true-ish value" for: '=== when: {
+    def do_match: val {
+      match val {
+        case |x| { x even? } -> "yup, it's even"
+        case _ -> "nope, not even"
+      }
+    }
+    do_match: 2 . should == "yup, it's even"
+    do_match: 1 . should == "nope, not even"
+  }
+
+  it: "should return the receiver of a block" for: 'receiver when: {
+    class Foo { def foo { { self } } } # return block
+    f = Foo new
+    f foo receiver should == f
+  }
+
+  it: "should set the receiver correctly to a new value" for: 'receiver: when: {
+    b = { "hey" }
+
+    b receiver: 10
+    b receiver should == 10
+
+    b receiver: "Hello, World!"
+    b receiver should == "Hello, World!"
+  }
 }

data/tests/class.fy

@@ -64,7 +64,7 @@ FancySpec describe: Class with: {
     instance normal_method should == 'new_normal_found
   }
 
-  it: "should have dynamically generated getter methods" for: 'responds_to?: when: {
+  it: "should have dynamically generated getter and setter methods" for: 'responds_to?: when: {
     instance = ClassWithNoMixin new
     instance responds_to?: 'foo . should == true
     instance responds_to?: 'bar . should == true
@@ -77,6 +77,45 @@ FancySpec describe: Class with: {
     instance responds_to?: "noes:" . should == true
   }
 
+  it: "should define getter methods for single slots" for: 'read_slot: when: {
+    class Getters {
+      read_slot: 'foo
+      read_slot: 'bar
+    }
+
+    g = Getters new
+    g responds_to?: 'foo . should == true
+    g responds_to?: 'foo: . should == false
+    g responds_to?: 'bar . should == true
+    g responds_to?: 'bar: . should == false
+  }
+
+  it: "should define setter methods for single slots" for: 'write_slot: when: {
+    class Setters {
+      write_slot: 'foo
+      write_slot: 'bar
+    }
+
+    s = Setters new
+    s responds_to?: 'foo . should == false
+    s responds_to?: 'foo: . should == true
+    s responds_to?: 'bar . should == false
+    s responds_to?: 'bar: . should == true
+  }
+
+  it: "should define getter & setter methods for single slots" for: 'read_write_slot: when: {
+    class GettersAndSetters {
+      read_write_slot: 'foo
+      read_write_slot: 'bar
+    }
+
+    gs = GettersAndSetters new
+    gs responds_to?: 'foo . should == true
+    gs responds_to?: 'foo: . should == true
+    gs responds_to?: 'bar . should == true
+    gs responds_to?: 'bar: . should == true
+  }
+
   it: "should find the instance variable correctly" when: {
     class AClass {
       def initialize: foo {

data/tests/file.fy

@@ -1,12 +1,12 @@
 FancySpec describe: File with: {
   it: "should return an array with the openmodes symbols" for: 'open:modes: when: {
-    file = File open: "README" modes: ['read]
+    file = File open: "README.md" modes: ['read]
     file modes should == ['read]
     file close
   }
 
   it: "should be open after opening it and closed after closing" for: 'close when: {
-    file = File open: "README" modes: ['read]
+    file = File open: "README.md" modes: ['read]
     file open? should == true
     file close
     file open? should == false

data/tests/hash.fy

@@ -52,6 +52,12 @@ FancySpec describe: Hash with: {
     hash['foobar] should == 112.21
   }
 
+  it: "should return nil if the key isn't defined" for: '[] when: {
+    <['foo => "bar"]> ['bar] . should == nil
+    <[]> ['foobar] . should == nil
+    <['foo => "bar"]> [nil] . should == nil
+  }
+
   it: "should call the Block for each key and value" for: 'each: when: {
     hash = <['foo => "bar", 'bar => "baz", 'foobar => 112.21]>
     hash each: |key val| {
@@ -89,13 +95,7 @@ FancySpec describe: Hash with: {
       map: 'second . should == ["is cool"]
   }
 
-  it: "should return nil if the key isn't defined" when: {
-    <['foo => "bar"]> ['bar] . should == nil
-    <[]> ['foobar] . should == nil
-    <['foo => "bar"]> [nil] . should == nil
-  }
-
-  it: "should return an Array of the key-value pairs" when: {
+  it: "should return an Array of the key-value pairs" for: 'to_a when: {
     <['foo => "bar", 'bar => "baz"]> to_a should =? [['foo, "bar"], ['bar, "baz"]]
   }
 }