percept 0.0.1 → 3.0.0

data/spec/percept/checkbox_field/height_spec.rb

@@ -0,0 +1,15 @@
+describe Percept::CheckboxField, '#height' do
+
+  it 'returns the height' do
+    field = Percept::CheckboxField.new(
+      start_x: 5,
+      end_x: 10,
+      start_y: 7,
+      end_y: 12,
+    )
+    expect(field.height).to eq 5
+    field.start_y = 9
+    expect(field.height).to eq 3
+  end
+
+end

data/spec/percept/checkbox_field/width_spec.rb

@@ -0,0 +1,15 @@
+describe Percept::CheckboxField, '#width' do
+
+  it 'returns the width' do
+    field = Percept::CheckboxField.new(
+      start_x: 5,
+      end_x: 10,
+      start_y: 7,
+      end_y: 12,
+    )
+    expect(field.width).to eq 5
+    field.start_x = 7
+    expect(field.width).to eq 3
+  end
+
+end

data/spec/percept/field/contains_spec.rb

@@ -0,0 +1,50 @@
+describe Percept::Field, '#contains?' do
+
+  let(:field1) do
+    Percept::Field.new(
+      start_x: 10,
+      start_y: 10,
+      end_x: 20,
+      end_y: 20,
+      line: 'line',
+      image: 'image',
+    )
+  end
+
+  let(:field2) do
+    Percept::Field.new(
+      start_x: 15,
+      start_y: 15,
+      end_x: 25,
+      end_y: 18,
+      line: 'line',
+      image: 'image',
+    )
+  end
+
+  let(:field3) do
+    Percept::Field.new(
+      start_x: 100,
+      start_y: 100,
+      end_x: 200,
+      end_y: 200,
+      line: 'line',
+      image: 'image',
+    )
+  end
+
+  context 'when the fields overlap' do
+    it 'returns true' do
+      expect(field1.overlaps?(field2)).to eq true
+      expect(field2.overlaps?(field1)).to eq true
+    end
+  end
+
+  context 'when the fields do not overlap' do
+    it 'returns false' do
+      expect(field1.overlaps?(field3)).to eq false
+      expect(field3.overlaps?(field1)).to eq false
+    end
+  end
+
+end

data/spec/percept/field_detector/detect_field_spec.rb

@@ -0,0 +1,90 @@
+describe Percept::FieldDetector, '#detect_field' do
+
+  let(:min_field_height) { 5 }
+  let(:max_field_height) { 10 }
+  let(:field_detector) { Percept::FieldDetector.new }
+
+  before(:each) do
+    Percept.configure do |config|
+      config.min_field_height = min_field_height
+      config.max_field_height = max_field_height
+    end
+  end
+
+  context 'when top of image > max_field_height above line' do
+    let(:image_path) { File.join(fixture_path, 'low_line.png') }
+    let(:image) { image_class.new(image_path) }
+
+    it 'returns a field that has height of max_field_height' do
+      expect(image.lines.size).to eq 1
+      field = field_detector.detect_field(image.lines.first, image)
+      expect(field.height).to eq max_field_height
+      expect(field.width).to eq 32
+    end
+  end
+
+  context 'when top of image < max_field_height above line' do
+    let(:image_path) { File.join(fixture_path, 'high_line.png') }
+    let(:image) { image_class.new(image_path) }
+
+    it 'returns field with height of distance between line and top' do
+      expect(image.lines.size).to eq 1
+      field = field_detector.detect_field(image.lines.first, image)
+      expect(field.height).to eq 5
+    end
+  end
+
+  context 'when another line is < max_field_height above line' do
+    let(:image_path) { File.join(fixture_path, 'mid_lines.png') }
+    let(:image) { image_class.new(image_path) }
+
+    it 'returns field with height of distance between lines' do
+      expect(image.lines.size).to eq 2
+      field = field_detector.detect_field(image.lines.last, image)
+      expect(field.height).to eq 6
+    end
+  end
+
+  context 'when another line is < min_field_height above line' do
+    let(:image_path) { File.join(fixture_path, 'low_lines.png') }
+    let(:image) { image_class.new(image_path) }
+
+    it 'does not return a field' do
+      expect(image.lines.size).to eq 2
+      field = field_detector.detect_field(image.lines.last, image)
+      expect(field).to be_nil
+    end
+  end
+
+  context 'when there are nubs above the line' do
+    let(:image_path) { File.join(fixture_path, 'nubs.png') }
+    let(:image) { image_class.new(image_path) }
+
+    it 'returns a field that ignores the nubs' do
+      expect(image.lines.size).to eq 1
+      field = field_detector.detect_field(image.lines.last, image)
+      expect(field).not_to be_nil
+      expect(field.end_y).to eq 12
+      expect(field.start_y).to eq 2
+    end
+  end
+
+  context 'when the line is slanted to the left' do
+    let(:image_path) { File.join(fixture_path, 'slanted_left.png') }
+    let(:image) { image_class.new(image_path) }
+
+    it 'returns a field from the top of the line' do
+      expect(image.lines.size).to eq 1
+    end
+  end
+
+  context 'when the line is slanted to the right' do
+    let(:image_path) { File.join(fixture_path, 'slanted_right.png') }
+    let(:image) { image_class.new(image_path) }
+
+    it 'returns a field from the top of the line' do
+      expect(image.lines.size).to eq 1
+    end
+  end
+
+end

