fancy 0.3.0

data/lib/rbx/tuple.fy

@@ -0,0 +1,37 @@
+Tuple = Rubinius Tuple
+class Tuple {
+  ruby_alias: 'size
+
+  def initialize: size {
+    """
+    @size Size of the @Tuple@ (amount of values to hold).
+
+    Initializes a new @Tuple@ with a given amount of element slots.
+    E.g. if @size is @2, creates a 2-Tuple.
+    """
+
+    initialize(size)
+  }
+
+  def at: idx {
+    """
+    @idx Index for the element to get.
+    @return Element at the given index within the @Tuple@ or @nil.
+
+    Returns an element at a given indes.
+    Possibly throws an @Rubinius::ObjectBoundsExceededError@.
+    """
+
+    at(idx)
+  }
+
+  def at: idx put: val {
+    """
+    @idx Index of element to set.
+    @val Value to set at given index.
+
+    Sets a value for a given index within a @Tuple@.
+    """
+    put(idx, val)
+  }
+}

data/lib/set.fy

@@ -0,0 +1,61 @@
+class Set {
+  "A simple Set data structure class."
+
+  include: FancyEnumerable
+  read_slots: ['values]
+
+  def initialize: arr {
+    "Initialize a new Set with a given Array of values."
+    @values = arr uniq
+  }
+
+  def initialize {
+    "Initialize a new empty Set."
+    @values = []
+  }
+
+  def == other {
+    "Indicates, if two Sets are equal."
+    if: (other is_a?: Set) then: {
+      @values == (other values)
+    }
+  }
+
+  def Set [] arr {
+    "Initialize a new Array with a given Array of values."
+    Set new: arr
+  }
+
+  def << value {
+    "Insert a value into the Set."
+    { @values << value } unless: (includes?: value)
+  }
+
+  def includes?: value {
+    "Indicates, if the Set includes a given value."
+    @values includes?: value
+  }
+
+  def each: block {
+    "Calls a given Block for each element of the Set."
+    @values each: block
+  }
+
+  def unknown_message: msg with_params: params {
+    if: (params empty?) then: {
+      @values send: msg
+    } else: {
+      @values send: msg params: params
+    }
+  }
+
+  def to_s {
+    "Returns a String representation of a Set."
+    "Set" ++ @values to_s
+  }
+
+  def inspect {
+    "Returns a detailed String representation of a Set."
+    self to_s ++ " : Set"
+  }
+}

data/lib/stack.fy

@@ -0,0 +1,51 @@
+class Stack {
+  """
+  A simple Stack container class.
+  """
+
+  def initialize {
+    @arr = []
+  }
+
+  def initialize: size {
+    "Initializes a new Stack with a given size."
+
+    @arr = Array new: size
+  }
+
+  def push: obj {
+    "Pushes a value onto the Stack."
+
+    @arr << obj
+  }
+
+  def << obj {
+    "Same as Stack#push:."
+
+    @arr << obj
+  }
+
+  def pop {
+    "Pops the top-of-stack element from the Stack and returns it."
+
+    @arr remove_at: (self size - 1)
+  }
+
+  def top {
+    "Returns the top-of-stack element."
+
+    @arr last
+  }
+
+  def size {
+    "Returns the size of the Stack."
+
+    @arr size
+  }
+
+  def empty? {
+    "Indicates, if the Stack is empty."
+
+    @arr empty?
+  }
+}

data/lib/string.fy

@@ -0,0 +1,58 @@
+class String {
+  """
+  Strings are sequences of characters and behave as such.
+  All literal Strings within Fancy code are instances of the String
+  class.
+
+  They also include FancyEnumerable, which means you can use all the
+  common sequence methods on them, like +map:+, +select:+ etc.
+  """
+
+  include: FancyEnumerable
+
+  def ++ other {
+    "Concatenate the String with another String"
+
+    self + (other to_s)
+  }
+
+  def whitespace? {
+    "Indicates, if a String is empty or a single whitespace character."
+
+    self empty? or: (self == " ")
+  }
+
+  def blank? {
+    "Indicates, if a String consists only of whitespace."
+
+    self =~ /^\s*$/ if_do: {
+      true
+    } else: {
+      false
+    }
+  }
+
+  def * num {
+    "Returns a string that is the num-fold concatenation of itself."
+
+    str = ""
+    num to_i times: {
+      str = str ++ self
+    }
+    str
+  }
+
+  def words {
+    self split
+  }
+
+  def raise! {
+    "Raises a new StdError with self as the message."
+    StdError new: self . raise!
+  }
+
+  def rest {
+    "Returns a @String@ containing all but the first character."
+    from: 1 to: -1
+  }
+}

data/lib/struct.fy

@@ -0,0 +1,13 @@
+class Struct {
+   def Struct new: fields {
+      struct = ruby: "new" args: fields
+      struct read_write_slots: fields
+      struct define_method: "new:" with: |values| {
+        instance = struct new()
+        fields each_with_index: |f i| {
+          instance send: f params: [values at: i]
+        }
+      }
+      struct
+   }
+}

data/lib/symbol.fy

@@ -0,0 +1,23 @@
+class Symbol {
+  """
+  Symbols are unique identifiers and only created once.
+
+  If there are several occurrances of the same Symbol literal within
+  Fancy code, they all refer to the same Symbol object.
+  """
+
+  def call: 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]
+    """
+
+    if: (arg is_a?: Array) then: {
+      arg first send: self params: $ arg rest
+    } else: {
+      arg send: self
+    }
+  }
+
+}

data/lib/true_class.fy

@@ -0,0 +1,43 @@
+class TrueClass {
+  "TrueClass. The class of the singleton true value."
+
+  def TrueClass new {
+    # always return true singleton object when trying to create a new
+    # TrueClass instance
+    true
+  }
+
+  def if_true: then_block else: else_block {
+    "Calls the then_block."
+    then_block call
+  }
+
+  def if_true: block {
+    "Calls the block."
+    block call
+  }
+
+  def if_false: block {
+    "Returns nil."
+    nil
+  }
+
+  def nil? {
+    "Returns nil."
+    false
+  }
+
+  def false? {
+    "Returns nil."
+    false
+  }
+
+  def true? {
+    "Returns true."
+    true
+  }
+
+  def not {
+    false
+  }
+}

data/lib/tuple.fy

@@ -0,0 +1,68 @@
+class Tuple {
+  """
+  Tuples are fixed-size containers providing index-based access to its
+  elements.
+  """
+
+  include: FancyEnumerable
+
+  def [] idx {
+    """
+    Forwards to @Tuple#at:@.
+    """
+
+    at: idx
+  }
+
+  def each: block {
+    self size times: |i| {
+      block call: [self at: i]
+    }
+  }
+
+  def == other {
+    """
+    @other Other @Tuple@ to compare @self with.
+    @return @true, if tuples are equal element-wise, @false otherwise.
+
+    Compares two @Tuple@s with each other.
+    """
+
+    if: (other is_a?: Tuple) then: {
+      if: (self size == (other size)) then: {
+        self size times: |i| {
+          unless: (self[i] == (other[i])) do: {
+            return false
+          }
+        }
+        return true
+      }
+    }
+    return false
+  }
+
+  def inspect {
+    str = "("
+    self each: |v| {
+      str = str ++ v
+    } in_between: {
+      str = str ++ ", "
+    }
+    str = str ++ ")"
+    str
+  }
+
+  def Tuple === obj {
+    """
+    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.
+    """
+
+    if: (obj is_a?: Tuple) then: {
+      [obj] + (obj map: 'identity)
+    }
+  }
+}

data/lib/version.fy

@@ -0,0 +1,6 @@
+VERSION_MAJOR = 0
+VERSION_MINOR = 3
+VERSION_PATCH = 0
+VERSION_SUFFIX = "alpha"
+
+FANCY_VERSION = [VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH] join: "." ++ " " ++ VERSION_SUFFIX

data/tests/argv.fy

@@ -0,0 +1,13 @@
+FancySpec describe: "ARGV & predefined values" with: {
+  it: "should have ARGV correctly defined" when: {
+    ARGV empty? should_not == true
+  }
+
+  it: "should have a __FILE__ variable defined" when: {
+    __FILE__ should_not == nil
+  }
+
+  it: "should have the __FILE__ value be an element in ARGV" when: {
+    ARGV any?: |a| { File basename(a) == (File basename(__FILE__)) } . should == true
+  }
+}

data/tests/array.fy

@@ -0,0 +1,343 @@
+FancySpec describe: Array with: {
+  it: "should contain three number values after adding them" for: '<< when: {
+    arr = []
+    arr << 1
+    arr << 2
+    arr << 3
+    arr should == [1,2,3]
+    arr size should == 3
+  }
+
+  it: "should iterate over all elements, calling a block" for: 'each: when: {
+    sum = 0
+    retval = [1,2,3,4,5] each: |x| { sum = sum + x }
+    retval should == sum
+    sum should == ([1,2,3,4,5] sum)
+  }
+
+  it: "should be empty after clearing it" for: 'clear when: {
+    arr = [1,2,3]
+    arr size should == 3
+    arr should == [1,2,3]
+    arr clear
+    arr size should == 0
+    arr should == []
+  }
+
+  it: "should be true for empty? when it's empty" for: 'empty? when: {
+    [] empty? should == true
+    [1] empty? should == false
+    [1,2] empty? should == false
+    [1,2,3] empty? should == false
+  }
+
+  it: "should be an empty array after initialization" for: 'new when: {
+    arr = Array new
+    arr size should == 0
+  }
+
+  it: "should return the correct value via index access" for: 'at: when: {
+    arr = ['a, 10, "hello, world"]
+    arr at: 2 . should == "hello, world"
+    arr at: 1 . should == 10
+    arr at: 0 . should == 'a
+  }
+
+  it: "should NOT include the items" for: "includes?:" when: {
+    arr = ['a, 10, "hello, world"]
+    arr includes?: "hello" . should == false
+    arr includes?: 11 . should == false
+    arr includes?: 'b . should == false
+  }
+
+  it: "should include the items" for: 'includes?: when: {
+    arr = ['a, 10, "hello, world"]
+    arr includes?: "hello, world" . should == true
+    arr includes?: 10 . should == true
+    arr includes?: 'a . should == true
+  }
+
+  it: "should return the correct index (or nil) for an element" for: 'index: when: {
+    arr = [1, 2, 'a, 3, 4]
+    arr index: 1 . should == 0
+    arr index: 2 . should == 1
+    arr index: 'a . should == 2
+    arr index: 3 . should == 3
+    arr index: 4 . should == 4
+    arr index: 'foo . should == nil
+  }
+
+  it: "should return an Array of all its indices" for: 'indices when: {
+    ['foo, 'bar, 'baz] indices should == [0,1,2]
+    [] indices should == []
+    ['foo] indices should == [0]
+  }
+
+  it: "should return all indices for an element as an Array" for: 'indices: when: {
+    arr = [1, 2, 'a, 3, 2, 'a]
+    arr indices_of: 1 . should == [0]
+    arr indices_of: 2 . should == [1, 4]
+    arr indices_of: 'a . should == [2, 5]
+    arr indices_of: 3. should == [3]
+    arr indices_of: 'foo . should == []
+  }
+
+  it: "should find the value" for: 'find: when: {
+    arr = ['foo, "bar", 'baz, 1234]
+
+    arr find: "bar" . should == "bar"
+
+    arr find: |x| {
+      x is_a?: String . if_true: {
+        x from: 0 to: 1 == "ba"
+      }
+    } . should == "bar"
+
+    arr find: "foo" . should == nil
+  }
+
+  it: "should NOT find the value" for: 'find: when: {
+    arr = ['foo, "bar", 'baz, 1234]
+
+    arr find: "ba" . should == nil
+
+    arr find: |x| {
+      x is_a?: String . if_true: {
+        x from: 0 to: 1 == "aa"
+      }
+    } . should == nil
+
+    arr find: "foobar" . should == nil
+  }
+
+  it: "should find the value via a block" for: 'find_by: when: {
+    arr = [1, 2, 'foo, "yo", nil, true]
+    arr find_by: |x| { x is_a?: String } . should == "yo"
+    arr find_by: |x| { x is_a?: Block } . should == nil
+  }
+
+  it: "should return the last element" for: 'last when: {
+    arr = [1, 2, 3, 'foo, "bar"]
+    arr last should == "bar"
+    (arr last == 'foo) should == false
+  }
+
+  it: "should return the last n element" for: 'last: when: {
+    arr = [1, 2, 3, 'foo, "bar"]
+    arr last: 1 . should == [arr last]
+    arr last: 2 . should == ['foo, "bar"]
+    arr last: 3 . should == [3, 'foo, "bar"]
+    arr last: 4 . should == [2, 3, 'foo, "bar"]
+    arr last: 5 . should == [1, 2, 3, 'foo, "bar"]
+    arr last: (arr size) . should == arr
+    arr last: (arr size + 1) . should == arr
+  }
+
+  it: "should return an array containing the values at the given indices" for: 'values_at: when: {
+    arr = [1, 2, 3, 'foo, "bar"]
+    arr values_at: [1, 3, 4, 10] . should == [2, 'foo, "bar", nil]
+  }
+
+  it: "should return unique values only" for: 'uniq when: {
+    arr = ['foo, 'bar, "baz", 'foo, "baz", "hello", 1, 0, 0, 1, 'bar, 'foo, "hello"]
+    arr uniq should == ['foo, 'bar, "baz", "hello", 1, 0]
+  }
+
+  it: "should prepend self to another array" for: '>> when: {
+    arr1 = ['foo, 'bar, 'baz]
+    arr2 = [1, 2, 3]
+    (arr1 >> arr2) should == ['foo, 'bar, 'baz, 1, 2, 3]
+  }
+
+  it: "should get an element by the []-operator" for: "[]" when: {
+    arr = ['foo, 'bar, 'baz]
+    arr[0] should == 'foo
+    arr[1] should == 'bar
+    arr[2] should == 'baz
+  }
+
+  it: "should get a sub-array by the []-operator" for: "[]" when: {
+    arr = ['foo, 'bar, 'baz]
+    arr[[0,2]] should == arr
+    arr[[0,1]] should == ['foo, 'bar]
+    arr[[0,1]] should == (arr from: 0 to: 1)
+    arr[[0,0]] should == [arr[0]]
+    arr[[1,1]] should == [arr[1]]
+    arr[[2,2]] should == [arr[2]]
+    arr[[0,-1]] should == arr
+    arr[[-1,-1]] should == [arr last]
+    arr[[-2,-1]] should == ['bar, 'baz]
+    arr[[-2,-1]] should == (arr last: 2)
+  }
+
+  it: "should join all elements with a string to a new string" for: 'join: when: {
+    arr = ['foo, 'bar, 'baz]
+    arr join: "," . should == "foo,bar,baz"
+  }
+
+  it: "should join all elements with the empty string to a new string" for: 'join when: {
+    arr = ['foo, 'bar, 'baz]
+    arr join should == "foobarbaz"
+  }
+
+  it: "should remove an element at a given index" for: 'remove_at: when: {
+    arr = [1, 'foo, 2, 'bar, 3, 'baz]
+    # remove_at: returns the removed element
+    arr remove_at: 1 . should == 'foo
+    arr should == [1, 2, 'bar, 3, 'baz]
+    arr remove_at: 3
+    arr should == [1, 2, 'bar, 'baz]
+    arr remove_at: [2, 3]
+    arr should == [1, 2]
+    arr = [1, 'hello, 2, 'world]
+    # remove_at: returns the removed elements as an array
+    # if it was passed an array of indexes
+    arr remove_at: [0, 2, 3] . should == [1, 2, 'world]
+    arr should == ['hello]
+  }
+
+  it: "should remove all occurances of a given object in-place" for: 'remove: when: {
+    arr = [1, 2, 'foo, 3, 'foo, 2, 4]
+    arr remove: 2
+    arr should == [1, 'foo, 3, 'foo, 4]
+    arr remove: 'foo
+    arr should == [1, 3, 4]
+  }
+
+  it: "should remove all elements with the given Array of indices" for: 'remove_at: when: {
+    arr = [1, 2, 'foo, 3, 'foo, 2, 4]
+    arr remove_at: [0, 2, 4]
+    arr should == [2, 3, 2, 4]
+  }
+
+  it: "should remove all elements that meet a given condition block" for: 'remove_if: when: {
+    arr = [1, 2, 3, 2, 5, 4]
+    arr remove_if: |x| { x < 3 }
+    arr should == [3, 5, 4]
+  }
+
+  it: "should remove all nil-value entries when calling compact" for: 'compact when: {
+    ['foo, nil, 'bar, nil, 'baz] compact should == ['foo, 'bar, 'baz]
+    [] compact should == []
+    [nil] compact should == []
+    ['foo] compact should == ['foo]
+  }
+
+  it: "should remove all nil-value entries in place when calling compact!" for: 'compact! when: {
+    arr = ['foo, nil, 'bar, nil, 'baz]
+    arr compact! should == ['foo, 'bar, 'baz]
+    arr should == ['foo, 'bar, 'baz]
+    [] compact! should == []
+    [nil] compact! should == []
+    ['foo] compact! should == ['foo]
+  }
+
+  it: "should remove all values that meet a condition" for: 'reject!: when: {
+    arr = ['foo, 'bar, 1, 2, 'baz, "hello"]
+    arr reject!: |x| { x is_a?: String } . should == ['foo, 'bar, 1, 2, 'baz]
+    arr should == ['foo, 'bar, 1, 2, 'baz]
+    arr reject!: |x| { x is_a?: Fixnum }
+    arr should == ['foo, 'bar, 'baz]
+  }
+
+  it: "should remove all values that don't meet a condition" for: 'select!: when: {
+    arr = ['foo, 'bar, 1, 2, 'baz, "hello"]
+    arr select!: |x| { x is_a?: Fixnum }
+    arr should == [1, 2]
+  }
+
+  it: "should return a new Array with all elements that meet a given condition" for: 'select: when: {
+    arr = [1, 2, "foo", 'bar, 120]
+    arr select: |x| { x is_a?: Fixnum } . should == [1,2,120]
+    arr should == [1, 2, "foo", 'bar, 120] # select: is non-destructive
+  }
+
+  it: "should print the maximum value in the list" for: 'max when: {
+    [1,2,3,4] max should == 4
+    [1,5,-3,2,6,-4,-2] max should == 6
+  }
+
+  it: "should print the minimum value in the list" for: 'min when: {
+    [1,2,3,4] min should == 1
+    [1,5,-3,2,6,-4,-2] min should == -4
+  }
+
+  it: "should return an Array containing the elements n times." for: '* when: {
+    [1,2,3,4,5] * 2 should == [1,2,3,4,5,1,2,3,4,5]
+    [1,2,3] * 2 should == ([1,2,3] + [1,2,3])
+    ['a,'b,'c] * 4 should == ['a,'b,'c, 'a,'b,'c, 'a,'b,'c, 'a,'b,'c]
+  }
+
+  it: "should return the concatenation of two Arrays" for: '+ when: {
+    ([1,2,3,4] + [-1,-2,-3,-4]) should == [1,2,3,4,-1,-2,-3,-4]
+  }
+
+  it: "should return true for all elements" for: 'all?: when: {
+    [1,2,3,4] all?: |x| { x < 5 } . should == true
+    [1,2,3,4] all?: |x| { x > 0 } . should == true
+    [1,2,3,4] all?: |x| { x > 4 } . should == false
+  }
+
+  it: "should return true for any elements" for: 'any?: when: {
+    [1,2,3,4] any?: |x| { x > 3 } . should == true
+    [1,2,3,4] any?: |x| { x < 4 } . should == true
+    [1,2,3,4] any?: |x| { x > 4 } . should == false
+  }
+
+  it: "should be selected from it with each index" for: 'select_with_index: when: {
+    ["yooo",2,3,1,'foo,"bar"] select_with_index: |x i| { x is_a?: Fixnum } . should == [[2,1], [3,2], [1,3]]
+  }
+
+  it: "should return its remaining (all but the first) elements as a new Array" for: 'rest when: {
+    [1,2,3,4] rest should == [2,3,4]
+    [] rest should == []
+    100 upto: 1000 . rest should == (101 upto: 1000)
+  }
+
+  it: "should return itself as a string" for: 'to_s when: {
+    [1,2,3] to_s should == "123"
+  }
+
+  it: "should call a given block between calling the each block" for: 'each:in_between: when: {
+    arr = []
+    [1,2,3] each: |x| { arr << x } in_between: { arr << "-" }
+    arr should == [1, "-", 2, "-", 3]
+
+    str = ""
+    ['foo, 'bar, 'baz] each: |x| { str = str ++ (x to_s) } in_between: { str = str ++ " " }
+    str should == "foo bar baz"
+  }
+
+  it: "should return the reduced value for a given block and initial value" for: 'reduce:init_val: when: {
+    arr = 1 upto: 10
+    arr sum should == (arr reduce: '+ init_val: 0)
+    arr product should == (arr reduce: '* init_val: 1)
+    arr to_s should == (arr reduce: '++ init_val: "")
+  }
+
+  it: "should return the reverse of itself" for: 'reverse when: {
+    [1,2,3] reverse should == [3,2,1]
+    1 upto: 10 . reverse should == (10 downto: 1)
+  }
+
+  it: "should inverse in-place" for: 'reverse! when: {
+    arr = [1,2,3]
+    arr reverse! should == [3,2,1]
+    arr should == [3,2,1]
+  }
+
+  it: "should take elements from itself as long a block yields true" for: 'take_while: when: {
+    1 upto: 15 . take_while: |x| { x < 10 } . should == (1 upto: 9)
+  }
+
+
+  it: "should drop elements from itself as long a block yields true" for: 'drop_while: when: {
+    1 upto: 15 . drop_while: |x| { x < 10 } . should == (10 upto: 15)
+  }
+
+  it: "should partition an array via a given block" for: 'partition_by: when: {
+    arr = [1,2,2,3,3,3,4,4,4,4,5]
+    arr partition_by: 'identity . should == [[1], [2,2], [3,3,3], [4,4,4,4], [5]]
+    arr partition_by: @{== 2} . should == [[1], [2,2], [3,3,3,4,4,4,4,5]]
+  }
+}