pdf-reader-turtletext 0.2.1 → 0.2.2

data/CHANGELOG

@@ -1,4 +1,9 @@
-Version 0.2.1              Release: n/a
+Version 0.2.2                Release: 1st Aug 2012
+==================================================
+* provide better control of inclusive/exclusive behaviour
+  for region selection \#4
+
+Version 0.2.1              Release: 31st July 2012
 ==================================================
 * fix row sorting for Rubinius 1.8 mode
 

data/README.rdoc

@@ -36,7 +36,9 @@ Then bundle install:
 
 === How do I install it for gem development?
 
-If you want to work on enhancements of fix bugs in PDF::Reader::Turtletext, fork and clone the github repository. See the section below on 'Contributing to PDF::Reader::Turtletext'
+If you want to work on enhancements of fix bugs in PDF::Reader::Turtletext, fork and clone the github repository. If you are using bundler (recommended), run <tt>bundle</tt> to install development dependencies.
+
+See the section below on 'Contributing to PDF::Reader::Turtletext' for more information.
 
 === How to instantiate Turtletext in code
 
@@ -70,6 +72,8 @@ Solution: use the <tt>bounding_box</tt> method to describe the region and extrac
 
 The range of methods that can be used within the <tt>bounding_box</tt> block are all optional, and include:
 * <tt>page</tt> - specifies the PDF page from which to extract text (default is 1).
+* <tt>inclusive</tt> - whether region selection should be inclusive or exclusive of the specified positions
+  (default is false).
 * <tt>below</tt> - a string, regex or number that describes the upper limit of the text box
   (default is top border of the page).
 * <tt>above</tt> - a string, regex or number that describes the lower limit of the text box
@@ -98,17 +102,47 @@ An explicit block parameter may be used with the <tt>bounding_box</tt> method:
   textangle.text
   => [['string','string'],['string']] # array of rows, each row is an array of text elements in the row
 
+=== How to describe an inclusive <tt>bounding_box</tt> region
+
+By default, the <tt>bounding_box</tt> method makes exclusive selection (i.e. not including the
+region limits).
+
+To specifiy an inclusive region, use the <tt>inclusive!</tt> command:
+
+  textangle = reader.bounding_box do
+    inclusive!
+    below /electricity/i
+    left_of "Total ($)"
+  end
+
+Alternatively, set <tt>inclusive</tt> to true:
+
+  textangle = reader.bounding_box do
+    inclusive true
+    below /electricity/i
+    left_of "Total ($)"
+  end
+
+Or with a block parameter, you may also assign <tt>inclusive</tt> to true:
+
+  textangle = reader.bounding_box do |r|
+    r.inclusive = true
+    r.below /electricity/i
+    r.left_of "Total ($)"
+  end
+
 === Extract text for a region with known positional co-ordinates
 
 If you know (or can calculate) the x,y positions of the required text region, you can extract the region's
 text using the <tt>text_in_region</tt> method.
 
   text = reader.text_in_region(
-    10,  # minimum x (left-most) (inclusive)
-    900, # maximum x (right-most) (inclusive)
-    200, # minimum y (bottom-most) (inclusive)
-    400, # maximum y (top-most) (inclusive)
-    1    # page
+    10,   # minimum x (left-most)
+    900,  # maximum x (right-most)
+    200,  # minimum y (bottom-most)
+    400,  # maximum y (top-most)
+    1,    # page (default 1)
+    false # inclusive of x/y position if true (default false)
   )
   => [['string','string'],['string']] # array of rows, each row is an array of text elements in the row
 

data/lib/pdf/reader/turtletext.rb

@@ -76,21 +76,22 @@ class PDF::Reader::Turtletext
     end
   end
 
-  # Returns an array of text elements found within the x,y limits,
-  # x ranges from +xmin+ (left of page) to +xmax+ (right of page)
-  # y ranges from +ymin+ (bottom of page) to +ymax+ (top of page)
-  # Each line of text found is returned as an array element.
+  # Returns an array of text elements found within the x,y limits on +page+:
+  # * x ranges from +xmin+ (left of page) to +xmax+ (right of page)
+  # * y ranges from +ymin+ (bottom of page) to +ymax+ (top of page)
+  # When +inclusive+ is false (default) the x/y limits do not include the actual x/y value.
   # Each line of text is an array of the seperate text elements found on that line.
   #   [["first line first text", "first line last text"],["second line text"]]
