fancy 0.3.3 → 0.4.0

data/lib/rbx/range.fy

@@ -2,26 +2,40 @@ class Range {
   ruby_alias: 'to_a
   ruby_alias: '==
   ruby_alias: '===
+  ruby_alias: 'first
+  ruby_alias: 'last
 
-  include: FancyEnumerable
+  def initialize: @start to: @end {
+    """
+    @start Start element of Range.
+    @end End element of Range.
 
-  def initialize: start to: end {
-    initialize(start, end)
+    Initializes a new Range starting at @start and ending at @end.
+    """
+
+    initialize(@start, @end)
   }
 
   def each: block {
+    """
+    @block @Block@ to be called with every value in @self.
+    @return @self.
+
+    Calls @block on each value in @self. Used for iterating over a @Range@.
+    """
+
     try {
       val = nil
       each() |x| {
         try {
           val = block call: [x]
         } catch (Fancy NextIteration) => ex {
-          val = ex return_value
+          val = ex result
         }
       }
-      val
+      return self
     } catch (Fancy BreakIteration) => ex {
-      ex return_value
+      ex result
     }
   }
 }

data/lib/rbx/regexp.fy

@@ -1,4 +1,8 @@
 class Regexp {
+  """
+  Regular Expression class. Used by Regexp literals in Fancy.
+  """
+
   ruby_alias: 'inspect
   ruby_alias: 'to_s
 
@@ -9,8 +13,12 @@ class Regexp {
   def i {
     Regexp new(source(), true)
   }
-}
 
-class MatchData {
-  ruby_alias: '[]
+  def Regexp new: string {
+    new(string)
+  }
+
+  def Regexp [string] {
+    new(string)
+  }
 }

data/lib/rbx/string.fy

@@ -10,8 +10,15 @@ class String {
   ruby_alias: 'chomp
   ruby_alias: 'inspect
   ruby_alias: 'to_sym
+  ruby_alias: '<
+  ruby_alias: '>
 
-  def [] index {
+  alias_method: '[]: for_ruby: '[]=
+  alias_method: 'scan: for_ruby: 'scan
+
+  forwards_unary_ruby_methods
+
+  def [index] {
     """Given an Array of 2 Numbers, it returns the substring between the given indices.
        If given a Number, returns the character at that index."""
 
@@ -103,4 +110,47 @@ class String {
   def unpack: format {
     unpack(format)
   }
+
+  def replace: pattern with: replacement {
+    if: (replacement is_a?: Block) then: {
+      gsub(pattern, &replacement)
+    } else: {
+      gsub(pattern, replacement)
+    }
+  }
+
+  def replace!: pattern with: replacement {
+    if: (replacement is_a?: Block) then: {
+      gsub!(pattern, &replacement)
+    } else: {
+      gsub!(pattern, replacement)
+    }
+  }
+
+  def append: string {
+    """
+    @string Other @String@ to append on @self.
+    @return @self, but modified.
+
+    Appends another @String@ onto this @String@.
+
+    Example usage:
+        str = \"hello\"
+        str append: \" world!\"
+        str # => \"hello world!\"
+    """
+
+    append(string)
+  }
+
+  def includes?: substring {
+    """
+    @substring @String@ to be checked if it's in @self.
+    @return @true if @substring is in @self, @false otherwise.
+
+    Indicates if a given substring is in @self.
+    """
+
+    include?(substring)
+  }
 }

data/lib/rbx/stringio.fy

@@ -0,0 +1,17 @@
+require("stringio")
+
+class StringIO {
+  include: IOMixin
+  forwards_unary_ruby_methods
+  StringIO forwards_unary_ruby_methods
+
+  ruby_alias: '<<
+
+  def each: block {
+    each(&block)
+  }
+
+  def each_line: block {
+    each_line(&block)
+  }
+}

data/lib/rbx/symbol.fy

@@ -7,6 +7,20 @@ class Symbol {
   }
 
   def inspect {
-    "'" ++ (inspect() from: 1 to: -1)
+    "'" ++ to_s
+  }
+
+  def defined? {
+    """
+    @return @true, if @self is defined as a constant in senders scope, @false otherwise.
+
+    Indicates if a Symbol is defined as a constant in the senders scope.
+    """
+
+    binding = Binding setup(Rubinius VariableScope of_sender(),
+                            Rubinius CompiledMethod of_sender(),
+                            Rubinius StaticScope of_sender())
+
+    binding send('self) class const_defined?(self)
   }
 }

data/lib/rbx/system.fy

@@ -1,14 +1,32 @@
 require("open3")
 
 class System {
+  """
+  System class. Holds system-wide relevant methods.
+  """
+
   def System exit {
-    "Exit the running Fancy process."
+    """
+    Exit the running Fancy process.
+    """
 
     Kernel exit()
   }
 
+  def System exit: exitcode {
+    """
+    @exitcode Exit code (Fixnum) to be returned to the parent process.
+
+    Exit the running Fancy process with a given exit code.
+    """
+
+    Kernel exit(exitcode)
+  }
+
   def System do: command_str {
-    "Runs the given string as a system() command."
+    """
+    Runs the given string as a system() command.
+    """
 
     Kernel system(command_str)
   }

data/lib/rbx/tcp_server.fy

@@ -1,6 +1,9 @@
 require("socket")
 
 class TCPServer {
-  " TCP Server "
+  """
+  TCP Server
+  """
+
   ruby_alias: 'accept
 }

data/lib/rbx/tcp_socket.fy

@@ -1,7 +1,18 @@
 require("socket")
 
 class TCPSocket {
+  """
+  TCP Socket class.
+  """
+
   def TCPSocket open: server port: port {
+    """
+    @server Server hostname to open Socket on.
+    @port Server port to open Socket on.
+
+    Creates and opens a new @TCPSocket@ on @server and @port.
+    """
+
     open(server, port)
   }
 }

data/lib/rbx/time.fy

@@ -1,4 +1,10 @@
 class Time {
+  """
+  Time class. Used for even more timely stuff.
+  """
+
+  forwards_unary_ruby_methods
+
   metaclass ruby_alias: 'now
   ruby_alias: '==
   ruby_alias: '-

data/lib/rbx/tuple.fy

@@ -1,9 +1,8 @@
 Tuple = Rubinius Tuple
 class Tuple {
-  ruby_alias: 'size
-  ruby_alias: 'to_a
+  forwards_unary_ruby_methods
 
-  def initialize: size {
+  def Tuple new: size {
     """
     @size Size of the @Tuple@ (amount of values to hold).
 
@@ -11,7 +10,15 @@ class Tuple {
     E.g. if @size is @2, creates a 2-Tuple.
     """
 
-    initialize(size)
+    if: (size < 2) then: {
+      ArgumentError new: "Tuple size has to be a minimum of 2!" . raise!
+    }
+
+    new(size)
+  }
+
+  def Tuple new {
+    ArgumentError new: "Cannot initialize empty Tuple!" . raise!
   }
 
   def at: idx {
@@ -26,7 +33,7 @@ class Tuple {
     at(idx)
   }
 
-  def at: idx put: val {
+  def [idx]: val {
     """
     @idx Index of element to set.
     @val Value to set at given index.
@@ -35,4 +42,6 @@ class Tuple {
     """
     put(idx, val)
   }
+
+  alias_method: 'at:put: for: '[]:
 }

data/lib/set.fy

@@ -1,61 +1,176 @@
 class Set {
-  "A simple Set data structure class."
+  """
+  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: values {
+    """
+    @values @FancyEnumerable@ of values to be used as values for @self.
+
+    Initialize a new Set with a given collection of values.
+    """
+
+    @hash = <[]>
+    values each: |v| {
+      @hash[v]: true
+    }
   }
 
   def initialize {
-    "Initialize a new empty Set."
-    @values = []
+    """
+    Initialize a new empty Set.
+    """
+
+    @hash = <[]>
+  }
+
+  def values {
+    """
+    @return Values in self as an @Array@.
+    """
+
+    @hash keys
+  }
+
+  def size {
+    """
+    @return Amount of values in @self as a @Fixnum@.
+    """
+
+    @hash size
+  }
+
+  def empty? {
+    """
+    @return @true, if Set is emty, @false otherwise.
+
+    Indicates, if a Set is empty.
+    """
+
+    @hash empty?
   }
 
   def == other {
-    "Indicates, if two Sets are equal."
+    """
+    @other @Set@ to compare @self against.
+    @return @true, if self is equal to @other, @false otherwise.
+
+    Indicates, if two Sets are equal.
+    """
+
     if: (other is_a?: Set) then: {
-      @values == (other values)
+      if: (size == (other size)) then: {
+        return other all?: |x| { includes?: x }
+      }
     }
+    return false
   }
 
-  def Set [] arr {
-    "Initialize a new Array with a given Array of values."
-    Set new: arr
+  def Set [values] {
+    """
+    @values @FancyEnumerable@ of values used for new Set.
+
+    Initialize a new Set with a given collection of values.
+    """
+
+    Set new: values
   }
 
   def << value {
-    "Insert a value into the Set."
-    { @values << value } unless: (includes?: value)
+    """
+    @value Value to be inserted into @self.
+    @return @self.
+
+    Insert a value into the Set.
+    """
+
+    @hash[value]: true
+    self
   }
 
   def includes?: value {
-    "Indicates, if the Set includes a given value."
-    @values includes?: value
+    """
+    @value Value to be checked for if included in @self.
+    @return @true if @value in @self, @false otherwise.
+
+    Indicates, if the Set includes a given value.
+    """
+
+    @hash includes?: value
   }
 
   def each: block {
-    "Calls a given Block for each element of the Set."
-    @values each: block
-  }
+    """
+    @block @Block@ to be called with each value in @self.
+    @return @self.
 
-  def unknown_message: msg with_params: params {
-    if: (params empty?) then: {
-      @values send_message: msg
-    } else: {
-      @values send_message: msg with_params: params
-    }
+    Calls a given Block for each element of the Set.
+    """
+
+    @hash each_key: block
+    self
   }
 
   def to_s {
-    "Returns a String representation of a Set."
-    "Set" ++ @values to_s
+    """
+    Returns a @String@ representation of a Set.
+    """
+
+    "Set[" ++ (values join: ", ") ++ "]"
   }
 
   def inspect {
-    "Returns a detailed String representation of a Set."
-    to_s ++ " : Set"
+    """
+    Returns a detailed @String@ representation of a Set.
+    """
+
+    "Set[" ++ (values map: 'inspect . join: ", " . to_s) ++ "]"
+  }
+
+  def remove: obj {
+    """
+    @obj Object to be removed from @self.
+
+    Removes a given object from a Set, if available.
+    """
+
+    @hash delete: obj
+  }
+
+  def + other {
+    """
+    @other Other Set to use for creating union Set.
+    @return Union Set containing all values in both @self and @other.
+    """
+
+    Set[values + (other values)]
+  }
+
+  def - other {
+    """
+    @other Other Set to use for creating difference Set.
+    @return Difference Set by removing all values from @self that are in @other.
+    """
+
+    s = Set[values]
+    other values each: |v| {
+      s remove: v
+    }
+    s
+  }
+
+  def & other {
+    """
+    @other Other Set to use for creating Set.
+    @return Intersection Set containing only values that are in both @self and @other.
+    """
+
+    s = Set[values]
+    s values each: |v| {
+      { s remove: v } unless: (other includes?: v)
+    }
+    s
   }
 }