fancy 0.8.0 → 0.9.0

data/tests/future_proxy.fy

@@ -0,0 +1,8 @@
+# FancySpec describe: FutureProxy with: {
+#   it: "returns a FutureProxy" with: 'future when: {
+#     f = "foo" future
+#     "yo: #{f to_s inspect}" println
+#     "foo" future: @{ println }
+#   }
+# }
+nil

data/tests/hash.fy

@@ -1,20 +1,23 @@
 FancySpec describe: Hash with: {
   it: "is empty on initialization" with: 'empty? when: {
-    hash = <[]>
-    hash size is: 0
-    hash empty? is: true
+    <[]> tap: @{
+      size is: 0
+      empty? is: true
+    }
   }
 
   it: "is empty on initialization via Hash#new" with: 'size when: {
-    hash = Hash new
-    hash size is: 0
-    hash empty? is: true
+    Hash new tap: @{
+      size is: 0
+      empty? is: true
+    }
   }
 
   it: "contains one entry" when: {
-    hash = <['foo => "bar"]>
-    hash size is: 1
-    hash empty? is: false
+    <['foo => "bar"]> tap: @{
+      size is: 1
+      empty? is: false
+    }
   }
 
   it: "contains 10 square values after 10 insertions" with: 'at: when: {
@@ -152,6 +155,34 @@ FancySpec describe: Hash with: {
     }
   }
 
+  it: "returns a nested object with slots based on key-value pairs in hashes" with: 'to_object_deep when: {
+    hashes = [
+      <[]>,
+      <['name => "foo", 'age => 42]>
+    ]
+
+    hashes each: |h| {
+      o = h to_object_deep
+      o slots each: |s| {
+        o receive_message: s . is: $ h[s]
+      }
+    }
+
+
+    people = [
+      <['person => <['name => "foo", 'age => 42, 'city => "London"]>]>,
+      <['person => { name: "foo" age: 42 city: "London" }]> # even works with blocks, yay
+    ]
+
+    people each: @{
+      to_object_deep tap: @{
+        person name is: "foo"
+        person age is: 42
+        person city is: "London"
+      }
+    }
+  }
+
   it: "returns a hash with all entries for which a block yields true" with: 'select_keys: when: {
     <[]> select_keys: { true } . is: <[]>
     <[]> select_keys: { false } . is: <[]>
@@ -231,4 +262,96 @@ FancySpec describe: Hash with: {
       ]>
     ]>
   }