data/spec/percept/field_detector/detect_fields_spec.rb

@@ -0,0 +1,42 @@
+describe Percept::FieldDetector, '#detect_fields' do
+
+  let(:field_detector) { Percept::FieldDetector.new }
+
+  it 'detects fields next to text' do
+    image = image_class.new(File.join(fixture_path, 'field_next_to_text.png'))
+    fields = field_detector.detect_fields(image)
+    expect(fields.size).to eq 1
+  end
+
+  it 'detects thin fields' do
+    image = image_class.new(File.join(fixture_path, 'thin_field.png'))
+    fields = field_detector.detect_fields(image)
+    expect(fields.size).to eq 1
+
+    field = fields.first
+    expect(field.start_x).to eq 33
+    expect(field.end_x).to eq 115
+    expect(field.start_y).to eq 14
+    expect(field.end_y).to eq 38
+  end
+
+  context 'when there is only text' do
+    it 'does not return any fields' do
+      image = image_class.new(File.join(fixture_path, 'text_no_line.png'))
+      expect(field_detector.detect_fields(image).size).to eq 0
+      image = image_class.new(File.join(fixture_path, 'text_no_line_2.png'))
+      expect(field_detector.detect_fields(image).size).to eq 0
+    end
+  end
+
+  it 'detects fields with text on them on the left side' do
+    image = image_class.new(File.join(fixture_path, 'text_on_line.png'))
+    expect(field_detector.detect_fields(image).size).to eq 1
+  end
+
+  it 'detects fields with text on them on the both sides' do
+    image = image_class.new(File.join(fixture_path, 'more_text_on_line.png'))
+    expect(field_detector.detect_fields(image).size).to eq 1
+  end
+
+end

data/spec/percept/fields_collection/shovel_spec.rb

@@ -0,0 +1,53 @@
+describe Percept::FieldCollection, '#<<' do
+  let(:field1) do
+    Percept::Field.new(
+      start_x: 10,
+      start_y: 10,
+      end_x: 20,
+      end_y: 20,
+      line: 'line',
+      image: 'image',
+    )
+  end
+  let(:field2) do
+    Percept::Field.new(
+      start_x: 15,
+      start_y: 15,
+      end_x: 25,
+      end_y: 18,
+      line: 'line',
+      image: 'image',
+    )
+  end
+  let(:field3) do
+    Percept::Field.new(
+      start_x: 100,
+      start_y: 100,
+      end_x: 200,
+      end_y: 200,
+      line: 'line',
+      image: 'image',
+    )
+  end
+  let(:fields_collection) { Percept::FieldCollection.new }
+
+  before(:each) do
+    fields_collection << field1
+    expect(fields_collection.size).to eq 1
+  end
+
+  context 'when the incoming field overlaps an existing one' do
+    it 'does not add the field to the list' do
+      fields_collection << field2
+      expect(fields_collection.size).to eq 1
+    end
+  end
+
+  context 'when the incoming field does not overlap an existing one' do
+    it 'adds the field to the list' do
+      fields_collection << field3
+      expect(fields_collection.size).to eq 2
+    end
+  end
+
+end

