fancy 0.6.0 → 0.7.0

data/lib/compiler/ast/class_def.fy

@@ -18,7 +18,7 @@ class Fancy AST {
 
     def bytecode: g {
       pos(g)
-      docstring = body() body() shift_docstring
+      docstring = body() body() docstring
       docstring if_true: {
         setdoc = MessageSend new: @line \
                              message: (Identifier from: "for:append:" line: @line) \

data/lib/compiler/ast/expression_list.fy

@@ -20,11 +20,7 @@ class Fancy AST {
     def bytecode: g {
       pos(g)
       size = @expressions size
-      @expressions each: |expr| {
-        size = size - 1
-        expr bytecode: g
-        { g pop() } if: (size > 0)
-      }
+      @expressions each: @{ bytecode: g } in_between: { g pop() }
     }
 
     # This method is only used by Rubinius' compiler classes and
@@ -33,13 +29,9 @@ class Fancy AST {
       []
     }
 
-    # If this expression list contains more than one expression
-    # and the first one is an string literal, it'll be used as doc.
-    # This method removes the first documentation string.
-    def shift_docstring {
-      if: ((@expressions first kind_of?(Rubinius AST StringLiteral)) && \
-           (@expressions size > 1)) then: {
-        @expressions shift()
+    def docstring {
+      if: (@expressions first kind_of?(Rubinius AST StringLiteral)) then: {
+        @expressions first
       }
     }
   }

data/lib/compiler/ast/identifier.fy

@@ -57,9 +57,9 @@ class Fancy AST {
     def bytecode: g {
       pos(g)
       match @string {
-        # case "true" -> g push_true()
-        # case "false" -> g push_false()
-        # case "nil" -> g push_nil()
+        case "true" -> g push_true()
+        case "false" -> g push_false()
+        case "nil" -> g push_nil()
         case _ ->
           if: (g state() scope() search_local(name)) then: {
             Rubinius AST LocalVariableAccess new(@line, name) bytecode(g)

data/lib/compiler/ast/method_def.fy

@@ -3,7 +3,7 @@ class Fancy AST {
     def initialize: @line name: @name args: @arguments (MethodArgs new: @line) body: @body (ExpressionList new: @line) access: @access ('public) {
       { @body = ExpressionList new: @line } unless: @body
       @name = @name method_name: nil
-      @docstring = @body shift_docstring
+      @docstring = @body docstring
       generate_ivar_assignment
 
       if: (@body empty?) then: {
@@ -71,6 +71,7 @@ class Fancy AST {
                        to:      (Self new: @line)                                                 \
                        args:    (MessageArgs new: @line args: [method_ident])
       ms bytecode: g
+      g pop()
     }
 
     def define_method_missing: g {
@@ -79,6 +80,7 @@ class Fancy AST {
                        to:      (Self new: @line)                                              \
                        args:    (MessageArgs new: @line)
       ms bytecode: g
+      g pop()
     }
   }
 

data/lib/compiler/ast/singleton_method_def.fy

@@ -16,6 +16,9 @@ class Fancy AST {
 
   class SingletonMethodDefScope : Rubinius AST DefineSingletonScope {
     def initialize: @line name: @name args: @arguments body: @body {
+      if: (@body empty?) then: {
+        @body unshift_expression: $ NilLiteral new: @line
+      }
     }
 
     define_method("bytecode") |g, recv| {
@@ -24,7 +27,7 @@ class Fancy AST {
 
     def bytecode: g receiver: receiver {
       pos(g)
-      docstring = @body shift_docstring
+      docstring = @body docstring
       sup = Rubinius AST DefineSingletonScope instance_method('bytecode)
       sup bind(self) call(g, receiver)
       MethodDef set: g docstring: docstring line: @line argnames: $ @arguments names()

data/lib/contracts.fy

@@ -1,60 +1,57 @@
-class Object {
-  def require: require_block ensure: ensure_block body: body_block {
-    requirement = Contract Requirement new: require_block
-    ensurance = Contract Requirement new: ensure_block
-    retval = nil
-    requirement if_fullfilled: {
-      retval = body_block call
-    }
-    ensure_block if_fullfilled: {
-      retval
-    }
-  }
-
-  def require: require_block body: body_block {
-    requirement = Contract Requirement new: require_block
-    requirement if_fullfilled: {
-      body_block call
-    }
-  }
-
-  def ensure: ensure_block body: body_block {
-    require: ensure_block body: body_block
-  }
-}
-
-class Contract {
-  class RequirementError : RuntimeError
-  class Requirement {
-    def initialize: @block
-    def if_fullfilled: block {
-      @block call: [self]
-      block call
-    }
-    def true: expr {
-      { RequirementError new: "#{expr} not true" . raise! } unless: expr
-    }
-    def false: expr {
-      { RequirementError new: "#{expr} not false" . raise! } if: expr
-    }
-  }
-}
-
-# # usage:
-# class Fixnum {
-#   def / other {
-#     require: @{
-#       true: $ other is_a?: Fixnum
-#       true: $ other > 0
-#       # better:
-#       other class is: Fixnum
-#       other is > 0
-#
-#     } body: {
-#        "foo" println
+# 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
+#   }
 # }
 
-# f = 10 / 2
-# g = 10 / 0 # requirement error
+# # 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

data/lib/dynamic_slot_object.fy

@@ -1,9 +1,21 @@
-class DynamicSlotObject : BasicObject {
+class DynamicSlotObject : Fancy BasicObject {
+  """
+  Helper class to dynamically create @Object@s with slots defined by sending messages to it.
+
+  Example:
+        dso = DynamicSlotObject new
+        dso name: \"Chris\"
+        dso age: 25
+        dso country: \"Germany\"
+        dso object                  # => Object with slots 'name, 'age and 'country defined
+  """
+
   def initialize {
     @object = Object new
   }
 
   def object {
+    @object metaclass read_write_slots: (@object slots)
     @object
   }
 
@@ -14,7 +26,18 @@ class DynamicSlotObject : BasicObject {
   }
 }
 
-class DynamicKeyHash : BasicObject {
+class DynamicKeyHash : Fancy BasicObject {
+  """
+  Helper class to dynamically create @Hash@es with keys and values defined by sending messages to it.
+
+  Example:
+        dkh = DynamicKeyHash new
+        dkh name: \"Chris\"
+        dkh age: 25
+        dkh country: \"Germany\"
+        dkh hash                    # => <['name => \"Chris\", 'age => 25, 'country => \"Germany\"]>
+  """
+
   def initialize: @deep (false) {
     @hash = <[]>
   }
@@ -36,7 +59,20 @@ class DynamicKeyHash : BasicObject {
   }
 }
 
-class DynamicValueArray : BasicObject {
+class DynamicValueArray : Fancy BasicObject {
+  """
+  Helper class to dynamically create @Array@s with values defined by sending messages to it.
+
+  Example:
+        dva = DynamicValueArray new
+        dva name: \"Chris\"
+        dva age: 25
+        dva country: \"Germany\"
+        dva something_else
+
+        dva array                   # => [['name, \"Chris\"], ['age, 25], ['country, \"Germany\"], 'something_else]
+  """
+
   def initialize {
     @arr = []
   }

data/lib/enumerable.fy

@@ -4,6 +4,24 @@ class Fancy {
     Mixin-Class with useful methods for collections that implement an @each:@ method.
     """
 
+    def at: index {
+      """
+      @index @Fixnum@ that is the 0-based index into @self.
+      @return Value in @self at 0-based position defined by @index.
+
+      Example:
+            \"foo\” at: 2 # => \"o\"
+            \"foo\” at: 3 # => nil
+      """
+
+      i = 0
+      each: |x| {
+        { return x } if: $ i == index
+        i = i + 1
+      }
+      return nil
+    }
+
     def each_with_index: block {
       """
       @block @Block@ to be called with each element and its index in the @self.
@@ -20,6 +38,48 @@ class Fancy {
       }
     }
 
+    def first {
+      """
+      @return The first element in the @Fancy::Enumerable@.
+      """
+      at: 0
+    }
+
+    def second {
+      """
+      @return The second element in the @Fancy::Enumerable@.
+      """
+      at: 1
+    }
+
+    def third {
+      """
+      @return The third element in the @Fancy::Enumerable@.
+      """
+      at: 2
+    }
+
+    def fourth {
+      """
+      @return The fourth element in the @Fancy::Enumerable@.
+      """
+      at: 3
+    }
+
+    def last {
+      """
+      @return Last element in @self or @nil, if empty.
+
+      Returns the last element in a @Fancy::Enumerable@.
+      """
+
+      item = nil
+      each: |x| {
+        item = x
+      }
+      item
+    }
+
     def includes?: item {
       """
       @item Item to check if it's included in @self.
@@ -28,7 +88,7 @@ class Fancy {
       Indicates, if a collection includes a given element.
       """
 
-      any?: |x| { item == x }
+      any?: |x| { x == item }
     }
 
     def each: each_block in_between: between_block {
@@ -44,7 +104,7 @@ class Fancy {
       }
     }
 
-    def join: str {
+    def join: str ("") {
       """
       @str Value (usually a @String@) to be used for the joined @String@.
       @return @String@ containing all elements in @self interspersed with @str.
@@ -144,6 +204,38 @@ class Fancy {
       coll
     }
 
+    def map_with_index: block {
+      """
+      @block A @Block@ that gets called with each element and its index in @self.
+      @return An @Array@ containing all values of calling @block with each element and its index in @self.
+
+      Returns a new @Array@ with the results of calling a given block for every element and its index.
+      """
+
+      coll = []
+      each_with_index: |x i| {
+        coll << (block call: [x, i])
+      }
+      coll
+    }
+
+    def map_chained: blocks {
+      """
+      @blocks Collection of @Block@s to be called sequentially for every element in @self.
+      @return Collection of all values in @self successively called with all blocks in @blocks.
+
+      Example:
+            (1,2,3) map_chained: (@{ + 1 }, 'to_s, @{ * 2 })
+            # => [\"22\", \"33\", \"44\"]
+      """
+
+      map: |v| {
+        blocks inject: v into: |acc b| {
+          b call: [acc]
+        }
+      }
+    }
+
     def select: condition {
       """
       @condition A @Block@ that is used as a filter on all elements in @self.
@@ -285,23 +377,23 @@ class Fancy {
       reduce: block init_val: val
     }
 
-    def uniq {
+    def unique {
       """
       @return @Array@ of all unique elements in @self.
 
       Returns a new Array with all unique values (double entries are skipped).
 
       Example:
-            [1,2,1,2,3] uniq # => [1,2,3]
+            [1,2,1,2,3] unique # => [1,2,3]
       """
 
-      uniq_vals = []
+      unique_vals = []
       each: |x| {
-        unless: (uniq_vals includes?: x) do: {
-          uniq_vals << x
+        unless: (unique_vals includes?: x) do: {
+          unique_vals << x
         }
       }
-      uniq_vals
+      unique_vals
     }
 
     def size {
@@ -312,7 +404,7 @@ class Fancy {
       """
 
       i = 0
-      each: |x| {
+      each: {
         i = i + 1
       }
       i
@@ -328,31 +420,6 @@ class Fancy {
       size == 0
     }
 
-    def first {
-      """
-      @return First element in @self or @nil, if empty.
-      """
-
-      each: |x| {
-        return x
-      }
-      nil
-    }
-
-    def last {
-      """
-      @return Last element in @self or @nil, if empty.
-
-      Returns the last element in an Enumerable.
-      """
-
-      item = nil
-      each: |x| {
-        item = x
-      }
-      item
-    }
-
     def compact {
       """
       @return @Array@ with all non-nil elements in @self.
@@ -363,16 +430,16 @@ class Fancy {
             [1,2,nil,3,nil] compact # => [1,2,3]
       """
 
-      reject: |x| { x nil? }
+      reject: @{ nil? }
     }
 
-    def superior_by: comparison_block taking: selection_block ('identity) {
+    def superior_by: comparison_block taking: selection_block (@{ identity }) {
       """
       @comparison_block @Block@ to be used for comparison.
-      @selection_block @Block@ to be used for selecting the values to be used for comparison by @comparison_bock.
+      @selection_block @Block@ to be used for selecting the values to be used for comparison by @comparison_block.
       @return Superior element in @self in terms of @comparison_block.
 
-      Returns the superior element in the @Enumerable that has met
+      Returns the superior element in the @Fancy::Enumerable@ that has met
       the given comparison block with all other elements,
       applied to whatever @selection_block returns for each element.
       @selection_block defaults to @identity.
@@ -424,7 +491,7 @@ class Fancy {
       (assuming them to be @Number@s (implementing '+' & '*')).
       """
 
-      reduce: '+ init_val: 0
+      inject: 0 into: '+
     }
 
     def product {
@@ -433,7 +500,7 @@ class Fancy {
       (assuming them to be @Number@s (implementing @+ & @*)).
       """
 
-      reduce: '* init_val: 1
+      inject: 1 into: '*
     }
 
     def average {
@@ -451,7 +518,7 @@ class Fancy {
       @return @Array@ of @Array@s, partitioned by equal return values of calling @block with each element
 
       Example:
-            0 upto: 10 . partition_by: |x| { x < 3 }  # => [[0, 1, 2], [3, 4, 5, 6, 7, 8, 9, 10]]
+            (0..10) partition_by: @{ < 3 }  # => [[0, 1, 2], [3, 4, 5, 6, 7, 8, 9, 10]]
       """
       last = block call: [first]
       coll = []
@@ -475,7 +542,7 @@ class Fancy {
       @return Random element in @self.
       """
 
-      at: (rand(size))
+      at: $ size random
     }
 
     def sort_by: block {
@@ -534,8 +601,7 @@ class Fancy {
       In either case, it simply converts @self to an @Array@ and returns it in reversed order.
       """
 
-      rev = self to_a
-      rev reverse
+      self to_a reverse
     }
 
     def to_hash: block {
@@ -548,12 +614,12 @@ class Fancy {
               # => <[3 => \"foo\", 5 => \"hello\", 2 => \"ok\", 0 => \"\"]>
       """
 
-      h = <[]>
-      self each: |val| {
+
+      inject: <[]> into: |h val| {
         key = block call: [val]
         h[key]: val
+        h
       }
-      h
     }
 
     def reverse_each: block {
@@ -567,5 +633,36 @@ class Fancy {
 
       reverse each: block
     }
+
+    def count: block {
+      """
+      @block Predicate @Block@ called with each element.
+      @return @Fixnum@ that is the amount of elements in @self for which @block yields @true.
+
+      Example:
+            (0..10) count: @{ even? }                   # => 6 (even numbers are: 0,2,4,6,8,10)
+            [1,2,3] count: @{ odd? }                    # => 2
+            [1,2, \"foo\"] count: @{ class == String }  # => 1
+      """
+
+      count = 0
+      each: |x| {
+        { count = count + 1 } if: $ block call: [x]
+      }
+      count
+    }
+
+    def to_s {
+      """
+      @return @String@ concatenation of elements in @self.
+
+      Example:
+            (1,2,3) to_s # => \"123\"
+            [1,2,3] to_s # => \"123\"
+            \"foo\" to_s # => \"foo\"
+      """
+
+      join
+    }
   }
 }