stupidedi 1.3.23 → 1.4.0

data/spec/examples/stupidedi/reader/failure_spec.rb

@@ -1,68 +0,0 @@
-require "spec_helper"
-
-describe Stupidedi::Reader::Failure do
-  include QuickCheck::Macro
-
-  def mkfailure(reason, remainder)
-    Stupidedi::Reader::Result.failure(reason, remainder, false)
-  end
-
-  describe "#reason" do
-    property("is the value given to the constructor") do
-      string
-    end.check do |s|
-      mkfailure(s, "remainder").reason.should eq(s)
-    end
-  end
-
-  describe "#remainder" do
-    property("is the value given to the constructor") do
-      string
-    end.check do |s|
-      mkfailure("reason", s).remainder.should eq(s)
-    end
-  end
-
-  # Note: `method` is dynamically scoped (bound by the caller's environment)
-  shared_examples_for "wrapped input delegator method" do
-    context "when remainder is wrapped" do
-      let(:input) { double("input", :offset => 400, :line => 90, :column => 10) }
-
-      it "returns input.method" do
-        mkfailure("reason", input).__send__(method).should ==
-          input.__send__(method)
-      end
-    end
-
-    context "when remainder is not wrapped" do
-      it "should return nil" do
-        mkfailure("reason", "remainder").__send__(method).should be_nil
-      end
-    end
-
-    context "when remainder is nil" do
-      it "should return nil" do
-        mkfailure("reason", nil).__send__(method).should be_nil
-      end
-    end
-  end
-
-  describe "#offset" do
-    it_should_behave_like "wrapped input delegator method" do
-      let(:method) { :offset }
-    end
-  end
-
-  describe "#line" do
-    it_should_behave_like "wrapped input delegator method" do
-      let(:method) { :line }
-    end
-  end
-
-  describe "#column" do
-    it_should_behave_like "wrapped input delegator method" do
-      let(:method) { :column }
-    end
-  end
-
-end

data/spec/examples/stupidedi/reader/input/delegated_input_spec.rb

