fancy 0.7.0 → 0.8.0

data/lib/rbx/directory.fy

@@ -1,4 +1,9 @@
+Directory = Dir
+
 class Directory {
+  forwards_unary_ruby_methods
+  metaclass forwards_unary_ruby_methods
+
   def self create: dirname {
     """
     @dirname Path of @Directory@ to create.
@@ -39,7 +44,7 @@ class Directory {
 
     try {
       Dir delete(dirname)
-    } catch Exception => e {
+    } catch StandardError => e {
       IOError new: (e message) . raise!
     }
   }
@@ -49,8 +54,8 @@ class Directory {
     @pattern Directory pattern or name containing files to be returned as an @Array@.
     @return @Array@ of files matching directory @pattern.
 
-    Example usage:
-        Directory list: \"tests/**/*.fy\"  # => [\"tests/file1.fy\", \"tests/more/file2.fy\"]
+    Example:
+          Directory list: \"tests/**/*.fy\"  # => [\"tests/file1.fy\", \"tests/more/file2.fy\"]
     """
 
     match pattern {

data/lib/rbx/documentation.fy

@@ -6,7 +6,7 @@ class Fancy Documentation {
     @docs = [docstring]
   }
 
-  def meta: @meta { }
+  def meta: @meta
   def meta { @meta }
 
   # A list of handlers that would like to get adviced when

data/lib/rbx/file.fy

@@ -126,6 +126,19 @@ class File {
     }
   }
 
+  def File delete!: filename {
+    """
+    @filename Path to @File@ to be deleted.
+
+    Deletes a @File@ with a given @filename. If an @IOError@ occurs,
+    it gets ignored.
+    """
+
+    try {
+      File delete: filename
+    } catch IOError {}
+  }
+
   def File directory?: path {
     """
     @path Path to check if it's a @Directory@.
@@ -148,6 +161,15 @@ class File {
     File rename(old_name, new_name)
   }
 
+  def File absolute_path: filename {
+    """
+    @filename Name of @File@ to get absolute path for.
+    @return Absolute (expanded) path for @filename.
+    """
+
+    File expand_path: filename
+  }
+
   def initialize: path {
     initialize(path)
   }

data/lib/rbx/integer.fy

@@ -4,7 +4,7 @@ class Integer {
   def times: block {
     """
     @block @Block@ to be called with each number between 0 and @self.
-    @return @self
+    @return @self.
 
     Calls a given @Block@ with each number between 0 and @self.
     """

data/lib/rbx/match_data.fy

@@ -4,7 +4,8 @@ class MatchData {
    (e.g. by using match/case expressions).
    """
 
-   ruby_alias: 'size
+   forwards_unary_ruby_methods
+
    ruby_alias: '[]
 
    def at: idx {

data/lib/rbx/method.fy

@@ -75,6 +75,10 @@ class Method {
   ruby_alias: 'executable
   include: MethodMixin
   forwards_unary_ruby_methods
+
+  def call: args ([]) {
+    call(*args)
+  }
 }
 
 class UnboundMethod {
@@ -86,4 +90,26 @@ class UnboundMethod {
   ruby_alias: 'executable
   include: MethodMixin
   forwards_unary_ruby_methods
+
+  alias_method: 'bind: for_ruby: 'bind
+
+  def call: args ([]) {
+    call(*args)
+  }
+
+  def selector_with_args {
+    match name {
+      case ":[]" -> return "[arg_0]"
+      case "[]:" -> return "[arg_0]: arg_1"
+    }
+
+    match arity {
+      case 0 -> name rest
+      case _ ->
+        selectors = name split: ":"
+        (0..arity - 1) map: |i| {
+          "#{selectors[i]}: arg_#{i}"
+        } . join: " "
+    }
+  }
 }

data/lib/rbx/object.fy

@@ -1,5 +1,5 @@
 class Object {
-  ruby_aliases: [ '==, '===, 'class, 'inspect, 'object_id, 'instance_variables ]
+  ruby_aliases: [ '==, '===, 'class, 'inspect, 'object_id, 'instance_variables, 'methods, 'instance_variable_get, 'instance_variable_set ]
 
   def initialize {
     initialize()
@@ -14,8 +14,13 @@ class Object {
     Fancy CodeLoader require: file_path
   }
 
-  def dclone {
-    "Returns a deep clone of self using Ruby's Marshal class."
+  def dup {
+    """
+    @return Copy (clone) of self.
+
+    Returns a deep clone of self using Ruby's Marshal class.
+    """
+
     Marshal load(Marshal dump(self))
   }
 

data/lib/rbx/regexp.fy

@@ -6,9 +6,8 @@ class Regexp {
   ruby_alias: 'inspect
   ruby_alias: 'to_s
 
-  def === string {
-    ruby: 'match args: [string]
-  }
+  alias_method: 'match: for_ruby: 'match
+  alias_method: '=== for_ruby: 'match
 
   def i {
     Regexp new(source(), true)
@@ -29,4 +28,8 @@ class Regexp {
   def Regexp [string] {
     new(string)
   }
+
+  def call: args {
+    args first =~ self
+  }
 }

data/lib/rbx/string.fy

@@ -3,12 +3,13 @@ class String {
   # prepend a : to fancy version of ruby methods.
   ruby_aliases: [
     '==, 'upcase, 'downcase, '=~, 'to_i, 'to_f,
-    'chomp, 'inspect, 'to_sym, '<, '>
+    'chomp, 'inspect, 'to_sym, '<, '>, '<=, '>=, '<=>
   ]
 
   alias_method: 'ruby_idx: for_ruby: '[]
   alias_method: '[]: for_ruby: '[]=
   alias_method: 'scan: for_ruby: 'scan
+  alias_method: 'to_i: for_ruby: 'to_i
   alias_method: 'uppercase for: 'upcase
   alias_method: 'lowercase for: 'downcase
 
@@ -166,4 +167,11 @@ class String {
   def message_name {
     self to_sym message_name to_s
   }
+
+  def to_fancy_message {
+    match self {
+      case /^:/ -> rest to_sym
+      case _ -> self
+    }
+  }
 }

data/lib/rbx/stringio.fy

@@ -12,6 +12,18 @@ class StringIO {
   }
 
   def each_line: block {
+    """
+    @block @Block@ to be called with each line in @self.
+    """
+
     each_line(&block)
   }
+
+  def string: str {
+    """
+    @str @String@ to set @string in @self to.
+    """
+
+    string=(str)
+  }
 }

data/lib/rbx/symbol.fy

@@ -32,4 +32,8 @@ class Symbol {
       case false -> ":" <<(symbol) to_sym
     }
   }
+
+  def to_fancy_message {
+    to_s to_fancy_message to_sym
+  }
 }

data/lib/stack.fy

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

data/lib/string.fy

@@ -198,4 +198,38 @@ class String {
 
     File expand_path: $ File dirname(self) + "/" + path
   }
+
+  def multiline? {
+    """
+    @return @true if @self is a multiline string, @false otherwise.
+
+    Example:
+          \"foo\nbar\" multiline? # => true
+          \"foo bar\" multiline?  # => false
+          \"\" multiline?         # => false
+          \"\n\n\n\" multiline?   # => true
+    """
+
+    grep: /\n/ . size > 0
+  }
+
+  def main? {
+    """
+    @return @true if @self is the filename of the script that got executed initially.
+    """
+
+    File expand_path: (ARGV[0] to_s) == self
+  }
+
+  def if_main: main_block else: else_block ({}) {
+    """
+    @main_block @Block@ to be run if @String#:main?@ returns true.
+    @else_block @Block@ to be called otherwise.
+
+    Same as:
+          if: main? then: else_block else: else_block
+    """
+
+    if: main? then: main_block else: else_block
+  }
 }

data/lib/stringio.fy

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

data/lib/symbol.fy

@@ -8,8 +8,11 @@ class Symbol {
 
   def call: arg {
     """
-    This allows Symbols to be used like Blocks
-    (e.g. in all methods of Enumerable).
+    @arg Argument to send @self to.
+    @return Value of sending @self as message to @arg.
+
+    This allows Symbols to be used like Blocks (e.g. in all methods of Enumerable).
+
     Example:
           [1, 2, 3] map: 'squared # => [1, 4, 9]
     """
@@ -24,6 +27,7 @@ class Symbol {
   def call {
     """
     Sends @self as message to the sender in its context.
+
     Example:
           'foo call
            # => same as

data/lib/system.fy

@@ -12,11 +12,25 @@ class System {
     """
     @message Error message to be printed before aborting programm execution.
 
-    Prints a given message on @*stderr* and then exits with an exit
+    Prints @message on @\*stderr\* and exits with an exit code of 1 (indicating
+    failure).
+    """
+
+    *stderr* println: message
+    abort
+  }
+
+  def System aborting: message do: block {
+    """
+    @message Message to print on @*stderr* before calling @block and exiting.
+    @block @Block@ to be called before exiting execution.
+
+    Prints @message on @\*stderr\*, calls @block and finally exits with an exit
     code of 1 (indicating failure).
     """
 
     *stderr* println: message
+    block call
     abort
   }
 }

data/lib/tuple.fy

@@ -84,9 +84,12 @@ class Tuple {
     """
 
     size times: |i| {
-      block call: [at: i]
+      try {
+        block call: [at: i]
+      } catch Fancy NextIteration {}
     }
-    self
+
+    return self
   }
 
   def reverse_each: block {

data/lib/version.fy

@@ -1,6 +1,6 @@
 class Fancy {
   VERSION_MAJOR = 0
-  VERSION_MINOR = 7
+  VERSION_MINOR = 8
   VERSION_PATCH = 0
 
   VERSION = [VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH] join: "."

data/ruby_lib/fdoc

@@ -1,23 +1,3 @@
-#!/usr/bin/env rbx
-# -*- ruby -*-
+#!/usr/bin/env fancy
 
-class Fancy; end
-class Fancy::Parser; end
-
-# fdoc is a documentation generator for fancy.
-# This is a ruby script because we need to setup a hook
-# BEFORE any fancy code is loaded. So we can create
-# documentation for Fancy's builtin objects as well.
-# See fdoc.
-base = File.expand_path("../boot", File.dirname(__FILE__))
-require File.expand_path("rbx-compiler/parser/fancy_parser", base)
-require File.expand_path("rbx-compiler/compiler", base)
-require File.expand_path("code_loader", base)
-require File.expand_path("fancy_ext", base)
-
-Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/rbx/documentation.fyc", base)
-Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/fdoc_hook.fyc", base)
-
-Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/rbx.fyc", base)
-
-Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/fdoc.fyc", base)
+require: "../lib/fdoc"

data/tests/array.fy

@@ -122,6 +122,9 @@ FancySpec describe: Array with: {
     arr index: 3 . is: 3
     arr index: 4 . is: 4
     arr index: 'foo . is: nil
+
+    arr index: @{ is_a?: Symbol } . is: 2
+    arr index: @{ is_a?: String } . is: nil
   }
 
   it: "returns an Array of all its indices" with: 'indices when: {
@@ -395,15 +398,6 @@ FancySpec describe: Array with: {
     arr is: [3,2,1]
   }
 
-  it: "takes elements from itself as long a block yields true" with: 'take_while: when: {
-    1 upto: 15 . take_while: |x| { x < 10 } . is: (1 upto: 9)
-  }
-
-
-  it: "drops elements from itself as long a block yields true" with: 'drop_while: when: {
-    1 upto: 15 . drop_while: |x| { x < 10 } . is: (10 upto: 15)
-  }
-
   it: "partitions an array via a given block" with: 'partition_by: when: {
     arr = [1,2,2,3,3,3,4,4,4,4,5]
     arr partition_by: 'identity . is: [[1], [2,2], [3,3,3], [4,4,4,4], [5]]
@@ -547,14 +541,6 @@ FancySpec describe: Array with: {
     arr sort_by: 'second . is: sorted
   }
 
-  it: "returns the array in groups of 3" with: 'in_groups_of: when: {
-    ['a,'b,'c] in_groups_of: 1 . is: [['a],['b],['c]]
-    array = 1 upto: 10
-    array in_groups_of: 3 . is: [[1,2,3], [4,5,6], [7,8,9], [10]]
-
-    (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]>

data/tests/class.fy

@@ -244,10 +244,8 @@ FancySpec describe: Class with: {
   }
 
   it: "is a subclass of another Class" with: 'subclass?: when: {
-    class Super {
-    }
-    class Sub : Super {
-    }
+    class Super
+    class Sub : Super
 
     Super subclass?: Object . is: true
     Sub subclass?: Object . is: true
@@ -450,12 +448,9 @@ FancySpec describe: Class with: {
   }
 
   it: "has the correct list of ancestors" with: 'ancestors when: {
-    class A {
-    }
-    class B : A {
-    }
-    class C : B {
-    }
+    class A
+    class B : A
+    class C : B
 
     A ancestors is: [A, Object, Kernel]
     B ancestors is: [B, A, Object, Kernel]
@@ -478,6 +473,20 @@ FancySpec describe: Class with: {
     { x b } raises: NoMethodError
     AClassWithPrivateMethods instance_method: 'a . private? is: true
     AClassWithPrivateMethods instance_method: 'b . private? is: true
+
+    class AClassWithPrivateMethods {
+      private: {
+        def c {
+          "private c"
+        }
+        def d {
+          "private d"
+        }
+      }
+    }
+
+    AClassWithPrivateMethods instance_method: 'c . private? is: true
+    AClassWithPrivateMethods instance_method: 'd . private? is: true
   }
 
   it: "makes methods protected" with: 'protected: when: {
@@ -498,6 +507,25 @@ FancySpec describe: Class with: {
     AClassWithProtectedMethods instance_method: 'b . private? is: false
     AClassWithProtectedMethods instance_method: 'a . protected? is: true
     AClassWithProtectedMethods instance_method: 'b . protected? is: true
+
+    class AClassWithProtectedMethods {
+      protected: {
+        def c {
+          "in c"
+        }
+        def d {
+          "in d"
+        }
+      }
+    }
+
+    { x a } raises: NoMethodError
+    { x b } raises: NoMethodError
+    AClassWithProtectedMethods instance_method: 'c . private? is: false
+    AClassWithProtectedMethods instance_method: 'd . private? is: false
+    AClassWithProtectedMethods instance_method: 'c . protected? is: true
+    AClassWithProtectedMethods instance_method: 'd . protected? is: true
+
   }
 
   it: "makes methods public" with: 'public: when: {
@@ -521,6 +549,26 @@ FancySpec describe: Class with: {
     AClassWithPublicMethods instance_method: 'b . protected? is: false
     AClassWithPublicMethods instance_method: 'a . public? is: true
     AClassWithPublicMethods instance_method: 'b . public? is: true
+
+    class AClassWithPublicMethods {
+      public: {
+        def c {
+          "in c"
+        }
+        def d {
+          "in d"
+        }
+      }
+    }
+
+    { x c } does_not raise: NoMethodError
+    { x d } does_not raise: NoMethodError
+    AClassWithPublicMethods instance_method: 'c . private? is: false
+    AClassWithPublicMethods instance_method: 'd . private? is: false
+    AClassWithPublicMethods instance_method: 'c . protected? is: false
+    AClassWithPublicMethods instance_method: 'd . protected? is: false
+    AClassWithPublicMethods instance_method: 'c . public? is: true
+    AClassWithPublicMethods instance_method: 'd . public? is: true
   }
 
   it: "defines a class without a body" when: {
@@ -646,4 +694,258 @@ FancySpec describe: Class with: {
     NoMethods instance_methods is: $ Object instance_methods
     Set[OneMethod instance_methods] is: $ Set[Object instance_methods + (OneMethod instance_methods: false)]
   }
+
+  it: "defines a before_method handler" with: 'before_method:run: when: {
+    class BeforeMethodClass {
+      read_slot: 'x
+      def initialize: @x
+      def before: arr {
+        arr << "Before Method: #{@x}"
+      }
+      def my_method: arr {
+        arr << "My Method: #{@x}"
+      }
+
+      before_method: 'my_method: run: 'before:
+    }
+
+    b1 = BeforeMethodClass new: 1
+    b2 = BeforeMethodClass new: 2
+
+    array = []
+
+    b1 my_method: array
+    b2 my_method: array
+
+    array is: [
+      "Before Method: 1", "My Method: 1",
+      "Before Method: 2", "My Method: 2"
+    ]
+
+    # we can also pass blocks
+
+    BeforeMethodClass before_method: 'my_method: run: |receiver array| {
+      array << "Before Block: #{receiver x}"
+    }
+
+    array = []
+
+    b1 my_method: array
+    b2 my_method: array
+
+    array is: [
+      "Before Block: 1", "Before Method: 1", "My Method: 1",
+      "Before Block: 2", "Before Method: 2", "My Method: 2"
+    ]
+  }
+
+  it: "defines an after_method handler" with: 'after_method:run: when: {
+    class AfterMethodClass {
+      read_slot: 'x
+      def initialize: @x
+      def after: arr {
+        arr << "After Method: #{@x}"
+      }
+      def my_method: arr {
+        arr << "My Method: #{@x}"
+      }
+
+      after_method: 'my_method: run: 'after:
+    }
+
+    b1 = AfterMethodClass new: 1
+    b2 = AfterMethodClass new: 2
+
+    array = []
+
+    b1 my_method: array
+    b2 my_method: array
+
+    array is: [
+      "My Method: 1", "After Method: 1",
+      "My Method: 2", "After Method: 2"
+    ]
+
+    AfterMethodClass after_method: 'my_method: run: |receiver array| {
+      "block getting called yo"
+      array << "After Block: #{receiver x}"
+    }
+
+    array = []
+
+    b1 my_method: array
+    b2 my_method: array
+
+    array is: [
+      "My Method: 1", "After Method: 1", "After Block: 1",
+      "My Method: 2", "After Method: 2", "After Block: 2"
+    ]
+  }
+
+
+  it: "defines an around_method handler" with: 'around_method:run: when: {
+    class AroundMethodClass {
+      read_slot: 'x
+      def initialize: @x
+      def around: arr {
+        arr << "Around Method: #{@x}"
+      }
+      def my_method: arr {
+        arr << "My Method: #{@x}"
+      }
+
+      around_method: 'my_method: run: 'around:
+    }
+
+    b1 = AroundMethodClass new: 1
+    b2 = AroundMethodClass new: 2
+
+    array = []
+
+    b1 my_method: array
+    b2 my_method: array
+
+    array is: [
+      "Around Method: 1", "My Method: 1", "Around Method: 1",
+      "Around Method: 2", "My Method: 2", "Around Method: 2"
+    ]
+
+
+    AroundMethodClass around_method: 'my_method: run: |receiver array| {
+      array << "Around Block: #{receiver x}"
+    }
+
+    array = []
+
+    b1 my_method: array
+    b2 my_method: array
+
+    array is: [
+      "Around Block: 1", "Around Method: 1", "My Method: 1", "Around Method: 1", "Around Block: 1",
+      "Around Block: 2", "Around Method: 2", "My Method: 2", "Around Method: 2", "Around Block: 2"
+    ]
+  }
+
+  it: "defines a custom calling chain for a method" with: 'define_calling_chain:for_method: when: {
+    class CallingChainClass {
+      def foo: arr { arr << "foo" }
+      def bar: arr { arr << "bar" }
+      def baz: arr { arr << "baz" }
+
+      define_calling_chain: ('foo:, 'bar:, 'baz:) for_method: 'foo:
+    }
+
+    arr = []
+    CallingChainClass new foo: arr
+    arr is: ["foo", "bar", "baz"]
+
+    CallingChainClass define_calling_chain: [|receiver arr|{ receiver baz: arr }, 'bar:] for_method: 'bar:
+
+    arr = []
+    CallingChainClass new bar: arr
+    arr is: ["baz", "bar"]
+  }
+
+  it: "exposes a Fancy method as a Ruby method to Ruby" with: 'expose_to_ruby:as: when: {
+    class ExposeToRuby {
+      def my_method { "in my_method" }
+      expose_to_ruby: 'my_method
+      def == other { true }
+      expose_to_ruby: '== as: 'ruby_==
+    }
+
+    ExposeToRuby new tap: @{
+      my_method is: "in my_method"
+      send('my_method) is: "in my_method"
+      == 1 is: true
+      send('ruby_==, 1) is: true
+    }
+  }
+
+  it: "rebinds an instance method within a block" with: 'rebind_instance_method:with:within: when: {
+    class RebindInstanceMethod {
+      def foo: msg ("foo!") {
+        msg println
+      }
+      def bar: msg {
+        "bar: #{msg}" println
+      }
+    }
+
+    rim = RebindInstanceMethod new
+    s = StringIO new
+    let: '*stdout* be: s in: {
+      rim foo
+      rim foo: "hello!"
+      s string is: "foo!\nhello!\n"
+      s string: ""
+
+      RebindInstanceMethod rebind_instance_method: 'foo: with: |msg| {
+        msg * 2 println
+      } within: {
+        let: '*stdout* be: s in: {
+          rim foo: "hello!"
+        }
+      }
+      s string is: "hello!hello!\n"
+
+      s string: ""
+      rim foo: "hello!"
+      s string is: "hello!\n"
+
+      s string: ""
+      RebindInstanceMethod rebind_instance_method: 'foo: with: 'bar: within: {
+        rim foo: "Test"
+      }
+      s string is: "bar: Test\n"
+    }
+  }
+
+  it: "removes defined slot accessor methods" with: 'remove_slot_accessors_for: when: {
+    class SlotAccessors {
+      read_write_slots: ('rw1, 'rw2)
+      read_slots: ('r1, 'r2)
+      write_slots: ('w1, 'w2)
+    }
+
+    sa = SlotAccessors new
+    {
+      sa rw1 is: nil
+      sa rw2 is: nil
+      sa r1 is: nil
+      sa r2 is: nil
+
+      sa rw1: "rw1"
+      sa rw2: "rw2"
+      sa w1: "w1"
+      sa w2: "w2"
+
+      sa rw1 is: "rw1"
+      sa rw2 is: "rw2"
+      sa r1 is: nil
+      sa r2 is: nil
+    } does_not raise: NoMethodError
+
+    { sa w1 } raises: NoMethodError
+    { sa w2 } raises: NoMethodError
+
+    SlotAccessors remove_slot_accessors_for: ('rw1, 'r1, 'w1)
+
+    { sa rw1 } raises: NoMethodError
+    { sa rw1: "foo"} raises: NoMethodError
+
+    {
+      sa rw2
+      sa rw2: "foo"
+    } does_not raise: NoMethodError
+
+    { sa r1 } raises: NoMethodError
+    { sa r2 } does_not raise: NoMethodError
+
+    { sa w1 } raises: NoMethodError
+    { sa w1: "foo" } raises: NoMethodError
+
+    { sa w2 } raises: NoMethodError
+    { sa w2: "foo" } does_not raise: NoMethodError
+  }
 }