-  def text_in_region(xmin,xmax,ymin,ymax,page=1)
+  def text_in_region(xmin,xmax,ymin,ymax,page=1,inclusive=false)
+    return [] unless xmin && xmax && ymin && ymax
     text_map = content(page)
     box = []
 
     text_map.each do |y,text_row|
-      if y >= ymin && y<= ymax
+      if inclusive ? (y >= ymin && y <= ymax) : (y > ymin && y < ymax)
         row = []
         text_row.each do |x,element|
-          if x >= xmin && x<= xmax
+          if inclusive ? (x >= xmin && x <= xmax) : (x > xmin && x < xmax)
             row << element
           end
         end
@@ -102,7 +103,8 @@ class PDF::Reader::Turtletext
 
   # Returns the position of +text+ on +page+
   #   {x: val, y: val }
-  # +text+ may be a string (exact match required) or a Regexp
+  # +text+ may be a string (exact match required) or a Regexp.
+  # Returns nil if the text cannot be found.
   def text_position(text,page=1)
     item = if text.class <= Regexp
       content(page).map do |k,v|

data/lib/pdf/reader/turtletext/textangle.rb

@@ -10,14 +10,15 @@
 # textangle.text
 #
 class PDF::Reader::Turtletext::Textangle
+
+  #
   attr_reader :reader
-  attr_accessor :page
-  attr_writer :above,:below,:left_of,:right_of
 
   # +turtletext_reader+ is a PDF::Reader::Turtletext
   def initialize(turtletext_reader,&block)
     @reader = turtletext_reader
     @page = 1
+    @inclusive = false
     if block_given?
       if block.arity == 1
         yield self
@@ -27,6 +28,34 @@ class PDF::Reader::Turtletext::Textangle
     end
   end
 
+  attr_writer :inclusive
+
+  def inclusive(*args)
+    if value = args.first
+      @inclusive = value
+    end
+    @inclusive
+  end
+
+  # Command: sets +inclusive true
+  def inclusive!
+    @inclusive = true
+  end
+
+  # Command: sets +inclusive false
+  def exclusive!
+    @inclusive = false
+  end
+
+  attr_writer :page
+  def page(*args)
+    if value = args.first
+      @page = value
+    end
+    @page
+  end
+
+  attr_writer :above
   def above(*args)
     if value = args.first
       @above = value
@@ -34,6 +63,7 @@ class PDF::Reader::Turtletext::Textangle
     @above
   end
 
+  attr_writer :below
   def below(*args)
     if value = args.first
       @below = value
@@ -41,6 +71,7 @@ class PDF::Reader::Turtletext::Textangle
     @below
   end
 
+  attr_writer :left_of
   def left_of(*args)
     if value = args.first
       @left_of = value
@@ -48,6 +79,7 @@ class PDF::Reader::Turtletext::Textangle
     @left_of
   end
 
+  attr_writer :right_of
   def right_of(*args)
     if value = args.first
       @right_of = value
@@ -55,15 +87,17 @@ class PDF::Reader::Turtletext::Textangle
     @right_of
   end
 
-  # Returns the text
+  # Returns the text array found within the defined region.
+  # Each line of text is an array of the seperate text elements found on that line.
+  #   [["first line first text", "first line last text"],["second line text"]]
   def text
     return unless reader
 
     xmin = if right_of
       if [Fixnum,Float].include?(right_of.class)
         right_of
-      else
-        reader.text_position(right_of,page)[:x] + 1
+      elsif xy = reader.text_position(right_of,page)
+        xy[:x]
       end
     else
       0
@@ -71,18 +105,18 @@ class PDF::Reader::Turtletext::Textangle
     xmax = if left_of
       if [Fixnum,Float].include?(left_of.class)
         left_of
-      else
-        reader.text_position(left_of,page)[:x] - 1
+      elsif xy = reader.text_position(left_of,page)
+        xy[:x]
       end
     else
-      99999 # TODO actual limit
+      99999 # TODO: figure out the actual limit?
     end
 
     ymin = if above
       if [Fixnum,Float].include?(above.class)
         above
-      else
-        reader.text_position(above,page)[:y] + 1
+      elsif xy = reader.text_position(above,page)
+        xy[:y]
       end
     else
       0
@@ -90,14 +124,14 @@ class PDF::Reader::Turtletext::Textangle
     ymax = if below
       if [Fixnum,Float].include?(below.class)
         below
