stupidedi 1.1.0

data/spec/examples/stupidedi/reader/input/delegated_input.example

@@ -0,0 +1,292 @@
+require "spec_helper"
+
+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.example

@@ -0,0 +1,73 @@
+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.example

@@ -0,0 +1,48 @@
+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

data/spec/examples/stupidedi/reader/success.example

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe Stupidedi::Reader::Success do
+  include QuickCheck::Macro
+
+  def mksuccess(value, remainder)
+    Stupidedi::Reader::Result.success(value, remainder)
+  end
+
+  describe "#value" do
+    it "returns the argument given to the constructor" do
+      mksuccess("a", "b").tap{|a, b| a.should == "a" }
+    end
+  end
+
+  describe "#remainder" do
+    it "returns the argument given to the constructor" do
+      mksuccess("a", "b").remainder.should == "b"
+      mksuccess("a", "b").tap{|a, b| b.should == "b" }
+    end
+  end
+
+  describe "#map" do
+    it "returns another result" do
+      mksuccess("a", "b").map { }.
+        should be_a(Stupidedi::Reader::Success)
+    end
+
+    it "yields the value"
+    it "changes the value"
+    it "preserves the remainder"
+  end
+
+end