data/spec/percept/line/approxequals_spec.rb

@@ -0,0 +1,60 @@
+describe Percept::Line, '#=~' do
+  let(:params) { { rows: nil, image: nil } }
+
+  context 'when the lines have the same length' do
+    let(:params) { { start_x: 5, end_x: 10, rows: nil, image: nil } }
+
+    context 'when start_y equals the other end_y' do
+      it 'returns true' do
+        line1 = Percept::Line.new(params.merge(start_y: 8))
+        line2 = Percept::Line.new(params.merge(start_y: 7))
+        expect(line1 =~ line2).to be true
+      end
+    end
+
+    context 'when end_y equals the other start_y' do
+      it 'returns true' do
+        line1 = Percept::Line.new(params.merge(start_y: 7))
+        line2 = Percept::Line.new(params.merge(start_y: 8))
+        expect(line1 =~ line2).to be true
+      end
+    end
+
+    context 'when neither start_y matches the other end_y' do
+      it 'returns false' do
+        line1 = Percept::Line.new(params.merge(start_y: 6))
+        line2 = Percept::Line.new(params.merge(start_y: 8))
+        expect(line1 =~ line2).to be false
+      end
+    end
+  end
+
+  context 'when the lines have x overlap' do
+    it 'returns true' do
+      line1 = Percept::Line.new(params.merge(start_x: 2, end_x: 7, start_y: 7))
+      line2 = Percept::Line.new(params.merge(start_x: 4, end_x: 9, start_y: 8))
+      expect(line1 =~ line2).to be true
+      line1 = Percept::Line.new(params.merge(start_x: 4, end_x: 9, start_y: 7))
+      line2 = Percept::Line.new(params.merge(start_x: 2, end_x: 7, start_y: 8))
+      expect(line1 =~ line2).to be true
+      line1 = Percept::Line.new(params.merge(start_x: 5, end_x: 9, start_y: 7))
+      line2 = Percept::Line.new(params.merge(start_x: 2, end_x: 5, start_y: 8))
+      expect(line1 =~ line2).to be true
+      line1 = Percept::Line.new(params.merge(start_x: 2, end_x: 5, start_y: 7))
+      line2 = Percept::Line.new(params.merge(start_x: 5, end_x: 9, start_y: 8))
+      expect(line1 =~ line2).to be true
+    end
+  end
+
+  context 'when the lines do not have x overlap' do
+    it 'returns true' do
+      line1 = Percept::Line.new(params.merge(start_x: 2, end_x: 5, start_y: 7))
+      line2 = Percept::Line.new(params.merge(start_x: 6, end_x: 9, start_y: 8))
+      expect(line1 =~ line2).to be false
+      line1 = Percept::Line.new(params.merge(start_x: 6, end_x: 9, start_y: 7))
+      line2 = Percept::Line.new(params.merge(start_x: 2, end_x: 5, start_y: 8))
+      expect(line1 =~ line2).to be false
+    end
+  end
+
+end

data/spec/percept/line/initialize_spec.rb

@@ -0,0 +1,29 @@
+describe Percept::Line, '#initialize' do
+
+  let(:params) do
+    { start_x: 3, end_x: 10, start_y: 5, row: 'my_row', image: 'my_image' }
+  end
+  let(:line) { Percept::Line.new(params) }
+
+  it 'sets its variables' do
+    expect(line.start_x).to eq 3
+    expect(line.end_x).to eq 10
+    expect(line.start_y).to eq 5
+    expect(line.rows).to eq ['my_row']
+    expect(line.image).to eq 'my_image'
+  end
+
+  context 'when :end_y is not given' do
+    it 'sets :end_y to :start_y + 1' do
+      expect(line.end_y).to eq 6
+    end
+  end
+
+  context 'when :end_y is given' do
+    it 'uses the given value' do
+      params[:end_y] = 15
+      expect(line.end_y).to eq 15
+    end
+  end
+
+end

