fancy 0.8.0 → 0.9.0

data/lib/string.fy

@@ -57,10 +57,9 @@ class String {
     Indicates, if a @String@ consists only of whitespace.
     """
 
-    self =~ /^\s*$/ if_true: {
-      true
-    } else: {
-      false
+    match self {
+      case /^\s*$/ -> true
+      case _ -> false
     }
   }
 
@@ -232,4 +231,57 @@ class String {
 
     if: main? then: main_block else: else_block
   }
+
+  def snake_cased {
+    """
+    Returns a snake cased version of @self.
+    """
+
+    r1 = Regexp new("([A-Z]+)([A-Z][a-z])")
+    r2 = Regexp new("([a-z\d])([A-Z])")
+    gsub(r1,"\1_\2") gsub(r2,"\1_\2") tr("-", "_") lowercase
+  }
+
+  def camel_cased {
+    """
+    Returns camel cased version of @self which is expected
+    to be a snake cased @String@.
+    """
+
+    self split: "_" . map: @{ capitalize } . join
+  }
+
+  def uppercase? {
+    """
+    @return @true if @self is completely uppercase, @false otherwise.
+
+    Example:
+        \"F\"   uppercase? # => true
+        \"FOO\" uppercase? # => true
+        \"f\”   uppercase? # => false
+        \"Foo\" uppercase? # => false
+    """
+
+    { return false } if: blank?
+    uppercase == self
+  }
+
+  def lowercase? {
+    """
+    @return @true if @self is completely lowercase, @false otherwise.
+
+    Example:
+        \"f\”   lowercase? # => true
+        \"foo\" lowercase? # => true
+        \"F\"   lowercase? # => false
+        \"Foo\" lowercase? # => false
+    """
+
+    { return false } if: blank?
+    lowercase == self
+  }
+
+  def starts_with?: string {
+    from: 0 to: (string size - 1) == string
+  }
 }

data/lib/symbol.fy

@@ -45,11 +45,39 @@ class Symbol {
     recv receive_message: self
   }
 
+  def call_with_receiver: receiver {
+    call: [receiver]
+  }
+
+  def call: args with_receiver: receiver {
+    call: $ args unshift: receiver
+  }
+
   def arity {
-    1
+    m = message_name to_s
+    match m {
+      case /^:[a-zA-Z0-9_]+$/ -> m count: |c| { c == ":" }
+      case /^:\W+$/ -> 2
+      case _ -> m count: |c| { c == ":" } + 1
+    }
   }
 
   def to_sym {
     self
   }
+
+  def to_block {
+    """
+    @return @Block@ that sends @self to its first argument, passing along any remaining arguments.
+
+    Example:
+          'inspect to_block
+          # is equal to:
+          @{ inspect }
+    """
+
+    |args| {
+      call: args
+    }
+  }
 }

data/lib/time.fy

@@ -0,0 +1,17 @@
+class Time {
+  def Time duration: block {
+    """
+    @block @Block to be called & timed.
+    @return @Float@ that is the duration (in seconds) of calling @block.
+
+    Calls @block and times the runtime duration of doing so in seconds.
+
+    Example:
+          Time duration: { Thread sleep: 1 } # => >= 1.0
+    """
+
+    start = Time now
+    block call
+    Time now - start
+  }
+}

data/lib/vars.fy

@@ -1,6 +1,7 @@
-*stdin* = STDIN
-*stdout* = STDOUT
-*stderr* = STDERR
+*stdin*      = STDIN
+*stdout*     = STDOUT
+*stderr*     = STDERR
+*fancy_root* = File absolute_path: $ File join: (File dirname: __FILE__, "..")
 
 __AFTER__BOOTSTRAP__: {
   *stdin* documentation: """

data/lib/version.fy

@@ -1,6 +1,6 @@
 class Fancy {
   VERSION_MAJOR = 0
-  VERSION_MINOR = 8
+  VERSION_MINOR = 9
   VERSION_PATCH = 0
 
   VERSION = [VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH] join: "."

data/ruby_lib/interactive/hilight.rb

@@ -0,0 +1,125 @@
+# encoding: utf-8
+module CodeRay
+  module Scanners
+
+    # Fancy scanner by swarley.
+    class Fancy < Scanner
+
+      register_for :fancy
+      file_extension 'fy'
+
+      SPECIAL_FORMS = %w[
+        def throw try catch class
+      ]  # :nodoc:
+
+      CORE_FORMS = %w[
+        + - > < == != >= <= % ** * = && || =~
+      ]  # :nodoc:
+
+      PREDEFINED_CONSTANTS = %w[
+        true false nil
+      ]  # :nodoc:
+
+      IDENT_KIND = WordList.new(:ident).
+        add(SPECIAL_FORMS, :keyword).
+        add(CORE_FORMS, :keyword).
+        add(PREDEFINED_CONSTANTS, :predefined_constant)
+
+      KEYWORD_NEXT_TOKEN_KIND = WordList.new(nil).
+        add(%w[ def defn defn- definline defmacro defmulti defmethod defstruct defonce declare ], :function).
+        add(%w[ ns ], :namespace).
+        add(%w[ defprotocol defrecord ], :class)
+
+      BASIC_IDENTIFIER = /[a-zA-Z$%*\/_+!?&<>\-=]=?[a-zA-Z0-9$&*+!\/_?<>\-\#]*/
+      CLASS_IDENTIFIER = /[A-Z]+[A-Za-z0-9]*|[A-Z]+[A-Za-z0-9]\:\:|\:\:[A-Z]+[A-Za-z0-9]*/
+      IDENTIFIER = /(?!-\d)(?:(?:#{BASIC_IDENTIFIER}\.)*#{BASIC_IDENTIFIER}(?:\/#{BASIC_IDENTIFIER})?\.?)|\.\.?/
+      SYMBOL = /\'[A-z]+[A-z0-9\:\!\%\^\&\*\_\-\+\=\|\?\\\/\>\<\.]*/o
+      DIGIT = /\d+/
+      DIGIT10 = DIGIT
+      DIGIT16 = /[0-9a-f]/i
+      DIGIT8 = /[0-7]/
+      DIGIT2 = /[01]/
+      DECIMAL = /#{DIGIT}\.#{DIGIT}|-#{DIGIT}\.#{DIGIT}/
+      NUM = /(?:\-)*(?:#{DIGIT}|#{DIGIT16}|#{DIGIT8}|#{DIGIT2}|#{DECIMAL})/
+      MESSAGE = /[A-Za-z0-9\&\_]+?(?:\:|\?\:)/
+      CAPTURE = /\|.+?\|/
+
+      protected
+
+      def scan_tokens(encoder, options)
+        state = :initial
+        kind = nil
+
+        until eos?
+          case state
+          when :initial
+            if match = scan(/ \s+ | \n | , /x)
+              encoder.text_token match, :space
+            elsif match = scan(/\#.+?$/)
+              encoder.text_token match, :comment
+            elsif match = scan(/\{|\}|\@\{|\[|\]|\(|\)/)
+              encoder.text_token match, :operator
+            elsif match = scan(Regexp.new((%W(+ - @ > < == != >= <= % ** * = && || =~).map {|x| Regexp.escape x }).join '|'))
+              encoder.text_token match, :operator
+            elsif match = scan(/\.|\$/)
+              encoder.text_token match, :predefined_constant
+            elsif match = scan(CAPTURE)
+              encoder.text_token match, :predefined_constant
+            elsif match = scan(CLASS_IDENTIFIER)
+              encoder.text_token match, :constant
+            elsif match = scan(/\:\:/)
+              encoder.text_token match, :constant
+            elsif match = scan(MESSAGE)
+              encoder.text_token match, :keyword
+            elsif match = scan(/#{IDENTIFIER}/o)
+              kind = IDENT_KIND[match]
+              encoder.text_token match, kind
+              if rest? && kind == :keyword
+                if kind = KEYWORD_NEXT_TOKEN_KIND[match]
+                  encoder.text_token match, :space if match = scan(/\s+/o)
+                  encoder.text_token match, kind if match = scan(/#{IDENTIFIER}/o)
+                end
+              end
+            elsif match = scan(MESSAGE)
+              encoder.text_token match, :keyword
+            elsif match = scan(/#{SYMBOL}/o)
+              encoder.text_token match, :symbol
+            elsif match = scan(/\./)
+              encoder.text_token match, :operator
+            elsif match = scan(/ \# \^ #{IDENTIFIER} /ox)
+              encoder.text_token match, :type
+            elsif match = scan(/ (\#)? " /x)
+              state = self[1] ? :regexp : :string
+              encoder.begin_group state
+              encoder.text_token match, :delimiter
+            elsif match = scan(/#{NUM}/o) and not matched.empty?
+              encoder.text_token match, match[/[.e\/]/i] ? :float : :integer
+            else
+              encoder.text_token getch, :error
+            end
+
+          when :string, :regexp
+            if match = scan(/[^"\\]+|\\.?/)
+              encoder.text_token match, :content
+            elsif match = scan(/"/)
+              encoder.text_token match, :delimiter
+              encoder.end_group state
+              state = :initial
+            else
+              raise_inspect "else case \" reached; %p not handled." % peek(1),
+                encoder, state
+            end
+          else
+            raise 'else case reached'
+          end
+        end
+
+        if [:string, :regexp].include? state
+          encoder.end_group state
+        end
+
+        encoder
+      end
+    end
+  end
+end

data/tests/array.fy

@@ -356,10 +356,6 @@ FancySpec describe: Array with: {
     [1,2,3,4] any?: |x| { x > 4 } . is: false
   }
 
-  it: "is selected from it with each index" with: 'select_with_index: when: {
-    ["yooo",2,3,1,'foo,"bar"] select_with_index: |x i| { x is_a?: Fixnum } . is: [[2,1], [3,2], [1,3]]
-  }
-
   it: "returns its remaining (all but the first) elements as a new Array" with: 'rest when: {
     [1,2,3,4] rest is: [2,3,4]
     [] rest is: []
@@ -529,15 +525,20 @@ FancySpec describe: Array with: {
     arr is: [1,5,4,2,3]
   }
 
-  it: "sorts the array with a given comparison block" with: 'sort_by: when: {
+  it: "sorts the array with a given comparison block" with: 'sort: when: {
     arr = [1,5,4,2,3]
     sorted = [1,2,3,4,5]
-    arr sort_by: |a b| { a <=>  b } . is: sorted
+    arr sort: |a b| { a <=>  b } . is: sorted
     arr is: [1,5,4,2,3]
 
     arr = [(1,2), (0,1), (3,0)]
     sorted = [(3,0), (0,1), (1,2)]
-    arr sort_by: |a b| { a second <=> (b second) } . is: sorted
+    arr sort: |a b| { a second <=> (b second) } . is: sorted
+  }
+
+  it: "sorts the array by a given block" with: 'sort_by: when: {
+    arr = [(1,2), (0,1), (3,0)]
+    sorted = [(3,0), (0,1), (1,2)]
     arr sort_by: 'second . is: sorted
   }
 
@@ -550,4 +551,15 @@ FancySpec describe: Array with: {
     [] to_hash: @{ size } . is: <[]>
     [[1,2],[3,4,5]] to_hash: @{ size } . is: <[2 => [1,2], 3 => [3,4,5]]>
   }
+
+  it: "returns an sub-array within a given range" with: 'from:to: when: {
+    [] from: 0 to: 1 . is: []
+    [1] from: 0 to: 0 . is: [1]
+    [1] from: 0 to: 1 . is: [1]
+    [1] from: 0 to: 2 . is: [1]
+    [1] from: 0 to: -1 . is: [1]
+    [1] from: 0 to: -2 . is: []
+    [0,1,2,3] from: 0 to: 3 . is: [0,1,2,3]
+    [0,1,2,3] from: -1 to: 3 . is: [3]
+  }
 }

data/tests/block.fy

@@ -32,6 +32,24 @@ FancySpec describe: Block with: {
     i is be: { i >= 10 }
   }
 
+  it: "calls a block while another is true or calls the alternative" with: 'while_true:else: when: {
+    i = 0
+    { i < 10 } while_true: {
+      i = i + 1
+    } else: {
+      i = "nope"
+    }
+    i is: 10
+
+    i = 0
+    { i > 10 } while_true: {
+      i = i + 1
+    } else: {
+      i = "nope"
+    }
+    i is: "nope"
+  }
+
   it: "calls a block while another is not true (boolean false)" with: 'while_false: when: {
     i = 0
     {i == 10} while_false: {
@@ -206,17 +224,17 @@ FancySpec describe: Block with: {
     block call: [42] with_receiver: (ClassD new) . is: "in ClassD#inspect: 42"
   }
 
-  it: "calls a block using the ruby-send syntax" with: 'call: when: {
+  it: "calls a block using []" with: '[] when: {
     b = |x y| {
       x + y
     }
 
     b call: [2,3] . is: 5
-    b(2,3) . is: 5
+    b[(2,3)] . is: 5
 
     b2 = |x| { x * 5 }
-    b2("hello") is: ("hello" * 5)
-    b2("foo") is: (b2 call: ["foo"])
+    b2["hello"] is: ("hello" * 5)
+    b2["foo"] is: (b2 call: ["foo"])
   }
 
   it: "dynamically creates a object with slots defined in a Block" with: 'to_object when: {
@@ -239,6 +257,26 @@ FancySpec describe: Block with: {
     }
   }
 
+  it: "dynamically creates a new object with slots recursively defined in blocks" with: 'to_object_deep when: {
+    o = {
+      name: "Sarah Connor"
+      age: 42
+      city: "Los Angeles"
+      persecuted_by: {
+        name: "The Terminator"
+        age: 'unknown
+      }
+    } to_object_deep
+
+    o name is: "Sarah Connor"
+    o age is: 42
+    o city is: "Los Angeles"
+    o persecuted_by do: {
+      name is: "The Terminator"
+      age is: 'unknown
+    }
+  }
+
   it: "dynamically creates a hash with keys and values defined in a Block" with: 'to_hash when: {
     { } to_hash is: <[]>
     { foo: "bar" } to_hash is: <['foo => "bar"]>
@@ -302,4 +340,65 @@ FancySpec describe: Block with: {
                 ['city, "San Francisco"],
                 'male, 'programmer, 'happy]
   }
+
+  it: "returns a Block that calls self then a given Block" with: 'then: when: {
+    a = []
+    block = { a << 1 } then: { a << 2 }
+    block call
+    a is: [1,2]
+    block call
+    a is: [1,2,1,2]
+  }
+
+  it: "returns a Block that calls itself after a given Block" with: 'after: when: {
+    a = []
+    block = { a << 1 } after: { a << 2}
+    block call
+    a is: [2,1]
+    block call
+    a is: [2,1,2,1]
+  }
+
+  it: "calls itself while logging errors to *stdout*" with: 'call_with_errors_logged when: {
+    io = StringIO new
+    let: '*stdout* be: io in: {
+      {
+        "hello" println
+        2 / 0
+      } call_with_errors_logged
+    }
+    io string is: "hello\ndivided by 0\n"
+  }
+
+  it: "calls itself with arguments while logging errors to *stdout*" with: 'call_with_errors_logged: when: {
+    io = StringIO new
+    let: '*stdout* be: io in: {
+      |x y| {
+        "x: #{x} y: #{y}" println
+        2 / 0
+      } call_with_errors_logged: [10, 20]
+    }
+    io string is: "x: 10 y: 20\ndivided by 0\n"
+  }
+
+  it: "calls itself while logging errors to a given IO object" with: 'call_with_errors_logged_to: when: {
+    io = StringIO new
+    {
+      2 / 0
+    } call_with_errors_logged_to: io
+    io string is: "divided by 0\n"
+
+    io = StringIO new
+    { "fail!" raise! } call_with_errors_logged_to: io
+    io string is: "fail!\n"
+  }
+
+  it: "calls itself with arguments while logging errors to a given IO object" with: 'call:with_errors_logged_to: when: {
+    io = StringIO new
+    |x y| {
+      io println: "x: #{x} y: #{y}"
+      2 / 0
+    } call: [10, 20] with_errors_logged_to: io
+    io string is: "x: 10 y: 20\ndivided by 0\n"
+  }
 }