-      else
-        reader.text_position(below,page)[:y] - 1
+      elsif xy = reader.text_position(below,page)
+        xy[:y]
       end
     else
-      99999 # TODO actual limit
+      99999 # TODO: figure out the actual limit?
     end
 
-    reader.text_in_region(xmin,xmax,ymin,ymax,page)
+    reader.text_in_region(xmin,xmax,ymin,ymax,page,inclusive)
   end
 
 end

data/lib/pdf/reader/turtletext/version.rb

@@ -4,7 +4,7 @@ module PDF
       class Version
         MAJOR = 0
         MINOR = 2
-        PATCH = 1
+        PATCH = 2
 
         STRING = [MAJOR, MINOR, PATCH].compact.join('.')
       end

data/pdf-reader-turtletext.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "pdf-reader-turtletext"
-  s.version = "0.2.1"
+  s.version = "0.2.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Paul Gallagher"]
-  s.date = "2012-07-31"
+  s.date = "2012-08-01"
   s.description = "a library that can read structured and positional text from PDFs. Ideal for asembling structured data from invoices and the like."
   s.email = "gallagher.paul@gmail.com"
   s.extra_rdoc_files = [

data/spec/fixtures/pdf_samples/expectations.yml

@@ -3,19 +3,22 @@
 # This is a YAML-format file, so beware that indentation is significant
 ---
 hello_world.pdf:
-  :test_above:
+  :test_numeric_above:
     :above: 100
     :expected_text:
     -
       - "Hello World"
-  :test_below:
+  :test_numeric_below:
     :below: 900
     :expected_text:
     -
       - "Hello World"
-  :test_below_na:
+  :test_numeric_below_na:
     :below: 10
     :expected_text: []
+  :test_below_na:
+    :below: "Bertie"
+    :expected_text: []
 simple_table_text.pdf:
   :test_above:
     :above: Table Header

data/spec/unit/reader/turtletext/textangle_spec.rb

@@ -14,7 +14,7 @@ describe PDF::Reader::Turtletext::Textangle do
     it { should be_a(PDF::Reader::Turtletext) }
   end
 
-  describe "#text" do
+  context "with mock content" do
     let(:page) { 1 }
     before do
       turtletext_reader.stub(:load_content).and_return(given_page_content)
@@ -28,10 +28,10 @@ describe PDF::Reader::Turtletext::Textangle do
 
     context "with block param" do
       [:above,:below,:left_of,:right_of].each do |positional_method|
-        context "with #{positional_method}" do
+        describe "##{positional_method}" do
           let(:term) { "canary" }
 
-          it "should work with block param" do
+          it "should assign correctly" do
             textangle = resource_class.new(turtletext_reader) do |r|
               r.send("#{positional_method}=",term)
             end
@@ -40,159 +40,430 @@ describe PDF::Reader::Turtletext::Textangle do
 
         end
       end
+
+      describe "#page" do
+        let(:value) { 2 }
+        describe "default" do
+          let(:textangle) { resource_class.new(turtletext_reader) do |r|
+          end }
+          subject { textangle.page }
+          it { should eql(1) }
+        end
+        it "should assign correctly" do
+          textangle = resource_class.new(turtletext_reader) do |r|
+            r.page = value
+          end
+          textangle.page.should eql(value)
+        end
+      end
+
+      describe "#inclusive" do
+        describe "default" do
+          let(:textangle) { resource_class.new(turtletext_reader) do |r|
+          end }
+          subject { textangle.inclusive }
+          it { should be_false }
+        end
+        it "should assign true correctly" do
+          textangle = resource_class.new(turtletext_reader) do |r|
+            r.inclusive = true
+          end
+          textangle.inclusive.should be_true
+        end
+        it "should assign false correctly" do
+          textangle = resource_class.new(turtletext_reader) do |r|
+            r.inclusive = false
+          end
+          textangle.inclusive.should be_false
+        end
+      end
+      describe "#inclusive!" do
+        it "should assign correctly" do
+          textangle = resource_class.new(turtletext_reader) do |r|
+            r.inclusive!
+          end
+          textangle.inclusive.should be_true
+        end
+      end
+      describe "#exclusive!" do
+        it "should assign correctly" do
+          textangle = resource_class.new(turtletext_reader) do |r|
+            r.exclusive!
+          end
+          textangle.inclusive.should be_false
+        end
+      end
     end
 
     context "without block param" do
-      it "#above should work" do
+      it "#above should assign correctly" do
         textangle = resource_class.new(turtletext_reader) do
           above "canary"
         end
         textangle.above.should eql("canary")
       end
-      it "#below should work" do
+      it "#below should assign correctly" do
         textangle = resource_class.new(turtletext_reader) do
           below "canary"
         end
         textangle.below.should eql("canary")
       end
-      it "#left_of should work" do
+      it "#left_of should assign correctly" do
         textangle = resource_class.new(turtletext_reader) do
           left_of "canary"
         end
         textangle.left_of.should eql("canary")
       end
-      it "#below should work" do
+      it "#below should assign correctly" do
         textangle = resource_class.new(turtletext_reader) do
           right_of "canary"
         end
         textangle.right_of.should eql("canary")
       end
-    end
 
-    context "when only below specified" do
-      context "as a string" do
-        let(:textangle) { resource_class.new(turtletext_reader) do |r|
-          r.below = "fraud"
-        end }
-        let(:expected) { [["smoked and streaky for me"]]}
-        subject { textangle.text }
-        it { should eql(expected) }
-      end
-      context "as a regex" do
-        let(:textangle) { resource_class.new(turtletext_reader) do |r|
-          r.below = /Fraud/i
-        end }
-        let(:expected) { [["smoked and streaky for me"]]}
-        subject { textangle.text }
-        it { should eql(expected) }
-      end
-      context "as a number" do
-        let(:textangle) { resource_class.new(turtletext_reader) do |r|
-          r.below = 20
-        end }
-        let(:expected) { [["smoked and streaky for me"]]}
-        subject { textangle.text }
-        it { should eql(expected) }
+      describe "#page" do
+        it "should assign correctly" do
+          textangle = resource_class.new(turtletext_reader) do
+            page 2
+          end
+          textangle.page.should eql(2)
+        end
       end
-    end
 
-    context "when only above specified" do
-      context "as a string" do
-        let(:textangle) { resource_class.new(turtletext_reader) do |r|
-          r.above = "heaven"
-        end }
-        let(:expected) { [["crunchy bacon"]]}
-        subject { textangle.text }
-        it { should eql(expected) }
-      end
-      context "as a regex" do
-        let(:textangle) { resource_class.new(turtletext_reader) do |r|
-          r.above = /heaVen/i
-        end }
-        let(:expected) { [["crunchy bacon"]]}
-        subject { textangle.text }
-        it { should eql(expected) }
-      end
-      context "as a number" do
-        let(:textangle) { resource_class.new(turtletext_reader) do |r|
-          r.above = 41
-        end }
-        let(:expected) { [["crunchy bacon"]]}
-        subject { textangle.text }
-        it { should eql(expected) }
+      describe "#inclusive" do
+        it "should assign true correctly" do
+          textangle = resource_class.new(turtletext_reader) do
+            inclusive true
+          end
+          textangle.inclusive.should be_true
+        end
+        it "should assign false correctly" do
+          textangle = resource_class.new(turtletext_reader) do
+            inclusive false
+          end
+          textangle.inclusive.should be_false
+        end
+      end
+      describe "#inclusive!" do
+        it "should assign correctly" do
+          textangle = resource_class.new(turtletext_reader) do
+            inclusive!
+          end
+          textangle.inclusive.should be_true
+        end
+      end
+      describe "#exclusive!" do
+        it "should assign correctly" do
+          textangle = resource_class.new(turtletext_reader) do
+            exclusive!
+          end
+          textangle.inclusive.should be_false
+        end
       end
     end
 
-    context "when only left_of specified" do
-      context "as a string" do
-        let(:textangle) { resource_class.new(turtletext_reader) do |r|
-          r.left_of = "turkey bacon"
-        end }
-        let(:expected) { [
-          ["crunchy bacon"],
-          ["bacon on kimchi noodles", "heaven"]
-        ] }
-        subject { textangle.text }
-        it { should eql(expected) }
-      end
-      context "as a regex" do
-        let(:textangle) { resource_class.new(turtletext_reader) do |r|
-          r.left_of = /turKey/i
-        end }
-        let(:expected) { [
-          ["crunchy bacon"],
-          ["bacon on kimchi noodles", "heaven"]
-        ] }
-        subject { textangle.text }
-        it { should eql(expected) }
-      end
-      context "as a number" do
-        let(:textangle) { resource_class.new(turtletext_reader) do |r|
-          r.left_of = 29
-        end }
-        let(:expected) { [
-          ["crunchy bacon"],
-          ["bacon on kimchi noodles", "heaven"]
-        ] }
-        subject { textangle.text }
-        it { should eql(expected) }
+    describe "#text" do
+
+      context "when only below specified" do
+        context "when exclusive (default)" do
+          context "as a string" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.below = "turkey bacon"
+            end }
+            let(:expected) { [["smoked and streaky for me"]]}
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+          context "as a regex" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.below = /turkey/i
+            end }
+            let(:expected) { [["smoked and streaky for me"]]}
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+          context "as a number" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.below = 30
+            end }
+            let(:expected) { [["smoked and streaky for me"]]}
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+        end
+        context "when inclusive" do
+          context "as a string" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.inclusive = true
+              r.below = "smoked and streaky for me"
+            end }
+            let(:expected) { [["smoked and streaky for me"]]}
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+          context "as a regex" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.inclusive = true
+              r.below = /Streaky/i
+            end }
+            let(:expected) { [["smoked and streaky for me"]]}
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+          context "as a number" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.inclusive = true
+              r.below = 10
+            end }
+            let(:expected) { [["smoked and streaky for me"]]}
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+        end
+        context "when no match" do
+          let(:textangle) { resource_class.new(turtletext_reader) do |r|
+            r.below = "fake"
+          end }
+          let(:expected) { [] }
+          subject { textangle.text }
+          it { should eql(expected) }
+        end
       end
