stupidedi 1.3.23 → 1.4.0

data/spec/examples/ruby/try_spec.rb

@@ -1,51 +0,0 @@
-require "spec_helper"
-using Stupidedi::Refinements
-
-describe "Object#try" do
-  let(:object) { double("object") }
-
-  it "calls a unary block" do
-    expect(object).to receive(:message).with(no_args)
-    object.try{|o| o.message }
-  end
-
-  it "calls a unary block" do
-    expect(object).to receive(:message).with(no_args)
-    object.try(&:message)
-  end
-
-  it "calls a nullary method" do
-    expect(object).to 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
-    expect(object).to 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
-    expect(object).to 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

data/spec/examples/stupidedi/audit_spec.rb

@@ -1,58 +0,0 @@
-require "spec_helper"
-
-describe Stupidedi::Schema::Auditor, :focus => true do
-
-  def self.definitions
-    ansi = Stupidedi::Color.ansi
-
-    @definitions ||= lambda do |root|
-      # Prevent walking in circles due to cycles in the graph
-      history = Hash.new
-      results = []
-
-      f = lambda do |namespace, recurse|
-        history[namespace] = true
-
-        for child in namespace.constants
-          begin
-            name  = [namespace, child].join("::")
-            value = namespace.const_get(child)
-
-            if value.is_a?(Module)
-              if not history[value]
-                recurse.call(value, recurse)
-              end
-            elsif value.kind_of?(Stupidedi::Schema::TransactionSetDef)
-              results << [name, value]
-            end
-          rescue Stupidedi::Exceptions::InvalidSchemaError
-            $stderr.puts "warning: #{ansi.red("#{$!.class} #{$!.message}")}"
-            $stderr.puts " module: #{name}"
-            $stderr.puts "  trace: #{$!.backtrace[0..-30].map{|x| "  " + x}.join("\n")}"
-            $stderr.puts
-          rescue LoadError, NameError
-            $stderr.puts "warning: #{ansi.red("#{$!.class} #{$!.message}")}"
-            $stderr.puts " module: #{name}"
-            $stderr.puts
-          end
-        end
-      end
-
-      f.call(root, f)
-      results
-    end.call(Stupidedi)
-  end
-
-  definitions.each do |name, definition|
-    next if name =~ /FiftyTen::X223::HC837I/
-
-    it name do
-      Stupidedi::Schema::Auditor.build(definition).audit
-    end
-  end
-
-  pending "Stupidedi::Schema::Auditor Stupidedi::Guides::FiftyTen::X223::HC837I" do
-    Stupidedi::Schema::Auditor.build(Stupidedi::Guides::FiftyTen::X223::HC837I).audit
-  end
-
-end

data/spec/examples/stupidedi/either_spec.rb

