fancy 0.5.0 → 0.6.0

data/lib/rbx/tcp_server.fy

@@ -1,9 +1,11 @@
-require("socket")
-
 class TCPServer {
   """
   TCP Server
   """
 
   ruby_alias: 'accept
+
+  def TCPServer new: host port: port {
+    new(host, port)
+  }
 }

data/lib/rbx/tcp_socket.fy

@@ -5,6 +5,8 @@ class TCPSocket {
   TCP Socket class.
   """
 
+  forwards_unary_ruby_methods
+
   def TCPSocket open: server port: port {
     """
     @server Server hostname to open Socket on.
@@ -15,4 +17,16 @@ class TCPSocket {
 
     open(server, port)
   }
+
+  def send: msg flags: flags (0) {
+    send(msg, flags)
+  }
+
+  def recv: maxlen {
+    recv(maxlen)
+  }
+
+  def read: n {
+    read(n)
+  }
 }

data/lib/remote_object.fy

@@ -0,0 +1,59 @@
+require: "fyzmq"
+
+class RemoteObject : BasicObject {
+  def initialize {
+    @context = ZMQ Context new
+    @sock = @context socket: ZMQ PAIR
+    Thread new: { self receive_remote }
+  }
+
+  def bind: port {
+    bind_addr = "ipc://127.0.0.1:#{port}"
+    "Binding #{self} to #{bind_addr}" println
+    @sock bind: bind_addr
+  }
+
+  def connect_port: port {
+    connect: "ipc://127.0.0.1:#{port}"
+  }
+
+  def connect: addr {
+    @sock connect: addr
+    "Connected #{self} to #{addr}" println
+  }
+
+  def receive_remote {
+    loop: {
+      "waiting" println
+      msg = @sock recv
+      "Got: #{msg inspect}" println
+    }
+  }
+
+  def send_async: message with_params: p {
+    "sending" println
+    @sock send: "foo" # ('send, message, p inspect)
+  }
+
+  def to_s {
+    "#<RemoteObject:#{object_id to_s: 16}>"
+  }
+
+  def inspect {
+    to_s
+  }
+}
+
+r = RemoteObject new
+
+if: (ARGV includes?: "bind") then: {
+  r bind: 3001
+} else: {
+  r connect_port: 3001
+}
+
+Thread sleep: 2
+
+r send_async: 'to_s: with_params: 16
+
+Thread sleep: 2

data/lib/set.fy

@@ -3,11 +3,11 @@ class Set {
   A simple Set data structure class.
   """
 
-  include: FancyEnumerable
+  include: Fancy Enumerable
 
   def initialize: values {
     """
-    @values @FancyEnumerable@ of values to be used as values for @self.
+    @values @Fancy::Enumerable@ of values to be used as values for @self.
 
     Initialize a new Set with a given collection of values.
     """
@@ -70,7 +70,7 @@ class Set {
 
   def Set [values] {
     """
-    @values @FancyEnumerable@ of values used for new Set.
+    @values @Fancy::Enumerable@ of values used for new Set.
 
     Initialize a new Set with a given collection of values.
     """
@@ -95,12 +95,23 @@ class Set {
     @value Value to be checked for if included in @self.
     @return @true if @value in @self, @false otherwise.
 
-    Indicates, if the Set includes a given value.
+    Indicates, if the Set includes @value.
     """
 
     @hash includes?: value
   }
 