-    end
 
-    context "when only right_of specified" do
-      context "as a string" do
-        let(:textangle) { resource_class.new(turtletext_reader) do |r|
-          r.right_of = "heaven"
-        end }
-        let(:expected) { [
-          ["turkey bacon","fraud"],
-          ["smoked and streaky for me"]
-        ] }
-        subject { textangle.text }
-        it { should eql(expected) }
-      end
-      context "as a regex" do
-        let(:textangle) { resource_class.new(turtletext_reader) do |r|
-          r.right_of = /Heaven/i
-        end }
-        let(:expected) { [
-          ["turkey bacon","fraud"],
-          ["smoked and streaky for me"]
-        ] }
-        subject { textangle.text }
-        it { should eql(expected) }
-      end
-      context "as a number" do
-        let(:textangle) { resource_class.new(turtletext_reader) do |r|
-          r.right_of = 26
-        end }
-        let(:expected) { [
-          ["turkey bacon","fraud"],
-          ["smoked and streaky for me"]
-        ] }
-        subject { textangle.text }
-        it { should eql(expected) }
+      context "when only above specified" do
+        context "when exclusive (default)" do
+          context "as a string" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.above = "bacon on kimchi noodles"
+            end }
+            let(:expected) { [["crunchy bacon"]] }
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+          context "as a regex" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.above = /kimchi/i
+            end }
+            let(:expected) { [["crunchy bacon"]] }
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+          context "as a number" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.above = 40
+            end }
+            let(:expected) { [["crunchy bacon"]] }
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+        end
+        context "when inclusive" do
+          context "as a string" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.inclusive = true
+              r.above = "crunchy bacon"
+            end }
+            let(:expected) { [["crunchy bacon"]] }
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+          context "as a regex" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.inclusive = true
+              r.above = /crunChy/i
+            end }
+            let(:expected) { [["crunchy bacon"]] }
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+          context "as a number" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.inclusive = true
+              r.above = 70
+            end }
+            let(:expected) { [["crunchy bacon"]] }
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+        end
+        context "when no match" do
+          let(:textangle) { resource_class.new(turtletext_reader) do |r|
+            r.above = "fake"
+          end }
+          let(:expected) { [] }
+          subject { textangle.text }
+          it { should eql(expected) }
+        end
       end
