fancy 0.6.0 → 0.7.0

data/lib/rbx/object.fy

@@ -97,7 +97,7 @@ class Object {
     Dynamically sends a given message (without parameters) to @self.
     """
 
-    send(message_name: message)
+    __send__(message message_name)
   }
 
   def receive_message: message with_params: params {
@@ -108,16 +108,7 @@ class Object {
     Dynamically sends a given message with parameters to @self.
     """
 
-   ruby: (message_name: message) args: params
-  }
-
-  def message_name: symbol {
-    symbol = symbol to_s
-    val = symbol include?(":")
-    match val {
-      case true -> symbol
-      case false -> ":" <<(symbol)
-    }
+    ruby: (message message_name) args: params
   }
 
   def responds_to?: message {
@@ -128,7 +119,7 @@ class Object {
     Indicates if an object responds to a given message.
     """
 
-    respond_to?(message_name: message)
+    respond_to?(message message_name)
   }
 
   def extend: class {
@@ -140,4 +131,13 @@ class Object {
 
     metaclass include: class
   }
+
+  def lambda: block {
+    """
+    @block @Block@ to be used as the lambda's body.
+    @return @Proc@ with Ruby's lambda semantics (e.g. @return always becomes @return_local)
+    """
+
+    lambda(&block)
+  }
 }

data/lib/rbx/proc.fy

@@ -0,0 +1,7 @@
+class Proc {
+  forwards_unary_ruby_methods
+  alias_method: 'call for_ruby: 'call
+  def call: args {
+    call(*args)
+  }
+}

data/lib/rbx/string.fy

@@ -24,7 +24,7 @@ class String {
     match index {
       case Array -> from: (index[0]) to: (index[1])
       case Tuple -> ruby_idx: index
-      case _ -> ruby_idx: index . chr()
+      case _ -> if: (ruby_idx: index) then: @{ chr() }
     }
   }
 
@@ -162,4 +162,8 @@ class String {
 
     gsub(substring, substitution)
   }
+
+  def message_name {
+    self to_sym message_name to_s
+  }
 }

data/lib/rbx/symbol.fy

@@ -23,4 +23,13 @@ class Symbol {
 
     binding send('self) class const_defined?(self)
   }
+
+  def message_name {
+    symbol = self to_s
+    val = symbol include?(":")
+    match val {
+      case true -> symbol to_sym
+      case false -> ":" <<(symbol) to_sym
+    }
+  }
 }

data/lib/string.fy

@@ -5,7 +5,7 @@ class String {
   class.
 
   They also include @Fancy::Enumerable@, which means you can use all the
-  common sequence methods on them, like +map:+, +select:+ etc.
+  common sequence methods on them, like @Fancy::Enumerable#map:@, @Fancy::Enumerable#select:@ etc.
   """
 
   include: Fancy Enumerable

data/lib/tuple.fy

@@ -1,3 +1,5 @@
+ObjectBoundsExceededError = Rubinius ObjectBoundsExceededError
+
 class Tuple {
   """
   Tuples are fixed-size containers providing index-based access to its
@@ -23,44 +25,54 @@ class Tuple {
     t
   }
 
-  def [idx] {
-    """
-    Forwards to @Tuple@#at:.
+  def Tuple === obj {
     """
+    Matches @Tuple@ class against an object.
+    If the given object is a Tuple instance, return a Tuple object.
 
-    at: idx
-  }
-
-  def first {
-    """
-    @return The first element in @self.
+    @obj Object to be matched against
+    @return Tuple instance containing the values of @obj to be used in pattern matching.
     """
 
-    at: 0
+    if: (obj is_a?: Tuple) then: {
+      [obj] + (obj map: 'identity)
+    }
   }
 
-  def second {
-    """
-    @return The second element in @self.
-    """
-
-    at: 1
+  def Tuple name {
+    "Tuple"
   }
 
-  def third {
+  def [idx] {
     """
-    @return The third element in @self.
+    Forwards to @Tuple@#at:.
     """
 
-    at: 2
+    at: idx
   }
 
-  def fourth {
+  def from: from to: to {
     """
-    @return The fourth element in @self.
+    @from Start index for sub-array.
+    @to End index ofr sub-array.
+
+    Returns sub-array starting at from: and going to to:
     """
 
-    at: 3
+    if: (from < 0) then: {
+      from = size + from
+    }
+    if: (to < 0) then: {
+      to = size + to
+    }
+    subarr = []
+    try {
+      from upto: to do: |i| {
+        subarr << (at: i)
+      }
+    } catch ObjectBoundsExceededError {
+    }
+    subarr
   }
 
   def each: block {
@@ -129,21 +141,11 @@ class Tuple {
     str
   }
 
-  def Tuple === obj {
+  def to_s {
     """
-    Matches @Tuple@ class against an object.
-    If the given object is a Tuple instance, return a Tuple object.
-
-    @obj Object to be matched against
-    @return Tuple instance containing the values of @obj to be used in pattern matching.
+    @return @String@ concatenation of elements in @self.
     """
 
-    if: (obj is_a?: Tuple) then: {
-      [obj] + (obj map: 'identity)
-    }
-  }
-
-  def Tuple name {
-    "Tuple"
+    join
   }
 }

data/lib/version.fy

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

data/tests/array.fy

@@ -195,9 +195,9 @@ FancySpec describe: Array with: {
     arr values_at: [1, 3, 4, 10] . is: [2, 'foo, "bar", nil]
   }
 
-  it: "returns unique values only" with: 'uniq when: {
+  it: "returns unique values only" with: 'unique when: {
     arr = ['foo, 'bar, "baz", 'foo, "baz", "hello", 1, 0, 0, 1, 'bar, 'foo, "hello"]
-    arr uniq is: ['foo, 'bar, "baz", "hello", 1, 0]
+    arr unique is: ['foo, 'bar, "baz", "hello", 1, 0]
   }
 
   it: "prepends self to another array" with: '>> when: {
@@ -225,6 +225,10 @@ FancySpec describe: Array with: {
     arr[[-1,-1]] is: [arr last]
     arr[[-2,-1]] is: ['bar, 'baz]
     arr[[-2,-1]] is: (arr last: 2)
+    # works with any Enumerable as argument:
+    arr[(0,2)] is: $ arr[[0,2]]
+    arr[(1,2)] is: $ arr[[1,2]]
+    arr[(0,-1)] is: $ arr[[0,-1]]
   }
 
   it: "joins all elements with a string to a new string" with: 'join: when: {
@@ -329,6 +333,14 @@ FancySpec describe: Array with: {
     ([1,2,3,4] + [-1,-2,-3,-4]) is: [1,2,3,4,-1,-2,-3,-4]
   }
 
+  it: "returns all elements not in another collection" with: '- when: {
+    [] - [] is: []
+    [] - [0] is: []
+    [1,2,3,4] - [2,4] is: [1,3]
+    [1,2,3] - [1,2,3,5] is: []
+    ["foo", "bar", "baz"] - ["bar"] is: ["foo", "baz"]
+  }
+
   it: "returns true for all elements" with: 'all?: when: {
     [1,2,3,4] all?: |x| { x < 5 } . is: true
     [1,2,3,4] all?: |x| { x > 0 } . is: true

data/tests/class.fy

@@ -567,4 +567,83 @@ FancySpec describe: Class with: {
     WithConstants["Nested"] is_a?: Class . is: true
     WithConstants["Nested"] is: WithConstants Nested
   }
+
+  it: "sets a constants value" with: '[]: when: {
+    Kernel["Object"] is: Object
+    { Kernel["Something"] } raises: NameError
+    Kernel["Something"]: Array
+    { Kernel["Something"] is: Array } does_not raise: NameError
+  }
+
+  it: "delegates methods correctly" with: 'delegate:to_slot: when: {
+    class Delegation {
+      delegate: ('[], '[]:, '<<, 'to_s, 'to_s:, 'inspect, 'each:in_between:) to_slot: 'object
+      def initialize: @object
+    }
+
+    d = Delegation new: "hello, world!"
+    d to_s is: "hello, world!"
+    d inspect is: $ "hello, world!" inspect
+    d = Delegation new: 2
+    d to_s is: "2"
+    d inspect is: "2"
+    d to_s: 2 . is: "10"
+    d = Delegation new: [1,2,3]
+    d << 5
+    d get_slot: 'object . is: [1,2,3,5]
+    d << nil
+    d get_slot: 'object . is: [1,2,3,5, nil]
+    d[2]: "foo"
+    d get_slot: 'object . is: [1,2,"foo",5,nil]
+    d[1] is: 2
+  }
+
+  it: "allows delegating only a single method" with: 'delegate:to_slot: when: {
+    class Delegation {
+      delegate: 'to_s to_slot: 'number
+      read_write_slot: 'number
+    }
+
+    d = Delegation new
+    d number: 5
+    d to_s is: $ 5 to_s
+  }
+
+  it: "defines a lazy slot" with: 'lazy_slot:value: when: {
+    class LazyClass {
+      lazy_slot: 'foo value: { Thread sleep: 0.01; 42 * @count }
+      def initialize: @count
+    }
+
+    f = LazyClass new: 2
+    start = Time now
+    f foo is: 84
+    Time now - start >= 0.01 is: true
+    start = Time now
+    f foo is: 84
+    Time now - start <= 0.01 is: true
+  }
+
+  it: "returns a string representation of itself and its superclass, if any" with: 'inspect when: {
+    class MySuperClass
+    class MySubClass : MySuperClass
+
+    Fixnum inspect is: "Fixnum : Integer"
+    MySuperClass inspect is: "MySuperClass : Object"
+    MySubClass inspect is: "MySubClass : MySuperClass"
+    Object inspect is: "Object"
+  }
+
+  it: "returns the right amount of instance methods" with: 'instance_methods: when: {
+    class NoMethods
+    class OneMethod {
+      def bar
+    }
+
+    NoMethods instance_methods: false . size is: 0
+    OneMethod instance_methods: false . size is: 1
+
+    NoMethods instance_methods is: $ Object instance_methods
+    Set[OneMethod instance_methods] is: $ Set[Object instance_methods + (OneMethod instance_methods: false)]
+  }
 }

data/tests/dynamic_key_hash.fy

@@ -0,0 +1,16 @@
+FancySpec describe: DynamicKeyHash with: {
+  it: "has the correct keys & values defined" when: {
+    dkh = DynamicKeyHash new
+    dkh tap: @{
+      name: "Chris"
+      age: 25
+      country: "Germany"
+    }
+
+    hash = dkh hash
+    Set[hash keys] is: $ Set[['name, 'age, 'country]]
+    hash['name] is: "Chris"
+    hash['age] is: 25
+    hash['country] is: "Germany"
+  }
+}

data/tests/dynamic_slot_object.fy

@@ -0,0 +1,28 @@
+FancySpec describe: DynamicSlotObject with: {
+  it: "has the correct slots defined" when: {
+    dso = DynamicSlotObject new
+    dso tap: @{
+      name: "Chris"
+      age: 25
+      country: "Germany"
+    }
+
+    dso object tap: @{
+      slots is: ['name, 'age, 'country]
+      class is: Object
+
+      # getters
+      name is: "Chris"
+      age is: 25
+      country is: "Germany"
+
+      # setters
+      name: "Jack"
+      name is: "Jack"
+      age: 26
+      age is: 26
+      country: "USA"
+      country is: "USA"
+    }
+  }
+}

data/tests/dynamic_value_array.fy

@@ -0,0 +1,12 @@
+FancySpec describe: DynamicValueArray with: {
+  it: "has the correct values defined" when: {
+    dva = DynamicValueArray new
+    dva tap: @{
+      name: "Chris"
+      age: 25
+      country: "Germany"
+      another_symbol
+      and_another_one
+    } . array is: [['name, "Chris"], ['age, 25], ['country, "Germany"], 'another_symbol, 'and_another_one]
+  }
+}

data/tests/enumerable.fy

@@ -5,4 +5,50 @@ FancySpec describe: Fancy Enumerable with: {
     [[1,2], [2,3,4], [], [1]] superior_by: '> taking: 'size . is: [2,3,4]
     [[1,2], [2,3,4], [-1]] superior_by: '< taking: 'first . is: [-1]
   }
+
+  it: "chain-maps all blocks on all values" with: 'map_chained: when: {
+    (1,2,3) map_chained: ('doubled, 'squared, 'to_s) . is: ["4", "16", "36"]
+    (1,2,3) map_chained: (@{ + 1 }, 'to_s) . is: ["2", "3", "4"]
+    [] map_chained: ('class, 'name) . is: []
+    [1, "foo", 'hello] map_chained: ('class, 'name) . is: ["Fixnum", "String", "Symbol"]
+  }
+
+  it: "maps over its elements with their index" with: 'map_with_index: when: {
+    (1,2,3) map_with_index: |x i| {
+      x + i
+    } . is: [1,3,5]
+
+    [1,2,3,4] map_with_index: |x i| {
+      i
+    } . is: [0,1,2,3]
+
+    [] map_with_index: |x i| { i } . is: []
+  }
+
+  it: "counts the amount of elements for which a block yields true" with: 'count: when: {
+    [1,2,3] count: @{ even? } . is: 1
+    (0..10) count: @{ even? } . is: 6
+    (0..10) count: @{ odd? } . is: 5
+    "foo" count: @{ == "o" } . is: 2
+    "foo" count: @{ != "o" } . is: 1
+    (1,2,3) count: @{ < 2 } . is: 1
+    [] count: { true } . is: 0
+    [1] count: { true } . is: 1
+    [1] count: { false } . is: 0
+  }
+
+  it: "returns a string concatenation of all elements in self" with: 'to_s when: {
+    (1,2,3) to_s is: "123"
+    [1,2,3] to_s is: "123"
+    "foo" to_s is: "foo"
+    [] to_s is: ""
+
+    class MyCollection {
+      include: Fancy Enumerable
+      def each: block {
+        (0..5) each: block
+      }
+    }
+    MyCollection new to_s is: "012345"
+  }
 }