fancy 0.5.0 → 0.6.0

data/examples/99bottles.fy

@@ -0,0 +1,5 @@
+# see http://bottles.heroku.com/wall/99
+99 downto: 2 do: |i| {
+  "#{i} bottles of beer on the wall, #{i} bottles of beer." println
+  "Take one down and pass it around, #{i - 1} bottles of beer on the wall.\n" println
+}

data/examples/conditions_exceptions.fy

@@ -0,0 +1,9 @@
+with_handlers: @{
+  when: ZeroDivisionError do: { restart: 'default }
+} do: {
+with_restarts: {
+  default: { 1 }
+} do: {
+  10 / 0 inspect println println
+}
+}

data/examples/conditions_parsing.fy

@@ -0,0 +1,68 @@
+class MalformedLogEntry : Error {
+  read_slot: 'text
+  def initialize: @text
+}
+
+class LogEntry {
+  read_write_slots: ('word, 'number)
+
+  def LogEntry parse_entry: text {
+    word, number = text split: "|"
+    number = number to_i
+    if: (word && number) then: {
+      LogEntry new do: {
+        word: word
+        number: number
+      }
+    } else: {
+      MalformedLogEntry new: text signal!
+    }
+  }
+}
+
+class LogFile {
+  read_slots: ('filename, 'entries)
+  def initialize: @filename entries: @entries ([]);
+  def parse {
+    @text = File read: @filename
+    with_restarts: {
+      skip_entry: { nil }
+    } do: {
+      @text lines each: |line| {
+        @entries << (LogEntry parse_entry: line)
+      }
+    }
+  }
+}
+
+class LogAnalyzer {
+  read_slots: ('words, 'numbers)
+  def initialize: @logfiles {
+    @words = <[]>
+    @numbers = <[]>
+  }
+  def analyze_all {
+    @entries = @logfiles map: |f| {
+      LogFile new: f . do: { parse } . entries
+    } flatten
+
+    @entries each: |e| { analyze: e }
+  }
+  def analyze: entry {
+    if: (@words[entry word]) then: |val| {
+      @words[entry word]: (val + 1)
+    } else: {
+      @words[entry word]: 1
+    }
+    if: (@numbers[entry number]) then: |val| {
+      @numbers[entry number]: (val + 1)
+    } else: {
+      @numbers[entry number]: 1
+    }
+  }
+}
+
+l = LogAnalyzer new: ["examples/conditions_parsing_log.log"]
+l analyze_all
+"  words: #{l words to_a sort_by: 'second reverse inspect}" println
+"numbers: #{l numbers to_a sort_by: 'second reverse inspect}" println

data/examples/greeter.fy

@@ -0,0 +1,9 @@
+class Greeter {
+  def initialize: @name
+  def greet {
+    "Hello, #{@name}" println
+  }
+}
+
+g = Greeter new: "World!"
+g greet # => "Hello, World!"

data/examples/html_generator.fy

@@ -10,45 +10,75 @@ class String {
 }
 
 class HTML {
-  def open_tag: name {
-    "<" ++ (name but_last) ++ ">"
+  def initialize {
+    @buf = ""
+  }
+
+  def initialize: block {
+    initialize
+    block call_with_receiver: self
+    self
+  }
+
+  def open_tag: name attrs: attrs (<[]>) {
+    @buf << "<" << (name but_last)
+    unless: (attrs empty?) do: {
+      @buf << " "
+      attrs each: |k v| {
+        @buf << k << "=" << (v inspect)
+      } in_between: {
+        @buf << " "
+      }
+    }
+    @buf << ">"
   }
 
   def close_tag: name {
-    "</" ++ (name but_last) ++ ">"
+    @buf << "</" << (name but_last) << ">"
   }
 
-  def unknown_message: name with_params: params {
-    name = name to_s
-    str = open_tag: name
+  def html_block: tag body: body attrs: attrs (<[]>) {
+    open_tag: tag attrs: attrs
+    match body first {
+      case Block -> @buf << (body first call)
+      case _ -> @buf << (body first)
+    }
+    close_tag: tag
+  }
 
-    body = params first call
-    if: (body is_a?: Array) then: {
-      body = body join
+  def unknown_message: m with_params: p {
+    match m to_s {
+      case /with:$/ ->
+        tag = m to_s substitute: /with:$/ with: ""
+        html_block: tag body: (p rest) attrs: (p first)
+      case _ ->
+        html_block: (m to_s) body: p
     }
+    nil
+  }
 
-    str ++ body ++ (close_tag: name)
+  def to_s {
+    @buf
   }
 }
 
-# lets generate some simple HTML output )
-h = HTML new
-h html: {
-  h body: {
-    [
-     h div: {
-       "hello, world!"
-     },
-     h div: {
-       h p: {
-         "OKIDOKI"
-       }
-     },
-     h div: {
-       h h3: {
-         "oh no!"
-       }
-     }
-    ]
+# lets generate some simple HTML output :)
+HTML new: |h| {
+  html: {
+    body: <['id => "body id" ]> with: {
+      div: {
+        "hello, world!"
+      }
+      div: {
+        p: {
+          "OKIDOKI"
+        }
+      }
+      div: {
+        h3: {
+          "oh no!"
+        }
+      }
+    }
   }
 } . println

data/examples/webserver/webserver.fy

@@ -1,18 +1,15 @@
 # webserver.fy
 # Example of a simple webserver written in fancy, using Ruby socket library
 
-require("socket")
-host = "127.0.0.1"
-port = 3000
-webserver = TCPServer new(host, port)
+host, port = "127.0.0.1", 3000
+webserver = TCPServer new: host port: port
 "Webserver running at: #{host}:#{port}" println
+
 loop: {
   session = webserver accept
-  session print: "HTTP/1.1 200/OK\r\nContent-type:text/html\r\n\r\n"
-  request = session readln
-  filename = "examples/webserver/index.html"
-  displayfile = File open(filename, "r")
-  content = displayfile read
-  session print: content
-  session close
+  Thread new: {
+    session print: "HTTP/1.1 200/OK\r\nContent-type:text/html\r\n\r\n"
+    session print: $ File read: "examples/webserver/index.html"
+    session close
+  }
 }

data/lib/argv.fy

@@ -39,3 +39,9 @@ def ARGV for_options: op_names do: block {
     }
   }
 }
+
+def ARGV main?: filename {
+  if: (ARGV[0]) then: {
+    File expand_path: (ARGV[0]) . == filename
+  }
+}

data/lib/array.fy

@@ -5,7 +5,7 @@ class Array {
   index-based access to members.
   """
 
-  include: FancyEnumerable
+  include: Fancy Enumerable
 
   def Array new: size {
     """
@@ -160,22 +160,6 @@ class Array {
     self
   }
 
-  def each_with_index: block {
-    """
-    @block @Block@ to be called with each element and its inde in the @Array@.
-    @return @self
-
-    Iterate over all elements in @Array@.
-    Calls a given @Block@ with each element and its index.
-    """
-
-    i = 0
-    each: |x| {
-      block call: [x, i]
-      i = i + 1
-    }
-  }
-
   def =? other {
     """
     @other Other @Array@ to compare this one to.
@@ -441,24 +425,6 @@ class Array {
     subarr
   }
 
-  def select: block {
-    """
-    @block Predicate @Block@ to be used as filter.
-    @return @Array@ of all the elements for which @block doesn't yield @false or @nil.
-
-    Returns a new Array with all the elements in self that yield a
-    true-ish value when called with the given Block.
-    """
-
-    tmp = []
-    each: |x| {
-      if: (block call: [x]) then: {
-        tmp << x
-      }
-    }
-    return tmp
-  }
-
   def select_with_index: block {
     """
     Same as #select:, just gets also called with an additional argument
@@ -474,6 +440,22 @@ class Array {
     tmp
   }
 
+  def to_hash {
+    """
+    Returns a @Hash@ with each key-value pair in @self.
+
+    Example:
+          [[1,2],[3,4]] to_hash  # => <[1 => 2, 3 => 4]>
+    """
+
+    h = <[]>
+    self each: |pair| {
+      k,v = pair
+      h[k]: v
+    }
+    h
+  }
+
   def Array === object {
     """
     @object Object to match @self against.

data/lib/block.fy

@@ -120,7 +120,88 @@ class Block {
     call: [val]
   }
 
+  def Block inspect {
+    name
+  }
+
   def Block name {
     "Block"
   }
-}
+
+  def [args] {
+    """
+    Same as Block#call:
+    """
+
+    call: args
+  }
+
+  def to_object {
+    """
+    Creates and returns a new @Object@ with slots defined dynamically in @self.
+    Looks and feels similar to Javascript object literals.
+
+    Example:
+          o = {
+            something: \"foo bar baz\"
+            with: 42
+          } to_object
+
+          o something # => \"foo bar baz\"
+          o with      # => 42
+    """
+
+    obj = DynamicSlotObject new do: self . object
+    obj metaclass read_write_slots: (obj slots)
+    obj
+  }
+
+  def to_hash {
+    """
+    Creates and returns a new @Hash@ with keys and values defined dynamically in @self.
+    Similar to @Block#object@ but returning a @Hash@ instead of an @Object@
+
+    Example:
+          o = {
+            something: \"foo bar baz\"
+            with: 42
+          } to_hash   # => <['something => \"foo bar baz\", 'with => 42]>
+    """
+
+    DynamicKeyHash new do: self . hash
+  }
+
+  def to_hash_deep {
+    """
+    Creates and returns a new @Hash@ with keys and values defined dynamically in @self.
+    Similar to @Block#to_hash@ but converting any value that's a @Block@ to a @Hash@ as well.
+
+    Example:
+          o = {
+            something: \"foo bar baz\"
+            with: 42
+            and: {
+              another: 'field
+            }
+          } to_hash_deep   # => <['something => \"foo bar baz\", 'with => 42, 'and => <['another => 'field]>]>
+    """
+
+    DynamicKeyHash new: true . do: self . hash
+  }
+
+  def to_a {
+    """
+    Creates and returns a new @Array@ with values defined dynamically in @self.
+    Similar to @Block#to_hash@ but returning an @Array@ instead of a @Hash@
+
+    Example:
+          a = {
+            something: \"foo bar baz\"
+            with: 42
+            something; else
+          } to_a   # => [['something, \"foo bar baz\"], ['with, 42], 'something, 'else]
+    """
+
+    DynamicValueArray new do: self . array
+  }
+}

data/lib/boot.fy

@@ -24,6 +24,7 @@ require: "string"
 require: "array"
 require: "range"
 require: "tuple"
+require: "dynamic_slot_object"
 require: "block"
 require: "iteration"
 require: "integer"
@@ -33,19 +34,20 @@ require: "directory"
 require: "hash"
 require: "set"
 require: "symbol"
-require: "method"
 require: "stack"
 require: "proxy"
 require: "thread_pool"
 require: "fiber"
-require: "fiber_pool"
 require: "future"
 require: "struct"
+require: "message_sink"
+require: "kvo"
 
 # version holds fancy's version number
 require: "version"
 require: "argv"
 require: "vars"
+require: "system"
 
 require: "documentation"
 

data/lib/compiler.fy

@@ -8,7 +8,7 @@ require: "compiler/ast"
 
 require: "parser"
 
-if: (__FILE__ == (ARGV[0])) then: {
+if: (ARGV main?: __FILE__) then: {
   require: "compiler/command"
-  Fancy Compiler Command run: ARGV
+  Fancy Compiler Command run: (ARGV rest)
 }