@@ -1,375 +0,0 @@
-require "spec_helper"
-
-describe Stupidedi::Either do
-
-  def mksuccess(value)
-    Stupidedi::Either.success(value)
-  end
-
-  def mkfailure(value)
-    Stupidedi::Either.failure(value)
-  end
-
-  describe "#reason" do
-    context "on failure" do
-      it "returns the value given to the constructor" do
-        mkfailure("a").reason.should == "a"
-      end
-    end
-  end
-
-  describe "#==(failure)" do
-    let(:failure) { mkfailure("a") }
-
-    context "on success" do
-      context "when reason == success.value" do
-        it "is false" do
-          failure.should_not == mksuccess("a")
-        end
-      end
-
-      context "when reason != success.value" do
-        it "is false" do
-          failure.should_not == mksuccess("b")
-        end
-      end
-    end
-
-    context "on failure" do
-      context "when reason == failure.reason" do
-        it "is true" do
-          failure.should == mkfailure("a")
-        end
-      end
-
-      context "when reason != failure.reason" do
-        it "is false" do
-          failure.should_not == mkfailure("b")
-        end
-      end
-    end
-  end
-
-  describe "#==(success)" do
-    let(:success) { mksuccess("a") }
-
-    context "on success" do
-      context "when value == success.value" do
-        it "is true" do
-          success.should == mksuccess("a")
-        end
-      end
-
-      context "when value != success.value" do
-        it "is false" do
-          success.should_not == mksuccess("b")
-        end
-      end
-    end
-
-    context "on failure" do
-      context "when value == failure.reason" do
-        it "is false" do
-          success.should_not == mkfailure("a")
-        end
-      end
-
-      context "when value != failure.reason" do
-        it "is false" do
-          success.should_not == mkfailure("b")
-        end
-      end
-    end
-  end
-
-  describe "#==(other)" do
-    context "on success" do
-      context "when value == other" do
-        it "is false" do
-          mksuccess("a").should_not == "a"
-        end
-      end
-
-      context "when value != other" do
-        it "is false" do
-          mksuccess("a").should_not == "b"
-        end
-      end
-    end
-
-    context "on failure" do
-      context "when reason == other" do
-        it "is false" do
-          mksuccess("a").should_not == "a"
-        end
-      end
-
-      context "when reason != other" do
-        it "is false" do
-          mksuccess("a").should_not == "b"
-        end
-      end
-    end
-  end
-
-  describe "#select(reason, &predicate)" do
-    context "on success" do
-      it "yields the wrapped value" do
-        lambda { mksuccess("a").select{|*a| raise a.inspect }}.should raise_error('["a"]')
-      end
-
-      context "when predicate is satisfied" do
-        it "returns itself" do
-          either = mksuccess("a")
-          either.select { true }.should eq(either)
-        end
-      end
-
-      context "when predicate is not satisfied" do
-        it "returns a failure" do
-          mksuccess("a").select { false }.should_not be_defined
-        end
-
-        context "when reason is given" do
-          it "returns a failure with the given reason" do
-            mksuccess("a").select("criteria not met") { false }.reason.
-              should == "criteria not met"
-          end
-        end
-
-        context "when reason is not given" do
-          it "returns a failure with a default reason" do
-            mksuccess("a").select { false }.reason.should == "select"
-          end
-        end
-      end
-    end
-
-    context "on failure" do
-      context "when reason is given" do
-        it "returns itself" do
-          either = mkfailure("a")
-          either.select("a") { false }.should eq(either)
-        end
-      end
-
-      context "when reason is not given" do
-        it "returns itself" do
-          either = mkfailure("a")
-          either.select.should eq(either)
-        end
-      end
-
-      it "does not call the block argument" do
-        lambda { mkfailure("a").select { raise }}.should_not raise_error
-      end
-    end
-  end
-
-  describe "#reject(reason, &predicate)" do
-    context "on success" do
-      it "yields the wrapped value" do
-        lambda { mksuccess("a").reject{|*a| raise a.inspect }}.should raise_error('["a"]')
-      end
-
-      context "when the predicate is satisfied" do
-        it "returns a failure" do
-          mksuccess("a").reject { true }.should_not be_defined
-        end
-
-        context "when reason is given" do
-          it "returns a failure with the given reason" do
-            mksuccess("a").reject("criteria not met") { true }.reason.
-              should == "criteria not met"
-          end
-        end
-
-        context "when reason is not given" do
-          it "returns a failure with a default reason" do
-            mksuccess("a").reject { true }.reason.should == "reject"
-          end
-        end
-      end
-
-      context "when the predicate is not satisfied" do
-        it "returns itself" do
-          either = mksuccess("a")
-          either.reject { false }.should eq(either)
-        end
-      end
-    end
-
-    context "on failure" do
-      context "when reason is given" do
-        it "returns itself" do
-          either = mkfailure("a")
-          either.reject("criteria not met").should eq(either)
-        end
-      end
-
-      context "when reason is not given" do
-        it "returns itself" do
-          either = mkfailure("a")
-          either.reject.should eq(either)
-        end
-      end
-
-      it "does not call the block argument" do
-        lambda { mkfailure("a").reject { raise }}.should_not raise_error
-      end
-    end
-  end
-
-  describe "#defined?" do
-    context "on success" do
-      it "returns true" do
-        mksuccess("a").should be_defined
-      end
-    end
-
-    context "on failure" do
-      it "returns false" do
-        mkfailure("a").should_not be_defined
-      end
-    end
-  end
-
-  # Success's map method is analogous to Failure's explain method
-  describe "#map(&block)" do
-    context "on success" do
-      it "returns a success" do
-        mksuccess("a").map { "b" }.should be_defined
-      end
-
-      it "yields the wrapped value" do
-        lambda { mksuccess("a").map {|*a| raise a.inspect }}.should raise_error('["a"]')
-      end
-
-      it "wraps the return value of the block argument" do
-        mksuccess("a").map{|a| a.length }.should == mksuccess(1)
-      end
-    end
-
-    context "on failure" do
-      it "does not evaluate the block argument" do
-        lambda { mkfailure("a").map { raise }}.should_not raise_error
-      end
-
-      it "returns itself" do
-        either = mkfailure("a")
-        either.map.should eq(either)
-      end
-    end
-  end
-
-  # Failure's explain method is analogous to Success's map method
-  describe "#explain(&block)" do
-    context "on success" do
-      it "does not evaluate the block argument" do
-        lambda { mksuccess("a").explain { raise }}.should_not raise_error
-      end
-
-      it "returns itself" do
-        either = mksuccess("a")
-        either.explain.should eq(either)
-      end
-    end
-
-    context "on failure" do
-      it "returns a failure" do
-        mkfailure("a").explain { "b" }.should_not be_defined
-      end
-
-      it "yields the wrapped reason" do
-        lambda { mkfailure("a").explain{|*a| raise a.inspect }}.should raise_error('["a"]')
-      end
-
-      it "wraps the return value of the block argument" do
-        mkfailure("a").explain{|a| a.length }.should == mkfailure(1)
-      end
-    end
-  end
-
-  # Failure's or method is analogous to Success's flatmap method
-  describe "#or(&either)" do
-    context "on success" do
-      it "does not call the block argument" do
-        lambda { mksuccess("a").or { raise }}.should_not raise_error
-      end
-
-      it "returns itself" do
-        either = mksuccess("a")
-        either.or.should eq(either)
-      end
-    end
-
-    context "on failure" do
-      it "yields the wrapped reason" do
-        lambda { mkfailure("a").or{|*a| raise a.inspect }}.should raise_error('["a"]')
-      end
-
-      it "returns the return value of the block" do
-        mkfailure("a").or{|a| mksuccess(a.succ) }.should == mksuccess("b")
-        mkfailure("a").or{|a| mkfailure(a.succ) }.should == mkfailure("b")
-      end
-
-      it "typechecks the return value of the block" do
-        lambda { mkfailure("a").or{|a| a }}.should raise_error(TypeError)
-      end
-    end
-  end
-
-  # Success's flatmap method is analogous to Failure's or method
-  describe "#flatmap(&block)" do
-    context "on success" do
-      it "yields the wrapped value" do
-        lambda { mksuccess("a").flatmap{|*a| raise a.inspect }}.should raise_error('["a"]')
-      end
-
-      it "returns the return value of the block argument" do
-        mksuccess("a").flatmap{|a| mksuccess(a.succ) }.should == mksuccess("b")
-        mksuccess("a").flatmap{|a| mkfailure(a.succ) }.should == mkfailure("b")
-      end
-
-      it "typechecks the return value of the block argument" do
-        lambda { mksuccess("a").flatmap{|a| a }}.should raise_error(TypeError)
-      end
-    end
-
-    context "on failure" do
-      it "does not evaluate the block argument" do
-        lambda { mkfailure("a").flatmap { raise }}.should_not raise_error
-      end
-
-      it "returns itself" do
-        either = mkfailure("a")
-        either.flatmap.should eq(either)
-      end
-    end
-  end
-
-  describe "#each(&block)" do
-    context "on success" do
-      it "yields the wrapped value" do
-        lambda { mksuccess("a").tap{|*a| raise a.inspect }}.should raise_error('["a"]')
-      end
-
-      it "returns itself" do
-        either = mksuccess("a")
-        either.tap{|a| a.length }.should eq(either)
-      end
-    end
-
-    context "on failure" do
-      it "does not evaluate the block argument" do
-        lambda { mkfailure("a").tap { raise }}.should_not raise_error
-      end
-
-      it "returns itself" do
-        either = mkfailure("a")
-        either.tap.should eq(either)
-      end
-    end
-  end
-
-end