+
+  it: "updates its values with a block" with: 'update_values: when: {
+    <[]> update_values: @{ to_s } . is: <[]>
+    h = <['name => "Tom", 'age => 21]>
+    h update_values: @{ * 2 }
+    h is: <['name => "TomTom", 'age => 42]>
+  }
+
+  it: "updates its keys with a block" with: 'update_keys: when: {
+    <[]> update_keys: @{ to_s } . is: <[]>
+    h = <['name => "Tom", 'age => 21]>
+    h update_keys: @{ to_s * 2 }
+    h is: <["namename" => "Tom", "ageage" => 21]>
+  }
+
+  it: "returns a new hash based on self with values updated with a block" with: 'with_updated_values: when: {
+    <[]> with_updated_values: @{ * 2 } . is: <[]>
+    h1 = <['name => "Tom", 'age => 21]>
+    h2 = h1 with_updated_values: @{ * 2 }
+
+    h1 is: <['name => "Tom", 'age => 21]>
+    h2 is: <['name => "TomTom", 'age => 42]>
+  }
+
+  it: "returns a new hash based on self with keys updated with a block" with: 'with_updated_keys: when: {
+    <[]> with_updated_keys: @{ * 2 } . is: <[]>
+    h1 = <['name => "Tom", 'age => 21]>
+    h2 = h1 with_updated_keys: @{ to_s * 2 }
+
+    h1 is: <['name => "Tom", 'age => 21]>
+    h2 is: <["namename" => "Tom", "ageage" => 21]>
+  }
+
+  it: "calls a block with a value for a given key, if available" with: 'with_value_for_key:do:else: when: {
+    h = <['hello => "world", 1 => 2, "foo" => "barbaz"]>
+    else_ran? = false
+    else_block = { else_ran? = true }
+
+    h with_value_for_key: 'hello do: @{ is: "world" } else: else_block
+    h with_value_for_key: 1 do: @{ is: 2 } else: else_block
+    h with_value_for_key: "foo" do: @{ "barbaz" } else: else_block
+
+    else_ran? = false
+
+    h with_value_for_key: "not in hash" do: {
+      "should not call this block!" raise!
+    } else: else_block
+
+    else_ran? is: true
+  }
+
+  it: "sets the default value on creation" when: {
+    h = Hash new: "default"
+    h['key] is: "default"
+    h['key]: "hallo"
+    h['key] is: "hallo"
+  }
+
+  it: "sets the default value" with: 'default: when: {
+    h = Hash new
+    h default is: nil
+    h default: "foo"
+    h default is: "foo"
+
+    block = |_ k| { k }
+    h default: block
+    h default is: block
+  }
+
+  it: "returns the default value" with: 'default when: {
+    Hash new default is: nil
+    Hash new: "foo" . default is: "foo"
+
+    block = |h k| { k * 2 }
+    Hash new: block . default is: block
+    Hash new: block . tap: |h| {
+      h[1] is: 2
+      h["foo"] is: "foofoo"
+    }
+  }
+
+  it: "returns the return value for a given key" with: 'default_for: when: {
+    Hash new: 2 . tap: @{
+      default_for: "foo" . is: 2
+      default_for: "bar" . is: 2
+    }
+
+    Hash new: |_ k| { k * 2 } . tap: @{
+      default_for: "foo" . is: "foofoo"
+      default_for: 100 . is: 200
+    }
+  }
 }

data/tests/html.fy

@@ -16,18 +16,35 @@ FancySpec describe: HTML with: {
       }
     }
 
-    h to_s is: \
-"""<html>
-  <head>
-    <title>
-      Hello
-    </title>
-  </head>
-  <body>
-    <h1>
-      Hello, World!
-    </h1>
-  </body>
-</html>"""
+    html = """
+    <html>
+      <head>
+        <title>
+          Hello
+        </title>
+      </head>
+      <body>
+        <h1>
+          Hello, World!
+        </h1>
+      </body>
+    </html>
+    """
+
+    h to_s is: $ html skip_leading_indentation
+  }
+
+  it: "indents the generated html by a common offset" when: {
+    h = HTML new: @{
+      foo: @{ bar: "baz" }
+    } indentation: 3
+
+    h to_s lines is: [
+      "   <foo>",
+      "     <bar>",
+      "       baz",
+      "     </bar>",
+      "   </foo>"
+    ]
   }
 }

data/tests/integer.fy

@@ -5,5 +5,8 @@ FancySpec describe: Integer with: {
     100 decimals is: [1, 0, 0]
     123 decimals is: [1, 2, 3]
     998811 decimals is: [9, 9, 8, 8, 1, 1]
+    -0 decimals is: [0]
+    -10 decimals is: [1,0]
+    -1234 decimals is: [1, 2, 3, 4]
   }
 }

data/tests/method.fy

@@ -3,17 +3,6 @@ FancySpec describe: Method with: {
     [1,2,3] method: "each:" . class is: Method
   }
 
-  # it: "returns the (correct) sender object of the MessageSend" when: {
-  #   class SenderTest {
-  #     def give_me_the_sender! {
-  #       __sender__
-  #     }
-  #   }
-
-  #   x = SenderTest new
-  #   x give_me_the_sender! is: self
-  # }
-
   it: "returns the amount of arguments a Method takes" with: 'arity when: {
     class Foo {
       def no_args
@@ -140,4 +129,10 @@ FancySpec describe: Method with: {
     def fooaa: bar ("fo");
     fooaa: 10
   }
+
+  it: "can handle a singleton method def with an empty body" when: {
+    obj = "foo"
+    def obj bar
+    def obj bar: @x
+  }
 }

data/tests/object.fy

@@ -25,7 +25,7 @@ FancySpec describe: Object with: {
     { self a_singleton_method } raises: NoMethodError
   }
 