@@ -1,293 +0,0 @@
-require "spec_helper"
-using Stupidedi::Refinements
-
-describe Stupidedi::Reader::DelegatedInput do
-  include QuickCheck::Macro
-
-  def mkinput(*args)
-    Stupidedi::Reader::Input.build(*args)
-  end
-
-  describe "#offset" do
-    it "returns the value given to the constructor" do
-      mkinput("", 10, 20, 30).offset.should == 10
-    end
-  end
-
-  describe "#line" do
-    it "returns the value given to the constructor" do
-      mkinput("", 10, 20, 30).line.should == 20
-    end
-  end
-
-  describe "#column" do
-    it "returns the value given to the constructor" do
-      mkinput("", 10, 20, 30).column.should == 30
-    end
-  end
-
-  describe "#position" do
-    it "returns a Position value" do
-      mkinput("").position.should be_a(Stupidedi::Reader::Position)
-    end
-
-    it "returns a Position value at the current offset" do
-      mkinput("", 3).position.offset.should == 3
-    end
-
-    it "returns a Position value at the current line" do
-      mkinput("", 0, 3).position.line.should == 3
-    end
-
-    it "returns a Position value at the current column" do
-      mkinput("", 0, 0, 3).position.column.should == 3
-    end
-  end
-
-  describe "#defined_at?(n)" do
-    context "when n is less than input length" do
-      property("is true") do
-        with(:size, between(1, 25)) { [string, between(0, size - 1)] }
-      end.check do |s, n|
-        mkinput(s).defined_at?(n).should be true
-      end
-    end
-
-    context "when n is equal to input length" do
-      property("is false") do
-        with(:size, between(0, 25)) { [string, size] }
-      end.check do |s, n|
-        mkinput(s).defined_at?(n).should be false
-      end
-    end
-
-    context "when n is greater than input length" do
-      property("is false") do
-        with(:size, between(0, 25)) { [string, size + integer.abs] }
-      end.check do |s, n|
-        mkinput(s).defined_at?(n).should be false
-      end
-    end
-  end
-
-  describe "#empty?" do
-    context "when the input is empty" do
-      it "is true" do
-        mkinput("").should be_empty
-        mkinput([]).should be_empty
-      end
-    end
-
-    context "when the input is not empty" do
-      it "is false" do
-        mkinput(" ").should_not be_empty
-        mkinput([1]).should_not be_empty
-      end
-    end
-  end
-
-  describe "#drop(n)" do
-    context "when n is zero" do
-      it "returns itself" do
-        mkinput("abc").drop(0).should == "abc"
-      end
-    end
-
-    context "when n is negative" do
-      it "raises an error" do
-        lambda { mkinput("abc").drop(-1) }.should raise_error
-      end
-    end
-
-    context "when less than n elements are available" do
-      it "increments the offset" do
-        mkinput("abc", 10).drop(25).offset.should == 13
-      end
-
-      property("increments the offset") do
-        with(:size, between(0, 25)) do
-          [string, between(size + 1, 1000), between(10, 1000)]
-        end
-      end.check do |s, n, offset|
-        mkinput(s, offset).drop(n).offset.should == offset + s.length
-      end
-
-      it "returns an empty input" do
-        mkinput("abc", 10).drop(10).should be_empty
-      end
-    end
-
-    context "when n elements are available" do
-      it "increments the offset" do
-        mkinput("abc", 10).drop(2).offset.should == 12
-      end
-
-      property("increments the offset") do
-        with(:size, between(0, 25)) do
-          [string, between(0, size), between(10, 1000)]
-        end
-      end.check do |s, n, offset|
-        mkinput(s, offset).drop(n).offset.should == offset + n
-      end
-
-      it "returns an input with the first n elements removed" do
-        mkinput(%w(a b c d)).drop(3).should == %w(d)
-      end
-
-      property("returns an input with the first n elements removed") do
-        with(:size, between(0, 25)) do
-          [string, between(0, size)]
-        end
-      end.check do |s, n|
-        mkinput(s).drop(n).should == s.drop(n)
-      end
-    end
-
-    property("increments the line count") do
-      string = array { with(:size, between(0, 15)) { string }}.join("\n")
-      n      = between(0, string.length * 2)
-      offset = integer
-      line   = integer
-
-      [string, n, offset, line]
-    end.check do |s, n, o, l|
-      mkinput(s, o, l).drop(n).line.should == l + s.take(n).count("\n")
-    end
-
-    it "calculates the column" do
-      input = mkinput("abc\nxyz")
-      input.drop(0).column.should == 1
-      input.drop(1).column.should == 2
-      input.drop(2).column.should == 3
-      input.drop(3).column.should == 4
-      input.drop(4).column.should == 1
-      input.drop(5).column.should == 2
-      input.drop(6).column.should == 3
-    end
-
-    property("calculates the column") do
-      string = array { with(:size, between(0, 50)) { string }}.join("\n")
-      n      = between(0, string.length * 2)
-      offset = integer
-      line   = integer
-      column = integer
-
-      [string, n, offset, line, column]
-    end.check do |s, n, o, l, c|
-      prefix = s.take(n)
-
-      if prefix.include?("\n")
-        mkinput(s, o, l, c).drop(n).column.should == prefix.length - prefix.rindex("\n")
-      else
-        mkinput(s, o, l, c).drop(n).column.should == c + prefix.length
-      end
-    end
-  end
-
-  describe "#take(n)" do
-    context "when n is zero" do
-      it "returns an empty value" do
-        mkinput("abc").take(0).should == ""
-      end
-
-      it "returns an empty value" do
-        mkinput(%w(a b c)).take(0).should == []
-      end
-    end
-
-    context "when n is negative" do
-      it "raises an error" do
-        lambda { mkinput("abc").take(-1) }.should raise_error
-      end
-    end
-
-    context "when less than n elements are available" do
-      it "returns all available elements" do
-        mkinput("ab").take(3).should == "ab"
-      end
-
-      it "returns all available elements" do
-        mkinput(%w(a b)).take(3).should == %w(a b)
-      end
-
-      it "does not update the offset" do
-        mkinput("abc", 500).tap do |x|
-          x.take(4)
-        end.offset.should == 500
-      end
-    end
-
-    context "when n elements are available" do
-      it "returns the first n elements" do
-        mkinput("abc").take(2).should == "ab"
-      end
-
-      it "returns the first n elements" do
-        mkinput(%w(a b c)).take(2).should == %w(a b)
-      end
-
-      it "does not update the offset" do
-        mkinput("abc", 500).tap do |x|
-          x.take(2)
-        end.offset.should == 500
-      end
-    end
-  end
-
-  describe "#at(n)" do
-    context "when n is negative" do
-      it "raises an error" do
-        lambda { mkinput("abc").at(-1) }.should raise_error
-      end
-    end
-
-    context "when the input is defined_at?(n)" do
-      it "returns the element at index n" do
-        mkinput("abc").at(2).should == "c"
-      end
-
-      it "returns the element at index n" do
-        mkinput(%w(a b c)).at(2).should == "c"
-      end
-
-      it "does not update the offset" do
-        mkinput("abc", 500).tap do |x|
-          x.at(5)
-        end.offset.should == 500
-      end
-    end
-
-    context "when the input is not defined_at?(n)" do
-      it "returns nil" do
-        mkinput("abc").at(3).should be_nil
-      end
-
-      it "returns nil" do
-        mkinput(%w(a b c)).at(3).should be_nil
-      end
-
-      it "does not update the offset" do
-        mkinput("abc", 500).tap do |x|
-          x.at(1)
-        end.offset.should == 500
-      end
-    end
-  end
-
-  describe "#index(search)" do
-    context "when search is an element in the input" do
-      it "returns the smallest index" do
-        mkinput("abcabc").index("b").should == 1
-        mkinput(%w(a b c a b c)).index("b").should == 1
-      end
-    end
-
-    context "when search is not an element in the input" do
-      it "returns nil" do
-        mkinput("abc").index("d").should be_nil
-        mkinput(%w(a b c)).index("d").should be_nil
-      end
-    end
-  end
-
-end

