stupidedi 1.2.20 → 1.4.1

data/spec/examples/ruby/blank_spec.rb

@@ -1,63 +0,0 @@
-require "spec_helper"
-using Stupidedi::Refinements
-
-describe Object do
-  describe "#blank?" do
-    it "is false" do
-      Object.new.blank?.should_not be
-    end
-  end
-end
-
-describe String do
-  describe "#blank?" do
-    context "if string contains non-whitespace characters" do
-      specify "then is string.blank? is false" do
-        "abc".blank?.should_not be
-        "  x".blank?.should_not be
-        " x ".blank?.should_not be
-        "x  ".blank?.should_not be
-      end
-    end
-
-    context "if string is #empty?" do
-      specify "then string.blank? is true" do
-        "".blank?.should be
-      end
-    end
-
-    context "if string contains only whitespace characters" do
-      specify "then string.blank? is true" do
-        "  ".blank?.should be
-        "\t".blank?.should be
-        "\n".blank?.should be
-        "\r".blank?.should be
-        "\f".blank?.should be
-      end
-    end
-  end
-end
-
-describe Enumerable do
-  describe "#blank?" do
-    context "if enum.empty?" do
-      specify "then enum.blank? is true" do
-        [].blank?.should be
-      end
-    end
-
-    context "if not enum.empty?" do
-      specify "then enum.blank? is false" do
-        [0].blank?.should_not be
-      end
-    end
-  end
-end
-
-describe NilClass do
-  describe "#blank?" do
-    it "is true" do
-      nil.blank?.should be
-    end
-  end
-end

data/spec/examples/ruby/count_spec.rb

@@ -1,69 +0,0 @@
-require "spec_helper"
-using Stupidedi::Refinements
-
-describe "Enumerable#count" do
-  include QuickCheck::Macro
-
-  context "with no given arguments" do
-    property("returns #length") do
-      with(:size, between(0, 20)) { array { integer }}
-    end.check do |enumerable|
-      enumerable.count.should == enumerable.length
-    end
-  end
-
-  context "with a given literal" do
-    let(:enumerable) { %w(a b a b c d a) }
-
-    it "returns the number of occurrences" do
-      enumerable.count("g").should == 0
-      enumerable.count("a").should == 3
-      enumerable.count("b").should == 2
-      enumerable.count("c").should == 1
-      enumerable.count("d").should == 1
-    end
-  end
-
-  context "with a given block argument" do
-    context "that always evaluates false" do
-      it "returns 0" do
-        %w(a b c d e f).count { false }.should == 0
-      end
-
-      property("returns 0") do
-        with(:size, between(0, 20)) { array { integer }}
-      end.check do |enumerable|
-        enumerable.count { false }.should == 0
-      end
-    end
-
-    context "that always evaluates true" do
-      it "returns #length" do
-        %w(a b c d e f).count { true }.should == 6
-      end
-
-      property("returns #length") do
-        with(:size, between(0, 20)) { array { integer }}
-      end.check do |enumerable|
-        enumerable.count { true }.should == enumerable.length
-      end
-    end
-
-    context "that evaluates true or false" do
-      it "returns the number of elements that satisfy the predicate" do
-        %w(a bc d ef g hi).count{|s| s.length == 2 }.should == 3
-      end
-
-      property("returns the number of elements that satisfy the predicate") do
-        divisor    = choose([1,2,3,4])
-        enumerable = with(:size, between(0, 20)) { array { integer }}
-
-        [enumerable, divisor]
-      end.check do |enumerable, divisor|
-        enumerable.count{|n| n.modulo(divisor).zero? }.should ==
-          enumerable.inject(0){|sum,n| sum + ((n.modulo(divisor).zero?) ? 1 : 0) }
-      end
-    end
-
-  end
-end

data/spec/examples/ruby/object_spec.rb