data/spec/percept/line/length_spec.rb

@@ -0,0 +1,22 @@
+describe Percept::Line, '#length' do
+
+  let(:line) do
+    Percept::Line.new(
+      start_y: 5,
+      end_y: 10,
+      start_x: 6,
+      end_x: 8,
+      row: 'no row',
+      image: 'no image',
+    )
+  end
+
+  it 'returns end_x - start_x' do
+    expect(line.length).to eq 2
+    line.end_x = 15
+    expect(line.length).to eq 9
+    line.start_x = 5
+    expect(line.length).to eq 10
+  end
+
+end

data/spec/percept/line/merge_bang_spec.rb

@@ -0,0 +1,58 @@
+describe Percept::Line, '#merge!' do
+
+  let(:params) do
+    { start_x: 3, end_x: 10, start_y: 5, row: 'my_row', image: 'my_image' }
+  end
+
+  let(:line) do
+    Percept::Line.new(params)
+  end
+
+  context 'when start_y is greater than the other start_y' do
+    it 'sets the start_y to the other start_y' do
+      other_line = Percept::Line.new(params.merge(start_y: 4))
+      line.merge!(other_line)
+      expect(line.start_y).to eq 4
+    end
+  end
+
+  context 'when end_y is less than the other end_y' do
+    it 'sets the end_y to the other end_y' do
+      other_line = Percept::Line.new(params.merge(start_y: 6))
+      line.merge!(other_line)
+      expect(line.end_y).to eq 7
+    end
+  end
+
+  context 'when start_x is greater than the other start_x' do
+    it 'sets the start_x to the other start_x' do
+      other_line = Percept::Line.new(params.merge(start_x: 2))
+      line.merge!(other_line)
+      expect(line.start_x).to eq 2
+    end
+  end
+
+  context 'when end_x is less than the other end_x' do
+    it 'sets the end_x to the other end_x' do
+      other_line = Percept::Line.new(params.merge(end_x: 11))
+      line.merge!(other_line)
+      expect(line.end_x).to eq 11
+    end
+
+    context 'when start_x is greater than the other start_x' do
+      it 'sets the start_x to the other start_x' do
+        other_line = Percept::Line.new(params.merge(end_x: 11, start_x: 2))
+        line.merge!(other_line)
+        expect(line.end_x).to eq 11
+        expect(line.start_x).to eq 2
+      end
+    end
+  end
+
+  it 'combines the rows' do
+    other_line = Percept::Line.new(params.merge(row: 'other_row'))
+    line.merge!(other_line)
+    expect(line.rows).to eq %w(my_row other_row)
+  end
+
+end

data/spec/percept/line/pixels_spec.rb

@@ -0,0 +1,15 @@
+describe Percept::Line, '#pixels' do
+
+  let(:image) { image_class.new(File.join(fixture_path, 'low_line.png')) }
+  let(:line) { image.lines.first }
+
+  before(:each) do
+    Percept.config.line_length = 30
+  end
+
+  it 'returns the associated pixels for the line' do
+    expect(line.pixels.size).to eq 32
+    expect(line.pixels.all?(&:blackish?)).to eq true
+  end
+
+end

data/spec/percept/line/split_spec.rb

@@ -0,0 +1,28 @@
+describe Percept::Line, '#split' do
+
+  let(:more_corners_path) { File.join(fixture_path, 'more_corners.png') }
+  let(:image) { image_class.new(more_corners_path) }
+
+  before(:each) do
+    Percept.config.line_length = 30
+  end
+
+  it 'returns a collection of lines split by vertical dividers' do
+    line = image.lines[8]
+    Percept.config.line_length = 32
+    lines = line.split
+    expect(lines).to be_empty
+    Percept.config.line_length = 5
+    lines = line.split
+    expect(lines.length).to eq 2
+    expect(lines.first.length).to eq 30
+    expect(lines.last.length).to eq 6
+
+    line_2 = image.lines[9]
+    lines = line_2.split
+    expect(lines.length).to eq 2
+    expect(lines.last.length).to eq 30
+    expect(lines.first.length).to eq 6
+  end
+
+end

data/spec/percept/line/to_s_spec.rb

