stupidedi 1.1.0

data/spec/examples/ruby/string.example

@@ -0,0 +1,111 @@
+require "spec_helper"
+
+describe "String#at" do
+  context "on an empty string" do
+    let(:string) { "" }
+
+    context "index zero" do
+      specify { string.at(0).should be_nil }
+    end
+
+    context "index one" do
+      specify { string.at(1).should be_nil }
+    end
+
+    context "index two" do
+      specify { string.at(2).should be_nil }
+    end
+  end
+
+  context %[on "abc"] do
+    let(:string) { "abc" }
+
+    context "index zero" do
+      specify { string.at(0).should == "a" }
+    end
+
+    context "index one" do
+      specify { string.at(1).should == "b" }
+    end
+
+    context "index two" do
+      specify { string.at(2).should == "c" }
+    end
+  end
+end
+
+describe "String#drop" do
+  context "from an empty string" do
+    let(:string) { "" }
+
+    context "zero characters" do
+      specify { string.drop(0).should == "" }
+    end
+
+    context "one character" do
+      specify { string.drop(1).should == "" }
+    end
+
+    context "two characters" do
+      specify { string.drop(2).should == "" }
+    end
+  end
+
+  context %[from "abc"] do
+    let(:string) { "abc" }
+
+    context "zero characters" do
+      specify { string.drop(0).should == "abc" }
+    end
+
+    context "one character" do
+      specify { string.drop(1).should ==  "bc" }
+    end
+
+    context "two characters" do
+      specify { string.drop(2).should ==   "c" }
+    end
+
+    context "three characters" do
+      specify { string.drop(3).should ==    "" }
+    end
+  end
+end
+
+describe "String#take" do
+  context "from an empty string" do
+    let(:string) { "" }
+
+    context "zero characters" do
+      specify { string.take(0).should == "" }
+    end
+
+    context "one character" do
+      specify { string.take(1).should == "" }
+    end
+
+    context "two characters" do
+      specify { string.take(2).should == "" }
+    end
+  end
+
+  context %[from "abc"] do
+    let(:string) { "abc" }
+
+    context "zero characters" do
+      specify { string.take(0).should == ""    }
+    end
+
+    context "one character" do
+      specify { string.take(1).should == "a"   }
+    end
+
+    context "two characters" do
+      specify { string.take(2).should == "ab"  }
+    end
+
+    context "three characters" do
+      specify { string.take(3).should == "abc" }
+    end
+  end
+end

data/spec/examples/ruby/symbol.example

@@ -0,0 +1,117 @@
+require "spec_helper"
+
+describe "Symbol#to_proc" do
+  include QuickCheck::Macro
+
+  it "calls nullary methods" do
+    :length.to_proc.call("abc").should == 3
+  end
+
+  it "calls nullary methods" do
+    :length.to_proc.call([1,1,1]).should == 3
+  end
+
+  it "shortens the syntax when passing unary blocks" do
+    %w(abc de f).map(&:length).should == [3, 2, 1]
+  end
+
+  it "shortens the syntax when passing unary blocks" do
+    [1, 4, 3, 0, 2].count(&:zero?).should == 1
+  end
+
+  it "calls unary methods" do
+    a = {          :a => 10, :b => 10}
+    b = {:a => 20,           :c => 20}
+
+    :merge.to_proc.call(a, b).should == a.merge(b)
+    :merge.to_proc.call(a, b).should == {:a => 20, :b => 10, :c => 20}
+  end
+
+  it "shortens the syntax when passing binary blocks" do
+    a = {          :a => 10, :b => 10}
+    b = {:a => 20, :b => 20, :c => 20}
+    c = {:b => 30, :c => 30, :d => 30}
+
+    [a, b, c].inject(&:merge).should == a.merge(b).merge(c)
+    [a, b, c].inject(&:merge).should == {:a => 20, :b => 30, :c => 30, :d => 30}
+  end
+
+  property("calls n-ary methods") do
+    map(between(0, 10)) { integer }
+  end.check do |as|
+    :call.to_proc.call(lambda{|*bs| bs }, *as).should == as
+  end
+
+  property("calls n-ary methods") do
+    map(between(0, 10)) { integer }
+  end.check do |as|
+    :call.to_proc.call(lambda{|*bs| bs.length }, *as).should == as.length
+  end
+
+# it "shortens the syntax when passing n-ary blocks", :ruby => 1.8 do
+#   list = []
+
+#   # avert your eyes, lisp haters!
+#   [[:zero?,     1       ],  #=> 1.__send__(:zero?)            == 1.zero?
+#    [:length,    "string"],  #=> "string".__send__(:length)    == "string".length
+#    [:+,         "a", "b"],  #=> "a".__send__(:+, "b")         == "a" + "b"
+#    [:fetch, {}, "a", "b"],  #=> {}.__send__(:fetch, "a", "b") == {}.fetch("a","b")
+#    [:[]=, list,  2, true],  #=> list.__send__(:[]=, 2, true)  == list[2] = true
+#    [:call, :length, "ab"]]. #=> :length.__send__(:call, "ab") == "ab".length
+
+#    map(&:call).should == [1.zero?,
+#                           "string".length,
+#                           ("a" + "b"),
+#                           {}.fetch("a","b"),
+#                           true,
+#                           "ab".length]
+#   list[2].should == true
+# end
+
+  it "shortens the syntax when passing n-ary blocks" do
+    list = []
+
+    # avert your eyes, lisp haters!
+    [[:zero?,     1       ],  #=> 1.__send__(:zero?)            == 1.zero?
+     [:length,    "string"],  #=> "string".__send__(:length)    == "string".length
+     [:+,         "a", "b"],  #=> "a".__send__(:+, "b")         == "a" + "b"
+     [:fetch, {}, "a", "b"],  #=> {}.__send__(:fetch, "a", "b") == {}.fetch("a","b")
+     [:[]=, list,  2, true],  #=> list.__send__(:[]=, 2, true)  == list[2] = true
+     [:call, :length, "ab"]]. #=> :length.__send__(:call, "ab") == "ab".length
+
+     map{|n,*as| n.call(*as) }.should ==
+                           [1.zero?,
+                            "string".length,
+                            ("a" + "b"),
+                            {}.fetch("a","b"),
+                            true,
+                            "ab".length]
+    list[2].should == true
+  end
+end
+
+describe "Symbol#call" do
+  include QuickCheck::Macro
+
+  it "requires at least one argument" do
+    lambda { :message.call }.should raise_error(ArgumentError)
+  end
+
+  it "sends a message to the first argument" do
+    receiver = mock("object")
+    receiver.should_receive(:message)
+    :message.call(receiver)
+  end
+
+  it "passes the remaining arguments along" do
+    receiver = mock("object")
+    receiver.should_receive(:message).with("a", "b")
+    :message.call(receiver, "a", "b")
+  end
+
+  it "does not flatten the argument list" do
+    receiver = mock("object")
+    receiver.should_receive(:message).with(["a", "b"], "c")
+    :message.call(receiver, ["a", "b"], "c")
+  end
+end