+
+      context "when only left_of specified" do
+        context "when exclusive (default)" do
+          context "as a string" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.left_of = "turkey bacon"
+            end }
+            let(:expected) { [
+              ["crunchy bacon"],
+              ["bacon on kimchi noodles", "heaven"]
+            ] }
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+          context "as a regex" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.left_of = /turKey/i
+            end }
+            let(:expected) { [
+              ["crunchy bacon"],
+              ["bacon on kimchi noodles", "heaven"]
+            ] }
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+          context "as a number" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.left_of = 30
+            end }
+            let(:expected) { [
+              ["crunchy bacon"],
+              ["bacon on kimchi noodles", "heaven"]
+            ] }
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+        end
+        context "when inclusive" do
+          context "as a string" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.inclusive = true
+              r.left_of = "heaven"
+            end }
+            let(:expected) { [
+              ["crunchy bacon"],
+              ["bacon on kimchi noodles", "heaven"]
+            ] }
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+          context "as a regex" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.inclusive = true
+              r.left_of = /heaVen/i
+            end }
+            let(:expected) { [
+              ["crunchy bacon"],
+              ["bacon on kimchi noodles", "heaven"]
+            ] }
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+          context "as a number" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.inclusive = true
+              r.left_of = 25
+            end }
+            let(:expected) { [
+              ["crunchy bacon"],
+              ["bacon on kimchi noodles", "heaven"]
+            ] }
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+        end
+        context "when no match" do
+          let(:textangle) { resource_class.new(turtletext_reader) do |r|
+            r.left_of = "fake"
+          end }
+          let(:expected) { [] }
+          subject { textangle.text }
+          it { should eql(expected) }
+        end
+      end
+
+      context "when only right_of specified" do
+        context "when exclusive (default)" do
+          context "as a string" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.right_of = "heaven"
+            end }
+            let(:expected) { [
+              ["turkey bacon","fraud"],
+              ["smoked and streaky for me"]
+            ] }
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+          context "as a regex" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.right_of = /Heaven/i
+            end }
+            let(:expected) { [
+              ["turkey bacon","fraud"],
+              ["smoked and streaky for me"]
+            ] }
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+          context "as a number" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.right_of = 25
+            end }
+            let(:expected) { [
+              ["turkey bacon","fraud"],
+              ["smoked and streaky for me"]
+            ] }
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+        end
+        context "when inclusive" do
+          context "as a string" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.inclusive = true
+              r.right_of = "turkey bacon"
+            end }
+            let(:expected) { [
+              ["turkey bacon","fraud"],
+              ["smoked and streaky for me"]
+            ] }
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+          context "as a regex" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.inclusive = true
+              r.right_of = /turkey/i
+            end }
+            let(:expected) { [
+              ["turkey bacon","fraud"],
+              ["smoked and streaky for me"]
+            ] }
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+          context "as a number" do
+            let(:textangle) { resource_class.new(turtletext_reader) do |r|
+              r.inclusive = true
+              r.right_of = 30
+            end }
+            let(:expected) { [
+              ["turkey bacon","fraud"],
+              ["smoked and streaky for me"]
+            ] }
+            subject { textangle.text }
+            it { should eql(expected) }
+          end
+        end
+        context "when no match" do
+          let(:textangle) { resource_class.new(turtletext_reader) do |r|
+            r.right_of = "fake"
+          end }
+          let(:expected) { [] }
+          subject { textangle.text }
+          it { should eql(expected) }
+        end
+      end
+
     end
 
   end