@@ -0,0 +1,13 @@
+describe Percept::Line, '#to_s' do
+
+  let(:attributes) { { start_x: 3, end_x: 10, start_y: 5 } }
+
+  let(:line) do
+    Percept::Line.new(attributes.merge(row: 'my_row', image: 'my_image'))
+  end
+
+  it 'returns a string of the line attributes' do
+    expect(line.to_s).to eq attributes.merge(end_y: 6).to_s
+  end
+
+end

data/spec/percept/line_collection/merge_line_spec.rb

@@ -0,0 +1,50 @@
+describe Percept::LineCollection, '#merge_line' do
+
+  let(:thick_image_path) { File.join(fixture_path, 'thick_line.png') }
+  let(:thick_image) { image_class.new(thick_image_path) }
+  let(:nub_bottom_left_path) { File.join(fixture_path, 'nub_bottom_left.png') }
+  let(:nub_bottom_left) { image_class.new(nub_bottom_left_path) }
+  let(:nub_top_right_path) { File.join(fixture_path, 'nub_top_right.png') }
+  let(:nub_top_right) { image_class.new(nub_bottom_left_path) }
+  let(:nub_both_sides_path) { File.join(fixture_path, 'nub_both_sides.png') }
+  let(:nub_both_sides) { image_class.new(nub_bottom_left_path) }
+
+  before(:each) do
+    Percept.config.line_length = 30
+  end
+
+  context 'when there is a thick line in the image' do
+    it 'merges the lines together' do
+      lines = thick_image.lines
+      expect(lines.size).to eq 1
+    end
+  end
+
+  context 'when there is a nub on the bottom line to the left' do
+    it 'merges the two lines together' do
+      lines = nub_bottom_left.lines
+      expect(lines.size).to eq 1
+      line = lines.first
+      expect(line.end_y - line.start_y).to eq 2
+    end
+  end
+
+  context 'when there is a nub on the top line to the right' do
+    it 'merges the two lines together' do
+      lines = nub_top_right.lines
+      expect(lines.size).to eq 1
+      line = lines.first
+      expect(line.end_y - line.start_y).to eq 2
+    end
+  end
+
+  context 'when there is a nub on both sides of a line' do
+    it 'merges the two lines together' do
+      lines = nub_both_sides.lines
+      expect(lines.size).to eq 1
+      line = lines.first
+      expect(line.end_y - line.start_y).to eq 2
+    end
+  end
+
+end

data/spec/percept/line_collection/remove_unwanted_lines_bang_spec.rb

@@ -0,0 +1,17 @@
+describe Percept::LineCollection, '#remove_unwanted_lines!' do
+
+  let(:image_path) { File.join(fixture_path, 'corners.png') }
+  let(:image) { image_class.new(image_path) }
+  let(:collection) { image.lines }
+
+  before(:each) do
+    Percept.config.line_length = 30
+  end
+
+  it 'removes lines that are table borders' do
+    expect(collection.size).to eq 10
+    collection.remove_unwanted_lines!
+    expect(collection.size).to eq 9
+  end
+
+end

data/spec/percept/line_collection/split_spec.rb

@@ -0,0 +1,20 @@
+describe Percept::LineCollection, '#split' do
+
+  let(:image_path) { File.join(fixture_path, 'more_corners.png') }
+  let(:image) { image_class.new(image_path) }
+  let(:collection) { image.lines }
+
+  before(:each) do
+    Percept.config.line_length = 30
+  end
+
+  it 'returns a new collection with associated lines split' do
+    expect(collection.length).to eq 10
+    new_collection = collection.split
+    expect(new_collection.length).to eq 10
+    Percept.config.line_length = 5
+    new_collection = collection.split
+    expect(new_collection.length).to eq 12
+  end
+
+end

data/spec/percept/line_collection/to_s_spec.rb

@@ -0,0 +1,11 @@
+describe Percept::LineCollection, '#to_s' do
+
+  let(:collection) { Percept::LineCollection.new }
+
+  it 'returns a stringified version of its associated lines' do
+    lines = %w(line_1 line_2)
+    collection.lines = lines
+    expect(collection.to_s).to eq lines.to_s
+  end
+
+end