fancy 0.7.0 → 0.8.0

data/lib/file.fy

@@ -15,6 +15,17 @@ class File {
     File open: filename modes: ['write] with: block
   }
 
+  def File append: filename with: block {
+    """
+    @filename Filename of @File@ to append to.
+    @block @Block@ called with a @File@ object to append to.
+
+    Opens a @File@ for appending and calls @block with it.
+    """
+
+    File open: filename modes: ['append] with: block
+  }
+
   def File read: filename with: block {
     """
     @filename Filename of @File@ to read from.
@@ -38,6 +49,14 @@ class File {
   }
 
   def File read_binary: filename {
+    """
+    @filename Filename of @File@ to read from.
+    @return @String@ that is the binary data in @filename.
+
+    Opens and reads the contents of a @File@ in binary mode and
+    returns its binary contents as a @String@.
+    """
+
     content = nil
     File read_binary: filename with: |f| {
       content = f read

data/lib/future.fy

@@ -1,6 +1,6 @@
 class FutureSend {
   """
-  A @FutureSend@ gets created whenever an asynchronous message via the @@ operator gets sent, yielding a @FutureSend@.
+  A @FutureSend@ gets created whenever an asynchronous message via the @ operator gets sent, yielding a @FutureSend@.
   They represent Futures/Promises in Fancy.
 
   Example:
@@ -41,13 +41,13 @@ class FutureSend {
     if: @failed then: {
       try {
         @fail_continuations each: @{ call: [@fail_reason] }
-      } catch Exception => ex {
+      } catch StandardError => ex {
         *stderr* println: "Error in FutureSend#completed! while calling fail continuations: #{ex}"
       }
     } else: {
       try {
         @continuations each: @{ call: [@value] }
-      } catch Exception => ex {
+      } catch StandardError => ex {
         *stderr* println: "Error in FutureSend#completed! while calling success continuations: #{ex}"
       }
     }
@@ -185,52 +185,10 @@ class FutureSend {
   }
 }
 
-class PooledFuture {
-  @@thread_pool = nil
-  @@pool_size = 10
-  WaitInterval = 0.1
-
-  def PooledFuture pool: n {
-    @@pool_size = match n {
-      case 0 -> 10
-      case _ -> n
-    }
-  }
-
-  def PooledFuture join! {
-    @@thread_pool join
-  }
-
-  def initialize: @block {
-    { @@thread_pool = ThreadPool new: @@pool_size } unless: @@thread_pool
-    @@thread_pool execute: @block
-  }
-
-  def when_done: block {
-    PooledFuture new: {
-      block call: [value]
-    }
-  }
-
-  def && block {
-    when_done: block
-  }
-
-  def completed? {
-    @block complete?
-  }
-
-  def value {
-    { Thread sleep: WaitInterval } until: { completed? }
-    @block completed_value
-  }
-}
-
 class FutureCollection {
   include: Fancy Enumerable
 
-  def initialize: @futures {
-  }
+  def initialize: @futures
 
   def each: block {
     @futures each: @{ when_done: block }

data/lib/hash.fy

@@ -163,4 +163,117 @@ class Hash {
 
     keys map: |k| { at: k }
   }
+
+  def select_keys: block {
+    """
+    @block @Block@ to be called with each key in @self.
+    @return @Hash@ of entries for which @block called with its key yields @true.
+
+    Example:
+          h = <['a => 1, 42 => (1,2,3), 'b => \"hello\"]>
+          h select_keys: @{ is_a?: Symbol } # => <['a => 1, 'b => \"hello\"]>
+    """
+
+    h = <[]>
+    keys each: |k| {
+      if: (block call: [k]) then: {
+        h[k]: $ self[k]
+      }
+    }
+    h
+  }
+
+  def reject_keys: block {
+    """
+    @block @Block@ to be called with each key in @self.
+    @return @Hash@ of entries for which @block called with its key yields @false.
+
+    Example:
+          h = <['a => 1, 42 => (1,2,3), 'b => \"hello\"]>
+          h reject_keys: @{ is_a?: Symbol } # => <[42 => (1,2,3)]>
+    """
+
+    select_keys: |k| { block call: [k] . not }
+  }
+
+  def random_key {
+    """
+    @return Random key in @self.
+    """
+
+    keys random
+  }
+
+  def random_value {
+    """
+    @return Random value in @self.
+    """
+
+    values random
+  }
+
+  def random {
+    """
+    @return Random value in @self.
+
+    Same as @Hash#random_value@.
+    """
+
+    random_value
+  }
+
+  def call: receiver {
+    """
+    @receiver Receiver to apply @self to.
+    @return @receiver.
+
+    Sends each key-value pair as a message (with one argument) to @receiver.
+
+    Example:
+          Person = Struct new: ('firstname, 'lastname)
+          p = Person new
+          <['firstname => \"Tom\", 'lastname => \"Cruise\"]> call: [p]
+
+          p firstname # => \"Tom\"
+          p lastname  # => \"Cruise\"
+    """
+
+    to_block call: receiver
+  }
+
+  def to_hash_deep {
+    h = dup
+    h each: |k v| {
+      match v {
+        case Block -> h[k]: $ v to_hash_deep
+      }
+    }
+    h
+  }
+
+  def to_block {
+    """
+    @return @Block@ that sends each key-value pair in @self as a message (with one argument) to its argument.
+
+    Example:
+          <['x => 100, 'y => 150]> to_block
+          # would be the same as:
+          |receiver| {
+            receiver tap: @{
+              x: 100
+              y: 150
+            }
+          }
+    """
+
+    |receiver| {
+      each: |k v| {
+        match k to_s {
+          case /:/ -> receiver receive_message: k with_params: [v]
+          case _ -> receiver receive_message: "#{k}:" with_params: [v]
+        }
+      }
+      receiver
+    }
+  }
 }

data/lib/integer.fy

@@ -21,11 +21,10 @@ class Integer {
     """
     @block @Block@ to be called and retries @self amount of times if exceptions get thrown.
     @retry_block @Block@ to be called before retrying execution of @block. Defaults to an empty @Block@.
-    @return Return value of calling @block or raises an exception after @self tries.
-            Returns @nil if @self <= 0.
+    @return Return value of calling @block or raises an exception after @self tries. Returns @nil if @self <= 0.
 
     Tries to call a @Block@ @self amount of times, returning its return
-    value or raising the last exception raised frin @block after @self tries.
+    value or raising the last exception raised from @block after @self tries.
 
     Example:
           2 times_try: {
@@ -41,13 +40,33 @@ class Integer {
     value = nil
     try {
       value = block call: [max_retries]
-    } catch Exception => e {
+    } catch StandardError => e {
       max_retries = max_retries - 1
       { e raise! } unless: $ max_retries > 0
       retry_block call
       retry
-    } finally {
-      return value
     }
+    value
+  }
+
+  def decimals {
+    """
+    @return @Array@ of all decimals of @self.
+
+    Returns all decimals of an Integer as an Array.
+
+    Example:
+          100 decimals   # => [1, 0, 0]
+          12345 decimals # => [1, 2, 3, 4, 5]
+    """
+
+    decimals = []
+    tmp = self
+    while: { tmp >= 10 } do: {
+      decimals << (tmp modulo: 10)
+      tmp = tmp div: 10
+    }
+    decimals << tmp
+    decimals reverse
   }
 }

data/lib/iteration.fy

@@ -22,7 +22,7 @@ class Fancy {
     """
 
     read_slots: ['result]
-    def initialize: @result {}
+    def initialize: @result
   }
 
   class NextIteration : StdError {
@@ -32,7 +32,7 @@ class Fancy {
     """
 
     read_slots: ['result]
-    def initialize: @result {}
+    def initialize: @result
   }
 
   class StopIteration : StdError {
@@ -54,7 +54,7 @@ class Fancy {
     """
 
     def initialize { @result = nil }
-    def initialize: @result { }
+    def initialize: @result
 
     def result {
       """

data/lib/main.fy

@@ -21,6 +21,7 @@ if: (ARGV size == 1) then: {
      "  -e 'command'            One line of Fancy code that gets evaluated immediately",
      "  -c [filenames]          Compile given files to Rubinius bytecode",
      "  -cv [filenames]         Compile given files to Rubinius bytecode verbosely (outputting the generated bytecode)",
+     "  -debug                  Start the Rubinius Debugger with Fancy",
      "",
      "Fancy package management:",
      "  install   [packagename] Install a Fancy package with a given name to $FANCYPACK_DIR",
@@ -65,6 +66,10 @@ ARGV for_option: "-cv" do: {
   System exit
 }
 
+ARGV for_option: "-debug" do: {
+  require: "rbx/debugger"
+}
+
 ARGV for_option: "install" do: |package_name| {
   match package_name {
     case "--deps" -> Fancy Package install_dependencies

data/lib/matchers.fy

@@ -0,0 +1,79 @@
+class Matchers {
+  class MatchAny {
+    """
+    MatchAny matcher. Matches any of the 2 values associated with it.
+
+    Example:
+          m = MatchAny new: 1 with: 2
+          m === 1  # => true
+          m === 2  # => true
+
+    There's also a shorthand method defined with @Object#><@:
+
+    Example:
+          m = 1 >< 2
+          m === 1  # => true
+          m === 2  # => true
+    """
+
+    read_slots: ('a, 'b)
+    def initialize: @a with: @b
+
+    def === object {
+      """
+      @other Object to match against.
+      @return @true if @objects matches either @a or @b in @self.
+      """
+
+      if: (@a === object) then: @{ return } else: {
+        @b === object
+      }
+    }
+
+    expose_to_ruby: '===
+
+    def == other {
+      match other {
+        case MatchAny -> @a == (other a) && { @b == (other b)}
+        case _ -> false
+      }
+    }
+  }
+
+  class MatchAll {
+    """
+    MatchAll matcher. Matches only if all of the 2 values associated with it match a given value.
+
+    Example:
+          m = MatchAll new: Array with: Enumerable
+          m === \"foo\"  # => false
+          m === [1,2,3]  # => true
+
+    There's also a shorthand method defined with @Object#<>@:
+
+    Example:
+          (Array <> Enumerable) === [1,2,3]  # => true
+    """
+
+    read_slots: ('a, 'b)
+    def initialize: @a with: @b
+
+    def === object {
+      """
+      @object Object to match against.
+      @return @true if it matches both @a and @b in @self.
+      """
+
+      if: (@a === object) then: { @b === object }
+    }
+
+    expose_to_ruby: '===
+
+    def == other {
+      match other {
+        case MatchAll -> @a == (other a) && { @b == (other b)}
+        case _ -> nil
+      }
+    }
+  }
+}

data/lib/nil_class.fy

@@ -79,6 +79,14 @@ class NilClass {
     []
   }
 
+  def to_hash {
+    """
+    @return An empty @Hash@.
+    """
+
+    <[]>
+  }
+
   def not {
     """
     @return @true.

data/lib/object.fy

@@ -355,9 +355,9 @@ class Object {
 
   def if_responds? {
     """
-    @return RespondsToProxy for @self
+    @return @Proxies::RespondsToProxy@ for @self
 
-    Returns a @RespondsToProxy@ for @self that forwards any messages
+    Returns a @Proxies::RespondsToProxy@ for @self that forwards any messages
     only if @self responds to them.
 
     Example:
@@ -365,7 +365,7 @@ class Object {
           object if_responds? some_message: some_parameter
     """
 
-    RespondsToProxy new: self
+    Proxies RespondsToProxy new: self
   }
 
   def backtick: str {
@@ -466,7 +466,7 @@ class Object {
             val = self receive_message: msg with_params: params
             sender completed: val
         }
-      } catch Exception => e {
+      } catch StandardError => e {
         { sender failed: e } if: sender
         die!
         e raise!
@@ -585,15 +585,10 @@ class Object {
     """
 
     metaclass read_write_slots: slotnames
-    val = nil
     try {
-      val = block call: [self]
+      return block call: [self]
     } finally {
-      slotnames each: |s| {
-        metaclass undefine_method: s
-        metaclass undefine_method: "#{s}:"
-      }
-      return val
+      metaclass remove_slot_accessors_for: slotnames
     }
   }
   private: 'with_mutable_slots:do:
@@ -627,9 +622,21 @@ class Object {
           some_complex_object method_1: arg1
           some_complex_object method_2: arg2
           some_complex_object method_3: arg3
+
+    If you pass it a block with 1 argument this method behaves exactly like @Object#tap:@
+
+    Example:
+          some_complex_object do: @{
+            method_1: arg1
+            method_2: arg2
+            method_3: arg3
+          }
     """
 
-    block call_with_receiver: self
+    match block arity {
+      case 0 -> block call_with_receiver: self
+      case _ -> block call: [self]
+    }
     self
   }
 
@@ -663,14 +670,17 @@ class Object {
     Thread sleep: seconds
   }
 
-  def let: var_name be: value in: block (nil) {
+  def let: var_name be: value in: block (nil) ensuring: ensure_block ({}) {
     """
     @var_name @Symbol@ that represents the name of the dynamic variable to be set.
     @value Value for the variable.
     @block @Block@ in which @var_name will be dynamically bound to @value.
+    @ensure_block @Block@ to be always called, even when @block raised an exception.
     @return Returns @value
 
     Dynamically rebinds @var_name as dynamic variable with @value as the value within @block.
+    Exceptions raised within @ensure_block are ignored.
+    Those raised in @block will be reraised up the callstack.
 
     Example:
           File write: \"/tmp/output.txt\" with: |f| {
@@ -687,15 +697,13 @@ class Object {
     }
 
     oldval = Thread current[var_name]
-    retval = nil
     try {
       Thread current[var_name]: value
-      retval = block call
-    } catch Exception => e {
-      e raise!
+      block call
+      return value
     } finally {
+      try { ensure_block call } catch {}
       Thread current[var_name]: oldval
-      return retval
     }
   }
 
@@ -721,4 +729,87 @@ class Object {
       let: '*stdout* be: f in: block
     }
   }
+
+  def fancy_methods {
+    """
+    @return @Array@ of all class methods defined in Fancy.
+    """
+
+    methods select: @{ includes?: ":" }
+  }
+
+  def ruby_methods {
+    """
+    @return @Array@ of all class methods defined in Ruby.
+    """
+
+    methods - fancy_methods
+  }
+
+  def >< other {
+    """
+    @other Other @Object@ to create a @MatchAny@ matcher with.
+
+    Shorthand for: `MatchAny new: self with: other`
+    """
+
+    Matchers MatchAny new: self with: other
+  }
+
+  def <> other {
+    """
+    @other Other @Object@ to create a @MatchAll@ matcher with.
+
+    Shorthand for: `MatchAll new: self with: other`
+    """
+
+    Matchers MatchAll new: self with: other
+  }
+
+  def ignoring: exception_classes do: block {
+    """
+    @exception_classes @Fancy::Enumerable@ of @Exception@s to ignore within @block.
+    @block @Block@ to be executed while ignoring (catching but not handling) @Exception@s defined in @exception_classes.
+
+    Example:
+          ignoring: (IOError, ZeroDivisionError) in: {
+            # do something
+          }
+    """
+
+    try {
+      block call
+    } catch (exception_classes to_a join_by: '><) {}
+  }
+
+  def rebind_method: method_name with: rebind_callable within: within_block {
+    """
+    @method_name Name of (singleton) method to rebind for @self.
+    @rebind_callable Name of method or @Block@ to rebind @method_name to.
+    @within_block @Block@ in which @method_name is rebound to @rebind_callable.
+    @return Value of calling @within_block with @self.
+
+    If @within_block takes an argument, it is called with @self.
+
+    Example:
+          class MyRebindableClass {
+            def foo {
+              42
+            }
+          }
+
+          r = MyRebindableClass new
+          r rebind_method: 'foo with: { 0 } within: @{ foo } # => 0
+    """
+
+    metaclass rebind_instance_method: method_name with: rebind_callable within: within_block receiver: self
+  }
+
+  def _ {
+    """
+    @return @Object@.
+    """
+
+    Object
+  }
 }