data/spec/unit/reader/turtletext/turtletext_spec.rb

@@ -90,7 +90,7 @@ describe PDF::Reader::Turtletext do
       {
         :with_single_text => {
           :source_page_content => {10.0=>{10.0=>"a first bit of text"}},
-          :xmin => 0, :xmax => 100, :ymin => 0, :ymax => 100,
+          :xmin => 0, :xmax => 100, :ymin => 0, :ymax => 100, :inclusive => false,
           :expected_text => [["a first bit of text"]]
         },
         :with_single_line_text => {
@@ -99,7 +99,7 @@ describe PDF::Reader::Turtletext do
             30.0=>{10.0=>"first part found", 20.0=>"last part found"},
             10.0=>{10.0=>"last line ignored"}
           },
-          :xmin => 0, :xmax => 100, :ymin => 20, :ymax => 50,
+          :xmin => 0, :xmax => 100, :ymin => 20, :ymax => 50, :inclusive => false,
           :expected_text => [["first part found", "last part found"]]
         },
         :with_multi_line_text => {
@@ -109,11 +109,20 @@ describe PDF::Reader::Turtletext do
             30.0=>{10.0=>"last line first part found", 20.0=>"last line last part found"},
             10.0=>{10.0=>"last line ignored"}
           },
-          :xmin => 0, :xmax => 100, :ymin => 20, :ymax => 50,
+          :xmin => 0, :xmax => 100, :ymin => 20, :ymax => 50, :inclusive => false,
           :expected_text => [
             ["first line first part found", "first line last part found"],
             ["last line first part found", "last line last part found"]
           ]