data/spec/examples/ruby/to_d.example

@@ -0,0 +1,90 @@
+# encoding: UTF-8
+require "spec_helper"
+
+describe Float do
+  describe "#to_d" do
+    include QuickCheck::Macro
+
+    # This fails inexplicably in Ruby 1.9.2, but works when
+    # other specs aren't run. It also behaves as expected
+    # in "rake console"...
+    property("f.to_d raises an error", :ruby => "1.8") do
+      float
+    end.check do |f|
+      lambda { f.to_d }.should raise_error
+    end
+  end
+end
+
+describe Integer do
+  describe "#to_d" do
+    include QuickCheck::Macro
+
+    property("int.to_d = int") do
+      integer
+    end.check{|n| n.should == n.to_d }
+
+    property("int.to_d is a BigDecimal") do
+      integer
+    end.check{|n| n.to_d.should be_a(BigDecimal) }
+  end
+end
+
+describe Rational do
+  describe "#to_d" do
+    include QuickCheck::Macro
+
+    property("rational.to_d ≈ rational") do
+      Rational(integer, integer)
+    end.check{|r| r.to_d.should be_within(1e-10).of(r) }
+
+    property("rational.to_d is a BigDecimal") do
+      Rational(integer, integer)
+    end.check{|r| r.to_d.should be_a(BigDecimal) }
+  end
+end
+
+describe BigDecimal do
+  describe "#to_d" do
+    include QuickCheck::Macro
+
+    property("decimal.to_d = decimal") do
+      integer.to_d
+    end.check{|b| b.to_d.should == b }
+  end
+end
+
+describe String do
+  describe "#to_d" do
+    include QuickCheck::Macro
+
+    context "when string has a valid format" do
+      property("string.to_d = BigDecimal(s)") do
+        Rational(integer, integer).to_d.to_s("F")
+      end.check{|s| s.to_d.should == BigDecimal(s) }
+
+      property("string.to_d = BigDecimal(s)") do
+        Rational(integer, integer).to_d.to_s
+      end.check{|s| s.to_d.should == BigDecimal(s) }
+
+      property("string.to_d = BigDecimal(s)") do
+        integer.to_s
+      end.check{|s| s.to_d.should == BigDecimal(s) }
+
+      property("string.to_d = BigDecimal(s)") do
+        Rational(integer, integer).to_f.to_s
+      end.check{|s| s.to_d.should == BigDecimal(s) }
+    end
+
+    context "when string has an invalid format" do
+      # This fails inexplicably in Ruby 1.9.2, but works when
+      # other specs aren't run. It also behaves as expected
+      # in "rake console"...
+      property("string.to_d raises an error", :ruby => "1.8") do
+        string
+      end.check do |s|
+        lambda { s.to_d }.should raise_error
+      end
+    end
+  end
+end

data/spec/examples/ruby/try.example

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+describe "Object#try" do
+  let(:object) { mock("object") }
+
+  it "calls a unary block" do
+    object.should_receive(:message).with(no_args)
+    object.try{|o| o.message }
+  end
+
+  it "calls a unary block" do
+    object.should_receive(:message).with(no_args)
+    object.try(&:message)
+  end
+
+  it "calls a nullary method" do
+    object.should_receive(:message).with(no_args)
+    object.try(:message)
+  end
+
+  it "calls a nullary method with a unary block" do
+    %w(a b c).try(:map, &:length).should == [1, 1, 1]
+  end
+
+  it "calls a nullary method with a binary block" do
+    %w(abc def ghi).try(:inject, &:+).should == "abcdefghi"
+  end
+
+  it "calls a unary method" do
+    object.should_receive(:message).with(:argument)
+    object.try(:message, :argument)
+  end
+
+  it "calls a unary method with a binary block" do
+    %w(abc def ghi).try(:inject, 1){|sum, e| sum + e.length }.should == 10
+  end
+
+  it "calls a binary method" do
+    object.should_receive(:message).with(:first, :second)
+    object.try(:message, :first, :second)
+  end
+end
+
+describe "NilClass#try" do
+  specify { nil.try{ whatever }.should be_nil }
+  specify { nil.try(:a).should be_nil }
+  specify { nil.try(:a) { whatever }.should be_nil }
+  specify { nil.try(:a, :b, :c).should be_nil }
+  specify { nil.try(:a, :b, :c) { whatever }.should be_nil }
+end