fancy 0.7.0 → 0.8.0

data/lib/compiler/ast/script.fy

@@ -1,7 +1,6 @@
 class Fancy AST {
   class Script : Node {
-    read_slots: ['file, 'line, 'body]
-
+    read_slots: ('file, 'line, 'body)
     @@stack = []
 
     def push_script {
@@ -16,8 +15,7 @@ class Fancy AST {
       @@stack last()
     }
 
-    def initialize: @line file: @file body: @body {
-    }
+    def initialize: @line file: @file body: @body
 
     def bytecode: g {
       pos(g)

data/lib/compiler/ast/singleton_method_def.fy

@@ -7,9 +7,6 @@ class Fancy AST {
 
     def bytecode: g {
       pos(g)
-      g push_self()
-      g send(@access, 0)
-      g pop()
       bytecode(g)
     }
   }

data/lib/compiler/ast/string_interpolation.fy

@@ -6,9 +6,9 @@ class Fancy AST {
     It works...
     """
 
-    def initialize: @line code: @code
+    def initialize: @line code: @code filename: @filename
     def parse_code {
-      Fancy Parser parse_code: @code file: ("<<StringInterpolation: " ++ (@code inspect) ++ ">>") line: @line
+      Fancy Parser parse_code: @code file: @filename line: @line
     }
     def bytecode: g {
       parse_code body expressions first bytecode: g

data/lib/compiler/ast/super.fy

@@ -1,12 +1,10 @@
 class Fancy AST {
   class Super : Node {
-    def initialize: @line {
-    }
+    def initialize: @line
   }
 
   class SuperSend : Node {
-    def initialize: @line message: @name args: @args {
-    }
+    def initialize: @line message: @name args: @args
 
     def bytecode: g {
       pos(g)

data/lib/compiler/ast/try_catch.fy

@@ -28,7 +28,7 @@ class Fancy AST {
       finally_ = g new_label()
       done = g new_label()
 
-      g setup_unwind(handler, Rubinius AST RescueType)
+      g setup_unwind(handler, Rubinius AST EnsureType)
 
       # make a break available to use
       current_break = g break()
@@ -42,9 +42,11 @@ class Fancy AST {
       if: current_redo then: { g redo=(g new_label()) }
 
       @body bytecode(g)
+      retval = g new_stack_local()
+      g set_stack_local(retval)
+      g pop()
 
       g pop_unwind()
-      g pop()
       g goto(finally_)
 
       if: current_break then: {
@@ -109,7 +111,7 @@ class Fancy AST {
 
       reraise set!()
 
-      # execte the finally block before propagating the exception
+      # execute the finally block before propagating the exception
       @ensure bytecode: g
 
       # remove the exception so we have the state
@@ -120,6 +122,7 @@ class Fancy AST {
       g reraise()
 
       finally_ set!()
+
       @ensure bytecode: g
 
       done set!()
@@ -127,12 +130,15 @@ class Fancy AST {
       g push_stack_local(outer_ex)
       g restore_exception_state()
       g pop_modifiers()
+
+      g pop()
+
+      g push_stack_local(retval)
     }
   }
 
   class ExceptionHandler : Node {
-    def initialize: @line condition: @condition var: @var body: @body {
-    }
+    def initialize: @line condition: @condition var: @var body: @body
 
     def bytecode: g final_tag: final_tag {
       pos(g)
@@ -160,8 +166,7 @@ class Fancy AST {
   }
 
   class CurrentException : Node {
-    def initialize: @line {
-    }
+    def initialize: @line
 
     def bytecode: g {
       pos(g)
@@ -170,8 +175,7 @@ class Fancy AST {
   }
 
   class Retry : Node {
-    def initialize: @line {
-    }
+    def initialize: @line
 
     def bytecode: g {
       pos(g)

data/lib/compiler/ast/tuple_literal.fy

@@ -1,7 +1,6 @@
 class Fancy AST {
   class TupleLiteral : Node {
-    def initialize: @line entries: @elements {
-    }
+    def initialize: @line entries: @elements
 
     def bytecode: g {
       pos(g)

data/lib/compiler/compiler.fy

@@ -37,7 +37,7 @@ class Fancy {
       result = nil
       try {
         result = compiler run()
-      } catch Exception => e {
+      } catch StandardError => e {
         compiler_error("Error trying to compile " ++ file, e)
       }
       result
@@ -63,7 +63,7 @@ class Fancy {
         compiler run()
       } catch Fancy Parser ParseError => e {
         e raise!
-      } catch Exception => e {
+      } catch StandardError => e {
         compiler_error("Error trying to compile " ++ file, e)
       }
     }

data/lib/compiler/stages.fy

@@ -1,11 +1,10 @@
 class Fancy Compiler Stages {
   class Stage : Rubinius Compiler Stage {
-    initialize = |compiler, last| {
+    define_method('initialize) |compiler last| {
       sup = Rubinius Compiler Stage instance_method('initialize)
       sup bind(self) call(compiler, last)
       initialize: compiler last: last
     }
-    define_method('initialize, &initialize)
 
     def self stage: name next: next (nil) {
       stage(name)
@@ -41,8 +40,7 @@ class Fancy Compiler Stages {
       compiler parser: self
     }
 
-    def input: @code file: @filename line: @line (1) {
-    }
+    def input: @code file: @filename line: @line (1);
 
     def run {
       ast = Fancy Parser parse_code: @code file: @filename line: @line
@@ -60,8 +58,7 @@ class Fancy Compiler Stages {
       compiler parser: self
     }
 
-    def input: @filename line: @line (1) {
-    }
+    def input: @filename line: @line (1);
 
     def run {
       ast = Fancy Parser parse_file: @filename line: @line

data/lib/contracts.fy

@@ -1,57 +1,89 @@
-# class Class {
-#   class Contracts {
-#     class ConditionBuilder : Proxy {
-#       def initialize: block for: @method class: @class {
-#         @conditions = <[]>
-#         block call: [self]
-#         insert_validations
-#       }
-
-#       def unknown_message: m with_params: p {
-#         if: (p size > 0 ) then: {
-#           @conditions[m to_s[[0,-2]]]: $ p first
-#         }
-#       }
-
-#       def insert_validations {
-#         name = @method name()
-#         alias_name = "__#{name}__orig__"
-#         conditions = @conditions
-
-#         @class alias_method: alias_name for: name
-#         @class define_method: name with: |p| {
-#           conditions each: |attr block| {
-#             # TODO
-#           }
-#           receive_message: alias_name with_params: p
-#         }
-#       }
-#     }
-#   }
-
-#   def preconditions: block for: method {
-#     Contracts ConditionBuilder new: block for: method class: self
-#   }
-
-#   def postconditions: block for: method {
-#     Contracts ConditionBuilder new: block for: method class: self
-#   }
-# }
-
-# # example
-
-# class Person {
-#  read_slots: ('name, 'age)
-
-#   preconditions: @{
-#     name: @{ blank? not }
-#     age: @{ > 0 }
-#   } for: $ def initialize: @name age: @age
-# }
-
-
-# p = Person new: "chris" age: 25
-# p inspect println
-
-
-nil
+class Class {
+  class Contracts {
+    class InterfaceNotImplementedError : ArgumentError {
+      """
+      Exception class that gets raised during @Class@ inclusion
+      whenever a class doesn't implement another class' required
+      interface.
+      """
+
+      read_slots: ('methods, 'interface, 'including_class)
+      def initialize: @methods interface: @interface including_class: @including_class {
+        initialize: \
+        "Methods #{@methods inspect} not implemented for interface: #{@interface name} required in class: #{@including_class name}"
+      }
+    }
+  }
+
+  lazy_slot: 'expected_interface_methods value: { [] }
+  lazy_slot: 'provided_interface_methods value: { [] }
+
+  def expects_interface_on_inclusion: methods {
+    """
+    @methods Collection of method signatures to expect on inclusion into another @Class@.
+
+    Declares a required interface (collection of method signatures) an including class has to provide.
+
+    Example:
+          class Enumerable {
+            expects_interface_on_inclusion: ['each:]
+          }
+    """
+
+    @expected_interface_methods = methods to_a
+  }
+
+  alias_method: 'expects_interface: for: 'expects_interface_on_inclusion:
+
+  def provides_interface: methods {
+    """
+    @methods Collection of method signatures this class explicitly declares to provide.
+
+    Example:
+          class MyCollection {
+            # you can skip this if you actually define each: before you include Fancy Enumerable.
+            provides_interface: ['each]
+            includes: Fancy Enumerable
+          }
+    """
+
+    provided_interface_methods append: (methods to_a)
+  }
+
+  def provides_interface?: methods {
+    """
+    @methods Collection of method signatures (an interface) to check for.
+    @return @true if all methods in @methods are provided by @self, @false otherwise.
+    """
+
+    pim = Set new: $ provided_interface_methods map: @{ message_name to_s } + instance_methods
+    methods all?: |m| { pim includes?: (m message_name to_s) }
+  }
+
+  def missing_methods_for_interface: methods {
+    """
+    @methods Collection of method signatures to check.
+    @return Collection of methods in @methods this class doesn't provide.
+    """
+
+    pim = Set new: $ provided_interface_methods map: @{ message_name to_s } + instance_methods
+    methods select: |m| { pim includes?: (m message_name to_s) . not }
+  }
+
+  def included: class {
+    """
+    @class @Class@ to be included in @self. Checks possible interface requirements.
+
+    Default include hook. Make sure to call this via `super included: class`.
+    """
+
+    class provides_interface?: expected_interface_methods
+    unless: (class provides_interface?: expected_interface_methods) do: {
+      not_implemented_methods = class missing_methods_for_interface: expected_interface_methods
+      if: (not_implemented_methods size > 0) then: {
+        Contracts InterfaceNotImplementedError new: not_implemented_methods interface: self including_class: class . raise!
+      }
+    }
+    true
+  }
+}

data/lib/dynamic_slot_object.fy

@@ -7,7 +7,8 @@ class DynamicSlotObject : Fancy BasicObject {
         dso name: \"Chris\"
         dso age: 25
         dso country: \"Germany\"
-        dso object                  # => Object with slots 'name, 'age and 'country defined
+
+        dso object  # => Object with slots 'name, 'age and 'country defined
   """
 
   def initialize {
@@ -15,6 +16,10 @@ class DynamicSlotObject : Fancy BasicObject {
   }
 
   def object {
+    """
+    @return @Object@ with slots defined dynamically by sending messages to @self.
+    """
+
     @object metaclass read_write_slots: (@object slots)
     @object
   }
@@ -35,14 +40,23 @@ class DynamicKeyHash : Fancy BasicObject {
         dkh name: \"Chris\"
         dkh age: 25
         dkh country: \"Germany\"
-        dkh hash                    # => <['name => \"Chris\", 'age => 25, 'country => \"Germany\"]>
+
+        dkh hash  # => <['name => \"Chris\", 'age => 25, 'country => \"Germany\"]>
   """
 
   def initialize: @deep (false) {
+    """
+    @deep If @true, recursively sends @to_hash to any value passed as an argument to @self that is a @Block@ (dynamically creating nested @Hash@es).
+    """
+
     @hash = <[]>
   }
 
   def hash {
+    """
+    @return @Hash@ generated dynamically by sending messages to @self.
+    """
+
     @hash
   }
 
@@ -70,7 +84,7 @@ class DynamicValueArray : Fancy BasicObject {
         dva country: \"Germany\"
         dva something_else
 
-        dva array                   # => [['name, \"Chris\"], ['age, 25], ['country, \"Germany\"], 'something_else]
+        dva array  # => [['name, \"Chris\"], ['age, 25], ['country, \"Germany\"], 'something_else]
   """
 
   def initialize {
@@ -78,6 +92,10 @@ class DynamicValueArray : Fancy BasicObject {
   }
 
   def array {
+    """
+    @return @Array@ generated dynamically by sending messages to @self.
+    """
+
     @arr
   }
 

data/lib/enumerable.fy

@@ -4,6 +4,8 @@ class Fancy {
     Mixin-Class with useful methods for collections that implement an @each:@ method.
     """
 
+    expects_interface: 'each:
+
     def at: index {
       """
       @index @Fixnum@ that is the 0-based index into @self.
@@ -14,10 +16,8 @@ class Fancy {
             \"foo\” at: 3 # => nil
       """
 
-      i = 0
-      each: |x| {
+      each_with_index: |x i| {
         { return x } if: $ i == index
-        i = i + 1
       }
       return nil
     }
@@ -80,6 +80,47 @@ class Fancy {
       item
     }
 
+    def rest {
+      """
+      @return @Array@ of all but the first element in @self.
+      """
+
+      drop: 1
+    }
+
+    def first: amount {
+      """
+      @amount Amount of first elements to take from @self.
+      @return @Array@ of first @amount elements in @self.
+
+      Example:
+            (1,2,3,4) first: 2 # => [1,2]
+      """
+
+      i = 0
+      take_while: {
+        i = i + 1
+        i <= amount
+      }
+    }
+
+    def last: amount {
+      """
+      @amount Amount of last elements to take from @self.
+      @return @Array@ of last @amount elements in @self.
+
+      Example:
+            (1,2,3,4) last: 2 # => [3,4]
+      """
+
+      start_index = size - amount
+      i = 0
+      drop_while: {
+        i = i + 1
+        i <= start_index
+      }
+    }
+
     def includes?: item {
       """
       @item Item to check if it's included in @self.
@@ -123,6 +164,21 @@ class Fancy {
       s
     }
 
+    def join_by: block {
+      """
+      @block @Block@ to be called pair-wise to produce a single value.
+      @return Result of calling @block pairwise (similar to using @Fancy::Enumerable#reduce:into:@).
+
+      Works similar to @Fancy::Enumerable#inject:into:@ but uses first element as value injected.
+
+      Example:
+            (1,2,3) reduce_by: '+  # => same as: (2,3) inject: 1 into: '+
+      """
+
+      first, *rest = self
+      rest inject: first into: block
+    }
+
     def any?: condition {
       """
       @condition @Block@ (or @Callable) that is used to check if any element in @self yields true for it.
@@ -318,7 +374,7 @@ class Fancy {
     def take: amount {
       """
       @amount Amount of elements to take from @self.
-      @return First @amount elements of @self in an @Array@.
+      @return @Array@ of first @amount elements in @self.
 
       Example:
             [1,2,3,4] take: 2 # => [1,2]
@@ -575,6 +631,8 @@ class Fancy {
       tmp = []
       enum = to_enum
 
+      { return groups } if: (size <= 0)
+
       loop: {
         size times: {
           tmp << (enum next)
@@ -664,5 +722,83 @@ class Fancy {
 
       join
     }
+
+    def sorted? {
+      """
+      @return @true if @self is sorted, @false otherwise.
+
+      Example:
+            (1,2,3) sorted? # => true
+            (2,1,3) sorted? # => false
+            \"abc\" sorted? # => true
+            \"bac\" sorted? # => false
+      """
+
+      last = nil
+      each: |x| {
+        if: last then: {
+          { return false } unless: $ last <= x
+        }
+        last = x
+      }
+      true
+    }
+
+    def split_at: index {
+      """
+      @index Index at which @self should be split.
+      @return @Array@ of 2 @Array@s of elements in self splitted at @index.
+
+      Example:
+            [1,2,3,4,5] split_at: 2 # => [[1,2], [3,4,5]]
+      """
+
+      [take: index, drop: index]
+    }
+
+    def split_with: predicate_block {
+      """
+      @predicate_block @Block@ to be used as a predicate on where to split in @self.
+      @return @Array@ of 2 @Array@s of elements split based on @predicate_block.
+
+      Example:
+            [1,2,3,4,5] split_with: @{ < 3 } # => [[1, 2], [3, 4, 5]]
+      """
+
+      [take_while: predicate_block, drop_while: predicate_block]
+    }
+
+    def grep: pattern {
+      """
+      @pattern Pattern to be filtered by (via @Object#===@)
+      @return Elements in @self for which @pattern matches.
+
+      Example:
+            \"hello world\" grep: /[a-h]/                 # => [\"h\", \"e\", \"d\"]
+            [\"hello\", \"world\", 1, 2, 3] grep: String  # => [\"hello\", \"world\"]
+      """
+
+      select: |x| { pattern === x }
+    }
+
+    def grep: pattern taking: block {
+      """
+      @pattern Pattern to be filtered by (via @Object#===@)
+      @block @Block@ to be called with each element for which @pattern matches.
+      @return Return values of elements in @self called with @block for which @pattern matches.
+
+      Example:
+            \"hello world\" grep: /[a-h]/ taking: @{ upcase }             # => [\"H\", \"E\", \"D\"]
+            [\"hello\", \"world\", 1, 2, 3] grep: String taking: 'upcase  # => [\"HELLO\", \"WORLD\"]
+      """
+
+      result = []
+      each: |x| {
+        match x {
+          case pattern -> result << (block call: [x])
+        }
+      }
+      result
+    }
   }
 }