-  it: "returns its class" when: {
+  it: "returns its class" with: 'class when: {
     nil class is: NilClass
     true class is: TrueClass
     "foo" class is: String
@@ -44,25 +44,32 @@ FancySpec describe: Object with: {
     obj this_is_not_defined: "It's true!" . is: "Got: this_is_not_defined: It's true!"
   }
 
-  it: "returns a correct string representation" when: {
+  it: "returns a correct string representation" with: 'to_s when: {
     3 to_s is: "3"
     'foo to_s is: "foo"
     nil to_s is: ""
   }
 
-  it: "returns a correct array representation" when: {
+  it: "returns a correct array representation" with: 'to_a when: {
     nil to_a is: []
     'foo to_a is: ['foo]
     <['foo => "bar", 'bar => "baz"]> to_a is =? [['bar, "baz"], ['foo, "bar"]]
   }
 
-  it: "returns a correct fixnum representation" when: {
+  it: "returns a hash based on own slot values" with: 'to_hash when: {
+    nil to_hash is: <[]>
+    false to_hash is: <[]>
+    true to_hash is: <[]>
+    (0..10) each: @{ to_hash is: <[]> }
+  }
+
+  it: "returns a correct fixnum representation" with: 'to_i when: {
     nil to_i is: 0
     3 to_i is: 3
     3.28437 to_i is: 3
   }
 
