tabula-rb 1.0.0

data/lib/tabula/cli.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Tabula
+  # Command-line interface for tabula
+  class CLI
+    FORMATS = %w[CSV TSV JSON MARKDOWN].freeze
+
+    def self.run(args)
+      new.run(args)
+    end
+
+    def initialize
+      @options = default_options
+    end
+
+    def run(args)
+      parser = build_parser
+      files = parser.parse(args)
+
+      if @options[:help]
+        puts parser
+        return 0
+      end
+
+      if @options[:version]
+        puts "tabula #{Tabula::VERSION}"
+        return 0
+      end
+
+      if files.empty?
+        warn 'Error: No PDF file specified'
+        warn parser
+        return 1
+      end
+
+      process_files(files)
+    rescue OptionParser::InvalidOption => e
+      warn "Error: #{e.message}"
+      warn parser
+      1
+    rescue Tabula::FileNotFoundError => e
+      warn "Error: #{e.message}"
+      warn 'Please check that the file path is correct and the file exists.'
+      1
+    rescue Tabula::InvalidOptionsError => e
+      warn "Error: Invalid option - #{e.message}"
+      warn 'Use --help to see available options and their valid values.'
+      1
+    rescue Tabula::InvalidPDFError => e
+      warn "Error: Invalid PDF file - #{e.message}"
+      1
+    rescue Tabula::PasswordRequiredError => e
+      warn "Error: PDF is password protected - #{e.message}"
+      warn 'Use the -s/--password option to provide the password.'
+      1
+    rescue StandardError => e
+      warn "Error: #{e.message}"
+      warn e.backtrace.first(5).join("\n") if @options[:debug]
+      1
+    end
+
+    private
+
+    def default_options
+      {
+        area: nil,
+        columns: nil,
+        format: 'CSV',
+        guess: false,
+        lattice: false,
+        stream: false,
+        pages: nil,
+        output: nil,
+        password: nil,
+        help: false,
+        version: false,
+        debug: false
+      }
+    end
+
+    def build_parser
+      OptionParser.new do |opts|
+        opts.banner = 'Usage: tabula [OPTIONS] <pdf_file> [<pdf_file> ...]'
+        opts.separator ''
+        opts.separator 'Extract tables from PDF files'
+        opts.separator ''
+        opts.separator 'Options:'
+
+        opts.on('-a', '--area AREA', 'Extraction area (top,left,bottom,right in points)') do |v|
+          @options[:area] = parse_area(v)
+        end
+
+        opts.on('-c', '--columns COLUMNS', 'Column boundaries (comma-separated x coordinates)') do |v|
+          @options[:columns] = v.split(',').map(&:to_f)
+        end
+
+        opts.on('-f', '--format FORMAT', FORMATS, "Output format: #{FORMATS.join(', ')} (default: CSV)") do |v|
+          @options[:format] = v.upcase
+        end
+
+        opts.on('-g', '--guess', 'Guess table areas (use detection algorithm)') do
+          @options[:guess] = true
+        end
+
+        opts.on('-l', '--lattice', 'Force lattice mode (use ruling lines)') do
+          @options[:lattice] = true
+          @options[:stream] = false
+        end
+
+        opts.on('-t', '--stream', 'Force stream mode (use text positions)') do
+          @options[:stream] = true
+          @options[:lattice] = false
+        end
+
+        opts.on('-p', '--pages PAGES', "Pages to extract (e.g., '1,2,3' or '1-5' or 'all')") do |v|
+          @options[:pages] = parse_pages(v)
+        end
+
+        opts.on('-o', '--output FILE', 'Output file (default: stdout)') do |v|
+          @options[:output] = v
+        end
+
+        opts.on('-s', '--password PASSWORD', 'PDF password') do |v|
+          @options[:password] = v
+        end
+
+        opts.on('--debug', 'Show debug information') do
+          @options[:debug] = true
+        end
+
+        opts.on('-v', '--version', 'Show version') do
+          @options[:version] = true
+        end
+
+        opts.on('-h', '--help', 'Show this help') do
+          @options[:help] = true
+        end
+      end
+    end
+
+    def parse_area(value)
+      parts = value.split(',').map(&:strip)
+      unless parts.size == 4
+        raise Tabula::InvalidOptionsError, "Area must have 4 values: top,left,bottom,right (got #{parts.size} values)"
+      end
+
+      parts.each_with_index do |p, idx|
+        labels = %w[top left bottom right]
+        unless p.match?(/\A-?\d+(\.\d+)?\z/)
+          raise Tabula::InvalidOptionsError, "Area #{labels[idx]} must be numeric, got '#{p}'"
+        end
+      end
+
+      parts.map(&:to_f)
+    end
+
+    def parse_pages(value)
+      return nil if value.downcase == 'all'
+
+      pages = []
+      value.split(',').each do |part|
+        part = part.strip
+        if part.include?('-')
+          range_parts = part.split('-')
+          unless range_parts.size == 2 && range_parts.all? { |p| p.match?(/\A\d+\z/) }
+            raise Tabula::InvalidOptionsError, "Invalid page range: '#{part}'. Use format like '1-5'"
+          end
+
+          range = range_parts.map(&:to_i)
+          if range[0] <= 0 || range[1] <= 0
+            raise Tabula::InvalidOptionsError, "Page numbers must be positive integers, got '#{part}'"
+          end
+          if range[0] > range[1]
+            raise Tabula::InvalidOptionsError, "Invalid page range: '#{part}'. Start must be less than or equal to end"
+          end
+
+          pages.concat((range[0]..range[1]).to_a)
+        else
+          unless part.match?(/\A\d+\z/)
+            raise Tabula::InvalidOptionsError, "Invalid page number: '#{part}'. Page numbers must be positive integers"
+          end
+
+          page_num = part.to_i
+          raise Tabula::InvalidOptionsError, "Page numbers must be positive integers, got '#{part}'" if page_num <= 0
+
+          pages << page_num
+        end
+      end
+      pages.uniq.sort
+    end
+
+    def process_files(files)
+      output_io = @options[:output] ? File.open(@options[:output], 'w') : $stdout
+      had_error = false
+
+      begin
+        files.each_with_index do |file, idx|
+          output_io.puts if idx.positive? # Separate multiple files
+
+          unless File.exist?(file)
+            warn "Error: File not found: #{file}"
+            warn 'Please check that the file path is correct and the file exists.'
+            had_error = true
+            next
+          end
+
+          process_file(file, output_io)
+        end
+      ensure
+        output_io.close if @options[:output]
+      end
+
+      had_error ? 1 : 0
+    end
+
+    def process_file(file, output_io)
+      extraction_options = build_extraction_options
+
+      tables = Tabula.extract(file, **extraction_options)
+
+      if tables.empty?
+        warn "No tables found in #{file}" if @options[:debug]
+        return
+      end
+
+      write_tables(tables, output_io)
+    end
+
+    def build_extraction_options
+      options = {
+        password: @options[:password],
+        guess: @options[:guess]
+      }
+
+      # Set extraction method
+      options[:method] = if @options[:lattice]
+                           :lattice
+                         elsif @options[:stream]
+                           :stream
+                         else
+                           :auto
+                         end
+
+      # Set pages
+      options[:pages] = @options[:pages] if @options[:pages]
+
+      # Set area
+      options[:area] = @options[:area] if @options[:area]
+
+      # Set columns
+      options[:columns] = @options[:columns] if @options[:columns]
+
+      options
+    end
+
+    def write_tables(tables, output_io)
+      case @options[:format]
+      when 'CSV'
+        Writers::CSVWriter.new.write(tables, output_io)
+      when 'TSV'
+        Writers::TSVWriter.new.write(tables, output_io)
+      when 'JSON'
+        Writers::JSONWriter.new(pretty: true).write(tables, output_io)
+      when 'MARKDOWN'
+        Writers::MarkdownWriter.new.write(tables, output_io)
+      end
+    end
+  end
+end