data/spec/examples/stupidedi/reader/separators_spec.rb

@@ -1,73 +0,0 @@
-require "spec_helper"
-
-describe Stupidedi::Reader::Separators do
-
-  let(:empty) { Stupidedi::Reader::Separators.empty }
-
-  describe ".empty" do
-    it "returns Separators(nil, nil, nil, nil)" do
-      empty.element.should be_nil
-      empty.segment.should be_nil
-      empty.component.should be_nil
-      empty.repetition.should be_nil
-    end
-  end
-
-  describe "#merge(other)" do
-    let(:first) do
-      empty.copy(:element => "a",
-                 :segment => "b",
-                 :component => "c",
-                 :repetition => "d")
-    end
-
-    context "if other.element.nil?" do
-      it "then a.merge(b).element == a.element" do
-        first.merge(empty).element.should == first.element
-      end
-    end
-
-    context "if not other.element.nil?" do
-      it "then a.merge(b).element == b.element" do
-        first.merge(empty.copy(:element => "A")).element.should == "A"
-      end
-    end
-
-    context "if other.segment.nil?" do
-      it "then a.merge(b).segment == a.segment" do
-        first.merge(empty).segment.should == first.segment
-      end
-    end
-
-    context "if not other.segment.nil?" do
-      it "then a.merge(b).segment == b.segment" do
-        first.merge(empty.copy(:segment => "A")).segment.should == "A"
-      end
-    end
-
-    context "if other.component.nil?" do
-      it "then a.merge(b).component == a.component" do
-        first.merge(empty).component.should == first.component
-      end
-    end
-
-    context "if not other.component.nil?" do
-      it "then a.merge(b).component == b.component" do
-        first.merge(empty.copy(:component => "A")).component.should == "A"
-      end
-    end
-
-    context "if other.repetition.nil?" do
-      it "then a.merge(b).repetition == a.repetition" do
-        first.merge(empty).repetition.should == first.repetition
-      end
-    end
-
-    context "if not other.repetition.nil?" do
-      it "then a.merge(b).repetition == b.repetition" do
-        first.merge(empty.copy(:repetition => "A")).repetition.should == "A"
-      end
-    end
-  end
-
-end

data/spec/examples/stupidedi/reader/stream_reader_spec.rb

@@ -1,48 +0,0 @@
-require "spec_helper"
-
-describe Stupidedi::Reader::StreamReader do
-
-  let(:success) { Stupidedi::Reader::Success }
-  let(:stream)  { Stupidedi::Reader::StreamReader }
-
-  def input(string)
-    Stupidedi::Reader::Input.from_string(string)
-  end
-
-  describe "#stream?" do
-    it "returns true"
-  end
-
-  describe "#empty?" do
-    context "with no input available"
-    context "with some input available"
-  end
-
-  describe "#read_character" do
-    context "with no input available" do
-      it "produces an error message"
-      it "encodes the error position"
-    end
-
-    context "with only one input character available"
-    context "with more than one input character available"
-  end
-
-  describe "#consume_character" do
-    context "with no input available" do
-      it "produces an error message"
-      it "encodes the error position"
-    end
-
-    context "with only one input character available"
-    context "with more than one input character available"
-  end
-
-  describe "#read_segment" do
-    context "with no input available"
-    context "with an isa segment at the start of input"
-    context "with an isa segment after the start of input"
-    context "with input that doesnt have an isa segment"
-  end
-
-end