+        },
+        :with_inclusive_text => {
+          :source_page_content => {
+            70.0=>{10.0=>"first line ignored"},
+            30.0=>{10.0=>"first part found", 20.0=>"last part found"},
+            10.0=>{10.0=>"last line ignored"}
+          },
+          :xmin => 10, :xmax => 100, :ymin => 30, :ymax => 30, :inclusive => true,
+          :expected_text => [["first part found", "last part found"]]
         }
       }.each do |test_name,test_expectations|
         context test_name do
@@ -122,8 +131,9 @@ describe PDF::Reader::Turtletext do
           let(:xmax) { test_expectations[:xmax] }
           let(:ymin) { test_expectations[:ymin] }
           let(:ymax) { test_expectations[:ymax] }
+          let(:inclusive) { test_expectations[:inclusive] }
           let(:expected_text) { test_expectations[:expected_text] }
-          subject { turtletext_reader.text_in_region(xmin,xmax,ymin,ymax,page) }
+          subject { turtletext_reader.text_in_region(xmin,xmax,ymin,ymax,page,inclusive) }
           it { should eql(expected_text) }
         end
       end
@@ -137,6 +147,7 @@ describe PDF::Reader::Turtletext do
         10.0=>{40.0=>"smoked and streaky da bomb"}
       } }
       {
+        :with_no_match => { :match_term => 'bertie beetle', :expected_position => nil },
         :with_simple_match => { :match_term => 'turkey bacon', :expected_position => {:x=>30.0, :y=>30.0} },
         :with_match_along_line => { :match_term => 'heaven', :expected_position => {:x=>25.0, :y=>40.0} },
         :with_regex_match => { :match_term => /kimchi/, :expected_position => {:x=>15.0, :y=>40.0} },

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pdf-reader-turtletext
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-31 00:00:00.000000000 Z
+date: 2012-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pdf-reader
-  requirement: &70339095317400 !ruby/object:Gem::Requirement
+  requirement: &70159058920880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -21,10 +21,10 @@ dependencies:
         version: 1.1.1
   type: :runtime
   prerelease: false
-  version_requirements: *70339095317400
+  version_requirements: *70159058920880
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70339095316760 !ruby/object:Gem::Requirement
+  requirement: &70159058920240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 1.1.4
   type: :development
   prerelease: false
-  version_requirements: *70339095316760
+  version_requirements: *70159058920240
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &70339095315980 !ruby/object:Gem::Requirement
+  requirement: &70159058919460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 1.6.4
   type: :development
   prerelease: false
-  version_requirements: *70339095315980
+  version_requirements: *70159058919460
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70339095315380 !ruby/object:Gem::Requirement
+  requirement: &70159058918900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 0.9.2.2
   type: :development
   prerelease: false
-  version_requirements: *70339095315380
+  version_requirements: *70159058918900
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70339095314600 !ruby/object:Gem::Requirement
+  requirement: &70159058918080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +65,10 @@ dependencies:
         version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *70339095314600
+  version_requirements: *70159058918080
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: &70339095313760 !ruby/object:Gem::Requirement
+  requirement: &70159058917260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,10 +76,10 @@ dependencies:
         version: '3.11'
   type: :development
   prerelease: false
-  version_requirements: *70339095313760
+  version_requirements: *70159058917260
 - !ruby/object:Gem::Dependency
   name: prawn
-  requirement: &70339095313100 !ruby/object:Gem::Requirement
+  requirement: &70159058916580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -87,10 +87,10 @@ dependencies:
         version: 0.12.0
   type: :development
   prerelease: false
-  version_requirements: *70339095313100
+  version_requirements: *70159058916580
 - !ruby/object:Gem::Dependency
   name: guard-rspec
-  requirement: &70339095312500 !ruby/object:Gem::Requirement
+  requirement: &70159058915980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -98,7 +98,7 @@ dependencies:
         version: 1.2.0
   type: :development
   prerelease: false
-  version_requirements: *70339095312500
+  version_requirements: *70159058915980
 description: a library that can read structured and positional text from PDFs. Ideal
   for asembling structured data from invoices and the like.
 email: gallagher.paul@gmail.com