+  def [value] {
+    """
+    @value Value to be checked for if included in @self.
+    @return @true if @value is in @self, @nil otherwise.
+
+    Indicates, if the Set includes @value.
+    """
+
+    @hash[value]
+  }
+
   def each: block {
     """
     @block @Block@ to be called with each value in @self.

data/lib/string.fy

@@ -4,11 +4,29 @@ class String {
   All literal Strings within Fancy code are instances of the String
   class.
 
-  They also include FancyEnumerable, which means you can use all the
+  They also include @Fancy::Enumerable@, which means you can use all the
   common sequence methods on them, like +map:+, +select:+ etc.
   """
 
-  include: FancyEnumerable
+  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\"
+  """
 
   def ++ other {
     """
@@ -52,7 +70,9 @@ 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\"
+
+    Example:
+          \"foo\" * 3 # => \"foofoofoo\"
     """
 
     str = ""
@@ -66,6 +86,7 @@ class String {
     """
     @return @Array@ of all the whitespace seperated words in @self.
 
+    Example:
           \"hello world\" words  # => [\"hello\", \"world\"]
     """
 
@@ -156,13 +177,25 @@ class String {
 
   def bytes {
     """
-    @return @FancyEnumerator@ of all bytes (@Fixnum@ values) in @self.
+    @return @Fancy::Enumerator@ of all bytes (@Fixnum@ values) in @self.
     """
 
     enum = bytes()
     def enum each: block {
       each(&block)
     }
-    FancyEnumerator new: enum
+    Fancy Enumerator new: enum
+  }
+
+  def relative_path: path {
+    """
+    @path Relative path to @self.
+    @return Absolute @File@ path relative to @self.
+
+    Example:
+          __FILE__ relative: \"../foo/bar\"
+    """
+
+    File expand_path: $ File dirname(self) + "/" + path
   }
 }

data/lib/stringio.fy

@@ -0,0 +1 @@
+require: "rbx/stringio"

data/lib/symbol.fy

@@ -44,4 +44,8 @@ class Symbol {
   def arity {
     1
   }
+
+  def to_sym {
+    self
+  }
 }

data/lib/system.fy

@@ -0,0 +1,22 @@
+class System {
+  def System abort {
+    """
+    Exits the current running Fancy process (application) with an exit
+    code of 1 (indicating failure).
+    """
+
+    exit: 1
+  }
+
+  def System abort: message {
+    """
+    @message Error message to be printed before aborting programm execution.
+
+    Prints a given message on @*stderr* and then exits with an exit
+    code of 1 (indicating failure).
+    """
+
+    *stderr* println: message
+    abort
+  }
+}

data/lib/thread_pool.fy

@@ -76,12 +76,12 @@ class ThreadPool {
 
   # Kills all threads
   def close {
-    @executors each: |e| { e close }
+    @executors each: @{ 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 } } }
+    { Thread sleep: 0.1 } until: { { @queue empty? } && { @executors all?: @{ active not } } }
   }
 
   class Completable {

data/lib/tuple.fy

@@ -4,7 +4,24 @@ class Tuple {
   elements.
   """
 
-  include: FancyEnumerable
+  include: Fancy Enumerable
+
+  def Tuple with_values: values {
+    """
+    @values Values of the @Tuple@ to be created.
+
+    Creates a new @Tuple@ with the @values passed in.
+
+    Example:
+          Tuple with_values: [1,2,3] # => (1,2,3)
+    """
+
+    t = Tuple new: $ values size
+    values each_with_index: |v i| {
+      t[i]: v
+    }
+    t
+  }
 
   def [idx] {
     """

data/lib/vars.fy

@@ -1,3 +1,20 @@
 *stdin* = STDIN
 *stdout* = STDOUT
 *stderr* = STDERR
+
+__AFTER__BOOTSTRAP__: {
+  *stdin* documentation: """
+    The Standard Input stream.
+    Can be rebound to any @IO@ stream via @Object#let:be:in:@.
+  """
+
+  *stdout* documentation: """
+    The Standard Output stream.
+    Can be rebound to any @IO@ stream via @Object#let:be:in:@.
+  """
+
+  *stderr* documentation: """
+    The Standard Error Output stream.
+    Can be rebound to any @IO@ stream via @Object#let:be:in:@.
+  """
+}

data/lib/version.fy

@@ -1,5 +1,5 @@
 VERSION_MAJOR = 0
-VERSION_MINOR = 4
+VERSION_MINOR = 6
 VERSION_PATCH = 0
 VERSION_SUFFIX = "alpha"
 

data/ruby_lib/fancy

@@ -4,6 +4,12 @@
 base = File.dirname(__FILE__)
 require File.expand_path("../boot/fancy_ext", base)
 
+class Object
+  define_method("__AFTER__BOOTSTRAP__:") do |block|
+    block.call
+  end
+end
+
 # Use the bootstrapping code loader.
 require File.expand_path("../boot/load", base)
 

data/tests/array.fy

@@ -61,6 +61,26 @@ FancySpec describe: Array with: {
     arr size is: 0
   }
 
+  it: "creates a new array with a given default value" with: 'new: when: {
+    arr = Array new: 5
+    arr size is: 5
+    arr each: |x| {
+      x is: nil
+    }
+
+    arr = Array new: 5 with: "hello"
+    arr size is: 5
+    arr each: |x| {
+      x is: "hello"
+    }
+
+    arr = Array new: 5 with: { 2 + 3 }
+    arr size is: 5
+    arr each: |x| {
+      x is: 5
+    }
+  }
+
   it: "returns the correct value via index access" with: 'at: when: {
     arr = ['a, 10, "hello, world"]
     arr at: 2 . is: "hello, world"
@@ -522,4 +542,14 @@ FancySpec describe: Array with: {
 
     (20,30,40) in_groups_of: 2 . is: [[20,30], [40]]
   }
+
+  it: "returns a hash" with: 'to_hash when: {
+    [] to_hash is: <[]>
+    [[1,2],[3,4]] to_hash is: <[1 => 2, 3 => 4]>
+  }
+
+  it: "returns a hash based on a key-block" with: 'to_hash: when: {
+    [] to_hash: @{ size } . is: <[]>
+    [[1,2],[3,4,5]] to_hash: @{ size } . is: <[2 => [1,2], 3 => [3,4,5]]>
+  }
 }

data/tests/block.fy

@@ -113,6 +113,28 @@ FancySpec describe: Block with: {
     [1,2,3] map: @{to_s * 3} . is: ["111", "222", "333"]
   }
 
+  it: "calls the block as a partial block, converting it to implicit message sends to the first argument" when: {
+    b = @{
+      inspect println
+      class println
+      * 2 println
+      'test println
+    }
+
+    require: "stringio"
+
+    out = StringIO new
+    let: '*stdout* be: out in: {
+      b call: ["Hello, World"]
+      b call: [1]
+      b call: [1, 2, 3]
+    }
+    expected_output = ["\"Hello, World\"\nString\nHello, WorldHello, World\ntest\n",
+                       "1\nFixnum\n2\ntest\n",
+                       "[1, 2, 3]\nArray\n1\n2\n3\n1\n2\n3\ntest\n"] join
+    out string is: expected_output
+  }
+
   it: "executes a match clause if the block returns a true-ish value" with: '=== when: {
     def do_match: val {
       match val {
@@ -196,4 +218,88 @@ FancySpec describe: Block with: {
     b2("hello") is: ("hello" * 5)
     b2("foo") is: (b2 call: ["foo"])
   }
+
+  it: "dynamically creates a object with slots defined in a Block" with: 'to_object when: {
+    o = {
+      name: "John Connor"
+      age: 12
+      city: "Los Angeles"
+      persecuted_by: $ {
+        name: "The Terminator"
+        age: 'unknown
+      } to_object
+    } to_object
+
+    o name is: "John Connor"
+    o age is: 12
+    o city is: "Los Angeles"
+    o persecuted_by do: {
+      name is: "The Terminator"
+      age is: 'unknown
+    }
+  }
+
+  it: "dynamically creates a hash with keys and values defined in a Block" with: 'to_hash when: {
+    { } to_hash is: <[]>
+    { foo: "bar" } to_hash is: <['foo => "bar"]>
+    { foo: "bar"; bar: "baz" } to_hash is: <['foo => "bar", 'bar => "baz"]>
+    h = {
+      name: "John Connor"
+      age: 12
+      city: "Los Angeles"
+      persecuted_by: $ {
+        name: "The Terminator"
+        age: 'unknown
+      } to_hash
+    } to_hash
+
+    h is: <['name => "John Connor",
+            'age => 12,
+            'city => "Los Angeles",
+            'persecuted_by => <[
+              'name => "The Terminator",
+              'age => 'unknown
+            ]>
+    ]>
+  }
+
+  it: "dynamically creates a hash with keys and values defined in a Block (deep)" with: 'to_hash_deep when: {
+    { } to_hash_deep is: <[]>
+    { foo: "bar" } to_hash_deep is: <['foo => "bar"]>
+    h = {
+      name: "John Connor"
+      age: 12
+      city: "Los Angeles"
+      persecuted_by: {
+        name: "The Terminator"
+        age: 'unknown
+      }
+    } to_hash_deep
+
+    h is: <['name => "John Connor",
+            'age => 12,
+            'city => "Los Angeles",
+            'persecuted_by => <[
+              'name => "The Terminator",
+              'age => 'unknown
+            ]>
+    ]>
+    h['persecuted_by] is: <['name => "The Terminator", 'age => 'unknown]>
+  }
+
+  it: "dynamically creates an array with values defined in a Block" with: 'to_a when: {
+    { } to_a is: []
+    { foo } to_a is: ['foo]
+    { foo; bar; baz } to_a is: ['foo, 'bar, 'baz]
+    { foo bar baz } to_a is: ['foo, 'bar, 'baz]
+    {
+      name: "Chris"
+      age: 24
+      city: "San Francisco"
+      male; programmer; happy
+    } to_a is: [['name, "Chris"],
+                ['age, 24],
+                ['city, "San Francisco"],
+                'male, 'programmer, 'happy]
+  }
 }