-  it: "is an Object of the correct Class (or Superclass)" when: {
+  it: "is an Object of the correct Class (or Superclass)" with: 'is_a?: when: {
     Object new is_a?: Object . is: true
     "foo" is_a?: String . is: true
     "foo" is_a?: Object . is: true

data/tests/option_parser.fy

@@ -1,7 +1,7 @@
 require: "lib/option_parser"
 
 FancySpec describe: OptionParser with: {
-  it: "parses an option with no argument" when: {
+  it: "parses an option with no argument" with: 'parse: when: {
     parsed_option? = false
 
     o = OptionParser new: @{
@@ -15,7 +15,7 @@ FancySpec describe: OptionParser with: {
     parsed_option? is: true
   }
 
-  it: "parses no option if none are passed" when: {
+  it: "parses no option if none are passed" with: 'parse: when: {
     parsed_option? = false
     o = OptionParser new: @{
       with: "--foo [arg]" doc: "bla" do: |arg| {
@@ -31,7 +31,7 @@ FancySpec describe: OptionParser with: {
     parsed_option? is: false
   }
 
-  it: "parses an option with an argument" when: {
+  it: "parses an option with an argument" with: 'parse: when: {
     parsed_option? = false
     passed_args = []
 
@@ -77,4 +77,13 @@ FancySpec describe: OptionParser with: {
     o parse: args
     args is: [1, 2]
   }
+
+  it: "parses options as a hash" with: 'parse_hash: when: {
+    o = OptionParser new: @{
+      with: "--some-option [some-value]" doc: "foo"
+    }
+
+    hash = o parse_hash: ["foo", "bar", "--some-option", "hello world!", "baz"]
+    hash is: <["--some-option" => "hello world!"]>
+  }
 }

data/tests/string.fy

@@ -55,6 +55,25 @@ FancySpec describe: String with: {
     "hello world" drop_while: |c| { c != " " } . join: "" . is: " world"
   }
 
+  it: "drops the last element" with: 'drop_last: when: {
+    [] drop_last is: []
+    [1] drop_last is: []
+    "foo" drop_last is: ["f", "o"]
+    (1,2,3) drop_last is: [1,2]
+  }
+
+  it: "rops the last n elements" with: 'drop_last: when: {
+    [] drop_last: 1 . is: []
+    [] drop_last: 2 . is: []
+    [] drop_last: 0 . is: []
+    [1] drop_last: 0 . is: [1]
+    [1] drop_last: 1 . is: []
+    [1] drop_last: 2 . is: []
+    [1,2,3] drop_last: 1 . is: [1, 2]
+    [1,2,3] drop_last: 2 . is: [1]
+    [1,2,3] drop_last: 3 . is: []
+  }
+
   it: "is empty" with: 'empty? when: {
     "" empty? is: true
     " " empty? is: false
@@ -70,7 +89,7 @@ FancySpec describe: String with: {
     "hello world" at: 5 . blank? is: true
   }
 
-  it: "is evaluated as fancy code and returns the correct value" when: {
+  it: "is evaluated as fancy code and returns the correct value" with: 'eval when: {
     x = "'foo" eval
     x is: 'foo
     "3 + 4" eval is: 7
@@ -78,6 +97,14 @@ FancySpec describe: String with: {
     "33.33" eval is: 33.33
   }
 
+  it: "parses empty code with newlines correctly" with: 'eval when: {
+    "" eval is: nil
+    "\n" eval is: nil
+    "\n\n" eval is: nil
+    "\n \n \n" eval is: nil
+    " \n " eval is: nil
+  }
+
   it: "returns itself times n" with: '* when: {
     "foo" * 2 is: "foofoo"
     "f" ++ ("o" * 2) ++ "bar" is: "foobar"
@@ -206,4 +233,45 @@ FancySpec describe: String with: {
 
     """ multiline? is: true
   }
+
+  it: "returns a snake cased version of itself" with: 'snake_cased when: {
+    "" snake_cased is: ""
+    "Foo" snake_cased is: "foo"
+    "FooB" snake_cased is: "foo_b"
+    "FooBarBaz" snake_cased is: "foo_bar_baz"
+    "Foo Bar Baz" snake_cased is: "foo bar baz"
+  }
+
+  it: "returns a camel cased version of itself" with: 'camel_cased when: {
+    "" camel_cased is: ""
+    "foo" camel_cased is: "Foo"
+    "foo_" camel_cased is: "Foo"
+    "foo_bar_baz" camel_cased is: "FooBarBaz"
+  }
+
+  it: "returns true if its uppercase" with: 'uppercase? when: {
+    "" uppercase? is: false
+    "foo" uppercase? is: false
+    "F" uppercase? is: true
+    "Foo" uppercase? is: false
+    "ABC" uppercase? is: true
+  }
+
+  it: "returns true if its lowercase" with: 'lowercase? when: {
+    "" lowercase? is: false
+    "foo" lowercase? is: true
+    "foA" lowercase? is: false
+    "A" lowercase? is: false
+    "abc" lowercase? is: true
+  }
+
+  it: "returns true if its begins with another string" with: 'starts_with?: when: {
+    "" starts_with?: "" . is: true
+    "foo" starts_with?: "f" . is: true
+    "foo" starts_with?: "fo" . is: true
+    "foo" starts_with?: "foo" . is: true
+    "foo" starts_with?: "fooo" . is: false
+    "foo" starts_with?: "oo" . is: false
+    "foo" starts_with?: "" . is: false
+  }
 }

data/tests/symbol.fy

@@ -28,8 +28,32 @@ FancySpec describe: Symbol with: {
     if: x then: 'foo else: 'bar . is: "foo"
   }
 
+  it: "returns its arity correctly (when interpreted as a method name)" with: 'arity when: {
+    'foo arity is: 1
+    'foo_bar_baz arity is: 1
+    ('+, '-, '*, '/) each: @{ arity is: 2 }
+    'foo: arity is: 2
+    'foo:bar: arity is: 3
+    'foo:bar:baz: arity is: 4
+  }
+
   it: "returns self" with: 'to_sym when: {
     'foo to_sym is: 'foo
     'bar to_sym is: 'bar
   }
+
+  it: "returns itself as a Block" with: 'to_block when: {
+    b = 'inspect to_block
+    b call: [2] . is: "2"
+    b call: ["foo"] . is: "\"foo\""
+
+    str = "hello, world yo!\"foo\""
+    b call: [str] . is: $ @{ inspect } call: [str]
+
+    add = '+ to_block
+    { add call: [2] } raises: ArgumentError
+    add call: [0,1] . is: 1
+    add call: [2,3] . is: 5
+    { add call: [2,3,4] } raises: ArgumentError
+  }
 }