data/lib/tabula/configuration.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Tabula
+  # Configuration class for customizable extraction parameters.
+  # All thresholds can be adjusted to tune extraction behavior.
+  class Configuration
+    # --- Ruling Detection ---
+
+    # Tolerance for determining if a ruling is horizontal or vertical (in points)
+    # Lines with less than this difference in position are considered aligned
+    attr_accessor :orientation_tolerance
+
+    # Tolerance for ruling intersection detection (in points)
+    attr_accessor :intersection_tolerance
+
+    # Maximum thickness of a filled rectangle to be treated as a ruling line (in points)
+    attr_accessor :ruling_thickness_threshold
+
+    # --- Text Element Merging ---
+
+    # Multiplier for space width when determining word boundaries
+    # Lower values = more aggressive word merging
+    attr_accessor :word_gap_multiplier
+
+    # Multiplier for determining line boundaries
+    attr_accessor :line_gap_multiplier
+
+    # --- Cell Detection ---
+
+    # Minimum number of cells required for a valid table
+    attr_accessor :min_cells
+
+    # Minimum dimension (width or height) for a valid table region (in points)
+    attr_accessor :min_table_dimension
+
+    # Tolerance for cell corner detection (in points)
+    attr_accessor :cell_tolerance
+
+    # --- Table Detection ---
+
+    # Minimum number of rows required for table detection
+    attr_accessor :min_rows
+
+    # Overlap threshold for merging duplicate table detections
+    attr_accessor :overlap_threshold
+
+    # Threshold for determining if a table has valid row/column ratio
+    attr_accessor :tabular_ratio_threshold
+
+    # Tolerance for clustering text edges during detection (in points)
+    attr_accessor :edge_clustering_tolerance
+
+    # Padding around detected table areas (in points)
+    attr_accessor :detection_padding
+
+    # --- Rectangle Comparison ---
+
+    # Threshold for vertical overlap comparison
+    attr_accessor :vertical_comparison_threshold
+
+    def initialize
+      # Ruling detection
+      @orientation_tolerance = 1.0
+      @intersection_tolerance = 1.0
+      @ruling_thickness_threshold = 8.0
+
+      # Text element merging
+      @word_gap_multiplier = 0.5
+      @line_gap_multiplier = 0.5
+
+      # Cell detection
+      @min_cells = 4
+      @min_table_dimension = 10.0
+      @cell_tolerance = 2.0
+
+      # Table detection
+      @min_rows = 2
+      @overlap_threshold = 0.9
+      @tabular_ratio_threshold = 0.65
+      @edge_clustering_tolerance = 8.0
+      @detection_padding = 2.0
+
+      # Rectangle comparison
+      @vertical_comparison_threshold = 0.4
+    end
+
+    # Create a copy with overrides
+    # @param overrides [Hash] values to override
+    # @return [Configuration]
+    def with(**overrides)
+      dup.tap do |config|
+        overrides.each { |key, value| config.send("#{key}=", value) }
+      end
+    end
+  end
+
+  # Default configuration instance
+  @default_configuration = Configuration.new
+
+  class << self
+    # Get the default configuration
+    # @return [Configuration]
+    def configuration
+      @default_configuration
+    end
+
+    # Set the default configuration
+    # @param config [Configuration]
+    def configuration=(config)
+      @default_configuration = config
+    end
+
+    # Configure with a block
+    # @yield [Configuration]
+    def configure
+      yield configuration
+    end
+  end
+end