@@ -1,99 +0,0 @@
-require "spec_helper"
-using Stupidedi::Refinements
-
-describe "Object#cons" do
-  include QuickCheck::Macro
-
-  context "with no argument" do
-    it "creates a singleton list" do
-      0.cons.should == [0]
-    end
-  end
-
-  context "with an array argument" do
-    it "prepends the object" do
-      "a".cons(%w(b c d)).should == %w(a b c d)
-    end
-
-    property("prepends the object") do
-      [character, array { character }]
-    end.check do |a, as|
-      a.cons(as).length.should == 1 + as.length
-      a.cons(as).first.should  == a
-    end
-
-    it "does not destructively modify the argument" do
-      array = %w(b c d)
-        "a".cons(array)
-      array.should == %w(b c d)
-    end
-  end
-end
-
-describe "Object#snoc" do
-  context "with no argument" do
-    it "creates a singleton list" do
-      0.snoc.should == [0]
-    end
-  end
-
-  context "with an array argument" do
-    it "appends the object" do
-      "d".snoc(%w(a b c)).should == %w(a b c d)
-    end
-
-    it "does not destructively modify the argument" do
-      array = %w(a b c)
-        "d".snoc(array)
-      array.should == %w(a b c)
-    end
-  end
-end
-
-describe "Object#bind" do
-  it "provides an alternative syntax to local variables and parethesized expressions" do
-    (1.bind{|a| a + 2 } * 3).
-      should == ((1 + 2) * 3)
-  end
-
-  it "provides an alternative syntax to local variables and parethesized expressions" do
-    1.bind{|a| (a + 2).bind{|b| b * 3 }}.
-      should == ((1 + 2) * 3)
-  end
-
-  it "provides an alternative syntax to local variables and parethesized expressions" do
-    1.bind{|a| a.bind{|b| b + 2 }.bind{|c| c * 3 }}.
-      should == ((1 + 2) * 3)
-  end
-end
-
-describe "Object#tap" do
-  let(:object) { double("object") }
-
-  it "requires a block argument" do
-    lambda { object.tap }.should raise_error(LocalJumpError)
-  end
-
-  it "yields the object to a block argument" do
-    expect(object).to receive(:message).with(:argument)
-    object.tap{|o| o.message(:argument) }
-  end
-
-  it "returns the object" do
-    object.tap { :whatever }.should eq(object)
-  end
-end
-
-describe "Object#eigenclass" do
-  let(:object) { double("object") }
-
-  it "returns a Class" do
-    object.eigenclass.should be_a(Class)
-  end
-
-  it "cannot be instantiated" do
-    lambda { object.eigenclass.new }.should raise_error(TypeError)
-  end
-
-  specify { object.eigenclass.should == (class << object; self; end) }
-end

data/spec/examples/ruby/string_spec.rb

@@ -1,112 +0,0 @@
-require "spec_helper"
-using Stupidedi::Refinements
-
-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_spec.rb

@@ -1,99 +0,0 @@
-require "spec_helper"
-using Stupidedi::Refinements
-
-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
-
-  pending "shortens the syntax when passing n-ary blocks",
-    unless: RUBY_VERSION >= "2.4" || RUBY_PLATFORM == "java" 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 = double("object")
-    expect(receiver).to receive(:message)
-    :message.call(receiver)
-  end
-
-  it "passes the remaining arguments along" do
-    receiver = double("object")
-    expect(receiver).to receive(:message).with("a", "b")
-    :message.call(receiver, "a", "b")
-  end
-
-  it "does not flatten the argument list" do
-    receiver = double("object")
-    expect(receiver).to receive(:message).with(["a", "b"], "c")
-    :message.call(receiver, ["a", "b"], "c")
-  end
-end

data/spec/examples/ruby/to_d_spec.rb

@@ -1,91 +0,0 @@
-# encoding: UTF-8
-require "spec_helper"
-using Stupidedi::Refinements
-
-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", :ruby => "1.8") 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