data/lib/tabula/core/point.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Tabula
+  # Represents a 2D point with x and y coordinates
+  class Point
+    attr_accessor :x, :y
+
+    def initialize(x, y)
+      @x = x.to_f
+      @y = y.to_f
+    end
+
+    def to_a
+      [x, y]
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Point)
+
+      x == other.x && y == other.y
+    end
+    alias eql? ==
+
+    def hash
+      [x, y].hash
+    end
+
+    def distance_to(other)
+      Math.sqrt(((x - other.x)**2) + ((y - other.y)**2))
+    end
+
+    def distance_squared_to(other)
+      ((x - other.x)**2) + ((y - other.y)**2)
+    end
+
+    def +(other)
+      Point.new(x + other.x, y + other.y)
+    end
+
+    def -(other)
+      Point.new(x - other.x, y - other.y)
+    end
+
+    def *(other)
+      Point.new(x * other, y * other)
+    end
+
+    def /(other)
+      Point.new(x / other, y / other)
+    end
+
+    def to_s
+      "Point(#{x}, #{y})"
+    end
+
+    def inspect
+      to_s
+    end
+  end
+end

data/lib/tabula/core/rectangle.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module Tabula
+  # Represents a rectangle with position and dimensions.
+  # Coordinates use PDF coordinate system (origin at bottom-left).
+  class Rectangle
+    # Threshold for vertical overlap comparison (40% overlap)
+    VERTICAL_COMPARISON_THRESHOLD = 0.4
+
+    attr_accessor :top, :left, :width, :height
+
+    def initialize(top, left, width, height)
+      @top = top.to_f
+      @left = left.to_f
+      @width = width.to_f
+      @height = height.to_f
+    end
+
+    # Create rectangle from bounds [top, left, bottom, right]
+    def self.from_bounds(top, left, bottom, right)
+      new(top, left, right - left, bottom - top)
+    end
+
+    # Create rectangle from two points
+    def self.from_points(p1, p2)
+      top = [p1.y, p2.y].min
+      left = [p1.x, p2.x].min
+      bottom = [p1.y, p2.y].max
+      right = [p1.x, p2.x].max
+      from_bounds(top, left, bottom, right)
+    end
+
+    # Compute bounding box of multiple rectangles
+    def self.bounding_box_of(rectangles)
+      return nil if rectangles.empty?
+
+      top = rectangles.map(&:top).min
+      left = rectangles.map(&:left).min
+      bottom = rectangles.map(&:bottom).max
+      right = rectangles.map(&:right).max
+
+      from_bounds(top, left, bottom, right)
+    end
+
+    def bottom
+      top + height
+    end
+
+    def bottom=(value)
+      @height = value - top
+    end
+
+    def right
+      left + width
+    end
+
+    def right=(value)
+      @width = value - left
+    end
+
+    def x
+      left
+    end
+
+    def x=(value)
+      self.left = value
+    end
+
+    def y
+      top
+    end
+
+    def y=(value)
+      self.top = value
+    end
+
+    def area
+      width * height
+    end
+
+    def center
+      Point.new(left + (width / 2.0), top + (height / 2.0))
+    end
+
+    def bounds
+      [top, left, bottom, right]
+    end
+
+    def points
+      [
+        Point.new(left, top),
+        Point.new(right, top),
+        Point.new(right, bottom),
+        Point.new(left, bottom)
+      ]
+    end
+
+    # Calculate vertical overlap with another rectangle
+    def vertical_overlap(other)
+      [0, [bottom, other.bottom].min - [top, other.top].max].max
+    end
+
+    # Calculate horizontal overlap with another rectangle
+    def horizontal_overlap(other)
+      [0, [right, other.right].min - [left, other.left].max].max
+    end
+
+    # Check if rectangles overlap vertically
+    def vertically_overlaps?(other, threshold = VERTICAL_COMPARISON_THRESHOLD)
+      overlap = vertical_overlap(other)
+      min_height = [height, other.height].min
+      return false if min_height.zero?
+
+      (overlap / min_height) >= threshold
+    end
+
+    # Check if rectangles overlap horizontally
+    def horizontally_overlaps?(other, threshold = 0.0)
+      overlap = horizontal_overlap(other)
+      min_width = [width, other.width].min
+      return true if min_width.zero? && overlap.zero?
+      return false if min_width.zero?
+
+      (overlap / min_width) > threshold
+    end
+
+    # Calculate overlap ratio (intersection area / union area)
+    def overlap_ratio(other)
+      intersection_area = vertical_overlap(other) * horizontal_overlap(other)
+      return 0.0 if intersection_area.zero?
+
+      union_area = area + other.area - intersection_area
+      return 0.0 if union_area.zero?
+
+      intersection_area / union_area
+    end
+
+    # Check if this rectangle contains a point
+    def contains_point?(point)
+      point.x.between?(left, right) && point.y >= top && point.y <= bottom
+    end
+
+    # Check if this rectangle fully contains another
+    def contains?(other)
+      left <= other.left && right >= other.right && top <= other.top && bottom >= other.bottom
+    end
+
+    # Check if this rectangle intersects another
+    def intersects?(other)
+      !(other.left > right || other.right < left || other.top > bottom || other.bottom < top)
+    end
+
+    # Merge this rectangle with another, returning the bounding box
+    def merge(other)
+      Rectangle.from_bounds(
+        [top, other.top].min,
+        [left, other.left].min,
+        [bottom, other.bottom].max,
+        [right, other.right].max
+      )
+    end
+
+    # Merge in place
+    def merge!(other)
+      merged = merge(other)
+      @top = merged.top
+      @left = merged.left
+      @width = merged.width
+      @height = merged.height
+      self
+    end
+
+    # Return intersection rectangle, or nil if no intersection
+    def intersection(other)
+      return nil unless intersects?(other)
+
+      Rectangle.from_bounds(
+        [top, other.top].max,
+        [left, other.left].max,
+        [bottom, other.bottom].min,
+        [right, other.right].min
+      )
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Rectangle)
+
+      top == other.top && left == other.left && width == other.width && height == other.height
+    end
+    alias eql? ==
+
+    def hash
+      [top, left, width, height].hash
+    end
+
+    def dup
+      Rectangle.new(top, left, width, height)
+    end
+
+    def to_s
+      "Rectangle[top=#{top}, left=#{left}, width=#{width}, height=#{height}]"
+    end
+
+    def inspect
+      to_s
+    end
+
+    # Comparator for sorting by position (top to bottom, left to right)
+    def <=>(other)
+      result = top <=> other.top
+      return result unless result.zero?
+
+      left <=> other.left
+    end
+
+    include Comparable
+  end
+end