dbf 5.4.0 → 5.6.0

data/lib/dbf/database/foxpro.rb

@@ -20,13 +20,16 @@ module DBF
       #  contacts = db.contacts.record(0)
       #
       # @param path [String]
-      def initialize(path)
+      # @param max_memo_size [optional Integer] Bytes to read from each memo
+      #   of the container and its tables; see DBF::Table.new
+      def initialize(path, max_memo_size: nil)
         @path = path
         @dirname = File.dirname(@path)
-        @db = DBF::Table.new(@path)
+        @max_memo_size = max_memo_size
+        @db = DBF::Table.new(@path, max_memo_size:)
         @tables = extract_dbc_data
       rescue Errno::ENOENT
-        raise DBF::FileNotFoundError, "file not found: #{path}"
+        raise FileHandler.not_found(path)
       end
 
       def table_names
@@ -38,7 +41,7 @@ module DBF
       # @param name [String]
       # @return [DBF::Table]
       def table(name)
-        Table.new(table_path(name), long_names: @tables[name])
+        Table.new(table_path(name), long_names: @tables[name], max_memo_size: @max_memo_size)
       end
 
       # Searches the database directory for the table's dbf file
@@ -71,15 +74,21 @@ module DBF
 
       def method_missing(method, *args) # :nodoc:
         name = method.to_s
-        table_names.index(name) ? table(name) : super
+        table_method?(name) ? table(name) : super
       end
 
       def respond_to_missing?(method, *)
-        table_names.index(method.to_s) || super
+        table_method?(method.to_s) || super
       end
 
       private
 
+      # Table names come from the container file, so implicit-conversion
+      # method names are never dispatched to a table (see Record).
+      def table_method?(name) # :nodoc:
+        !Record::RESERVED_METHODS.include?(name) && table_names.include?(name)
+      end
+
       # This method extracts the data from the database container. This is
       # just an ordinary table with a treelike structure. Field definitions
       # are in the same order as in the linked tables but only the long name
@@ -108,19 +117,18 @@ module DBF
     class Table < DBF::Table
       attr_reader :long_names
 
-      def initialize(path, long_names:)
+      def initialize(path, long_names:, max_memo_size: nil)
         @long_names = long_names
-        super(path)
+        super(path, max_memo_size:)
       end
 
+      # Replaces each column's short name with its long name from the
+      # container. Long names were decoded when the .dbc was read, so they
+      # are not decoded again with this table's code page.
       def build_columns # :nodoc:
-        columns = super
-
-        # modify the column definitions to use the long names as the
-        # columnname property is readonly, recreate the column definitions
-        columns.map do |column|
-          long_name = long_names[columns.index(column)]
-          Column.new(self, long_name, column.type, column.length, column.decimal)
+        super.each_with_index.map do |column, index|
+          long_name = long_names[index]
+          long_name ? column.with_name(long_name) : column
         end
       end
     end

data/lib/dbf/encoder.rb

@@ -4,12 +4,15 @@ module DBF
   # Transcodes strings from a source encoding to a target encoding.
   #
   # Most DBF code pages map to encodings built into Ruby and are converted
-  # with String#encode. A few (Mazovia cp620, Kamenický cp895) have no Ruby
-  # equivalent and are decoded through vendored byte-to-Unicode tables.
+  # with String#encode. A few (Mazovia cp620, Kamenický cp895, Macintosh
+  # Central European) have no Ruby converter and are decoded through
+  # vendored byte-to-Unicode tables.
   module Encoder
     # Byte-to-Unicode tables generated from
-    # https://github.com/SheetJS/js-codepage/blob/master/codepages/620.TBL and
-    # https://github.com/SheetJS/js-codepage/blob/master/codepages/895.TBL
+    # https://github.com/SheetJS/js-codepage/blob/master/codepages/620.TBL,
+    # https://github.com/SheetJS/js-codepage/blob/master/codepages/895.TBL and
+    # (Mac Central European) Python's mac_latin2 codec, which matches iconv's
+    # MACCENTRALEUROPE
 
     # Mazovia (Polish) MS-DOS
     CP620_TO_UNICODE = [
@@ -83,9 +86,46 @@ module DBF
       0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
     ].freeze
 
+    # Macintosh Central European (Ruby has the encoding but no converter)
+    MACCENTEURO_TO_UNICODE = [
+      0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+      0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+      0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+      0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+      0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+      0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+      0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+      0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+      0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+      0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+      0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+      0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+      0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+      0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+      0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+      0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+      0x00C4, 0x0100, 0x0101, 0x00C9, 0x0104, 0x00D6, 0x00DC, 0x00E1,
+      0x0105, 0x010C, 0x00E4, 0x010D, 0x0106, 0x0107, 0x00E9, 0x0179,
+      0x017A, 0x010E, 0x00ED, 0x010F, 0x0112, 0x0113, 0x0116, 0x00F3,
+      0x0117, 0x00F4, 0x00F6, 0x00F5, 0x00FA, 0x011A, 0x011B, 0x00FC,
+      0x2020, 0x00B0, 0x0118, 0x00A3, 0x00A7, 0x2022, 0x00B6, 0x00DF,
+      0x00AE, 0x00A9, 0x2122, 0x0119, 0x00A8, 0x2260, 0x0123, 0x012E,
+      0x012F, 0x012A, 0x2264, 0x2265, 0x012B, 0x0136, 0x2202, 0x2211,
+      0x0142, 0x013B, 0x013C, 0x013D, 0x013E, 0x0139, 0x013A, 0x0145,
+      0x0146, 0x0143, 0x00AC, 0x221A, 0x0144, 0x0147, 0x2206, 0x00AB,
+      0x00BB, 0x2026, 0x00A0, 0x0148, 0x0150, 0x00D5, 0x0151, 0x014C,
+      0x2013, 0x2014, 0x201C, 0x201D, 0x2018, 0x2019, 0x00F7, 0x25CA,
+      0x014D, 0x0154, 0x0155, 0x0158, 0x2039, 0x203A, 0x0159, 0x0156,
+      0x0157, 0x0160, 0x201A, 0x201E, 0x0161, 0x015A, 0x015B, 0x00C1,
+      0x0164, 0x0165, 0x00CD, 0x017D, 0x017E, 0x016A, 0x00D3, 0x00D4,
+      0x016B, 0x016E, 0x00DA, 0x016F, 0x0170, 0x0171, 0x0172, 0x0173,
+      0x00DD, 0x00FD, 0x0137, 0x017B, 0x0141, 0x017C, 0x0122, 0x02C7
+    ].freeze
+
     CUSTOM_TABLES = {
       'cp620' => CP620_TO_UNICODE,
-      'cp895' => CP895_TO_UNICODE
+      'cp895' => CP895_TO_UNICODE,
+      'maccenteuro' => MACCENTEURO_TO_UNICODE
     }.freeze
 
     # Is the encoding a code page without a Ruby Encoding, decoded through
@@ -97,6 +137,21 @@ module DBF
       encoding.is_a?(::String) && CUSTOM_TABLES.key?(encoding.downcase)
     end
 
+    # Raise unless strings in the encoding can be transcoded to Unicode, so
+    # an unknown name or a dummy encoding such as UTF-7 fails up front with
+    # a DBF::Error rather than with ArgumentError or
+    # Encoding::ConverterNotFoundError on the first read.
+    #
+    # @param encoding [String, Encoding]
+    # @raise [DBF::UnsupportedEncodingError]
+    def self.check(encoding)
+      return if custom?(encoding)
+
+      (+'').force_encoding(encoding).encode(Encoding::UTF_8)
+    rescue ArgumentError, TypeError, Encoding::ConverterNotFoundError
+      raise DBF::UnsupportedEncodingError, "unsupported encoding: #{encoding}"
+    end
+
     # Transcode a string from source_encoding to target_encoding
     #
     # @param string [String]

data/lib/dbf/errors.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module DBF
+  # Base class for all errors raised by the DBF library, so callers can
+  # rescue DBF::Error to catch anything the library raises.
+  class Error < StandardError
+  end
+
+  # A file cannot be opened. The message names only the file, not its
+  # directory, so an app that shows error messages to users does not reveal
+  # server paths; #path has the full path for logging.
+  class FileError < Error
+    # @return [String, nil] the full path of the file
+    attr_reader :path
+
+    def initialize(message = nil, path: nil)
+      super(message)
+      @path = path
+    end
+  end
+
+  class FileNotFoundError < FileError
+  end
+
+  # A file exists but cannot be opened, e.g. it is a directory or is not
+  # readable.
+  class FileAccessError < FileError
+  end
+
+  # The encoding passed to Table.new is unknown, or Ruby cannot transcode
+  # it to Unicode.
+  class UnsupportedEncodingError < Error
+  end
+
+  class NoColumnsDefined < Error
+  end
+end

data/lib/dbf/file_handler.rb

@@ -9,28 +9,76 @@ module DBF
       when StringIO
         data
       when String
-        File.open(data, 'rb')
+        open_file(data)
       else
-        raise ArgumentError, 'data must be a file path or StringIO object'
+        raise ArgumentError, 'data must be a file path or an IO-like object responding to #read and #seek' unless data.respond_to?(:read) && data.respond_to?(:seek)
+
+        # DBF is a binary format; a File opened in text mode would corrupt
+        # reads on Windows.
+        data.binmode if data.respond_to?(:binmode)
+        data
       end
-    rescue Errno::ENOENT
-      raise DBF::FileNotFoundError, "file not found: #{data}"
     end
 
-    def open_memo(data, memo, memo_class, version)
+    # Opens a file for binary reading, raising DBF errors instead of the
+    # system errors File.open raises, so callers need only rescue DBF::Error.
+    # A path containing a null byte cannot name a file, so it is not found.
+    # A directory opens without error but fails on the first read, so it is
+    # rejected here.
+    def open_file(path)
+      raise Errno::EISDIR if File.directory?(path)
+
+      File.open(path, 'rb')
+    rescue Errno::ENOENT, Errno::ENOTDIR, ArgumentError
+      raise not_found(path)
+    rescue SystemCallError => e
+      reason = SystemCallError.new(nil, e.errno).message
+      raise DBF::FileAccessError.new("cannot open file: #{display_name(path)} (#{reason})", path:)
+    end
+
+    def not_found(path)
+      DBF::FileNotFoundError.new("file not found: #{display_name(path)}", path:)
+    end
+
+    # The file name without its directory, for error messages. A null byte,
+    # which File.basename rejects, is shown as "?".
+    def display_name(path)
+      File.basename(path.to_s.tr("\x00", '?'))
+    end
+
+    def open_memo(data, memo, memo_class, version, max_size: nil)
       if memo
-        meth = memo.is_a?(StringIO) ? :new : :open
-        memo_class.send(meth, memo, version)
-      elsif !data.is_a?(StringIO)
-        path = Dir.glob(memo_search_path(data)).first
-        path && memo_class.open(path, version)
+        meth = memo.is_a?(String) ? :open : :new
+        memo_class.send(meth, memo, version, max_size:)
+      elsif (path = data_path(data))
+        found = find_memo(path)
+        found && memo_class.open(found, version, max_size:)
       end
     end
 
-    def memo_search_path(io)
-      dirname = File.dirname(io)
-      basename = File.basename(io, '.*')
-      "#{dirname}/#{basename}*.{fpt,FPT,dbt,DBT}"
+    def data_path(data)
+      return data if data.is_a?(String)
+
+      data.path if data.respond_to?(:path)
+    end
+
+    MEMO_EXTENSIONS = %w[fpt dbt].freeze
+
+    # Finds the memo file sitting next to the data file: same basename, with
+    # an .fpt or .dbt extension in any case. The directory is scanned rather
+    # than globbed so glob metacharacters in an uploaded filename cannot be
+    # expanded, and the basename must match exactly so data.dbf never picks
+    # up an unrelated memo such as data2.fpt.
+    def find_memo(path)
+      dirname = File.dirname(path)
+      basename = File.basename(path, '.*')
+      entries = Dir.children(dirname).sort.each_with_object({}) do |child, index|
+        index[child.downcase(:ascii)] ||= child
+      end
+      entry = MEMO_EXTENSIONS.filter_map { |ext| entries["#{basename}.#{ext}".downcase(:ascii)] }.first
+      entry && File.join(dirname, entry)
+    rescue SystemCallError
+      nil
     end
   end
 end

data/lib/dbf/header.rb

@@ -2,14 +2,12 @@
 
 module DBF
   class Header
-    HEADER_SIZE = 32
-
     attr_reader :version, :record_count, :header_length, :record_length, :encoding_key, :encoding
 
     def initialize(data)
       # Pad a nil or truncated header read so unpacking a short file yields
       # empty values instead of raising.
-      data = data.to_s.b.ljust(HEADER_SIZE, "\x00")
+      data = data.to_s.b.ljust(VersionConfig::DBASE3_HEADER_SIZE, "\x00")
       @version = data.unpack1('H2')
       @encoding_key = nil
       @encoding = nil

data/lib/dbf/memo/base.rb

@@ -6,19 +6,25 @@ module DBF
       BLOCK_HEADER_SIZE = 8
       BLOCK_SIZE = 512
 
-      def self.open(filename, version)
-        new(File.open(filename, 'rb'), version)
+      def self.open(filename, version, max_size: nil)
+        new(FileHandler.open_file(filename), version, max_size:)
       end
 
-      def initialize(data, version)
+      # @param max_size [Integer, nil] bytes to read from each memo; longer
+      #   memos are cut off. nil reads every memo in full.
+      def initialize(data, version, max_size: nil)
         @data = data
         @version = version
+        @max_size = max_size
       end
 
       def get(start_block)
         return nil unless start_block > 0
 
         build_memo start_block
+      rescue RangeError
+        # A corrupt memo pointer too large to seek to has no memo
+        nil
       end
 
       def close
@@ -31,7 +37,12 @@ module DBF
 
       private
 
-      attr_reader :data
+      attr_reader :data, :max_size
+
+      # Bounds a memo length by max_size, when one is set
+      def limit(length) # :nodoc:
+        max_size && length > max_size ? max_size : length
+      end
 
       def offset(start_block) # :nodoc:
         start_block * block_size

data/lib/dbf/memo/dbase3.rb

@@ -3,6 +3,9 @@
 module DBF
   module Memo
     class Dbase3 < Base
+      # Memo text up to, and whether it reached, the 0x1A terminator
+      TERMINATOR_PATTERN = /\A([^\x1A]*)(\x1A)?/n
+
       def build_memo(start_block) # :nodoc:
         data.seek offset(start_block)
         memo_string = +''
@@ -12,11 +15,22 @@ module DBF
           # than crashing on nil.gsub.
           break if block.nil?
 
-          block = block.gsub(/(\000|\032)/, '')
-          memo_string << block
-          break if block.size < BLOCK_SIZE
+          # The memo ends at its 0x1A terminator; bytes after it in the same
+          # block are leftovers, not memo text.
+          text, terminated = TERMINATOR_PATTERN.match(block).captures
+          text = text.delete("\000")
+          memo_string << text
+          break if terminated || text.size < BLOCK_SIZE || full?(memo_string)
         end
-        memo_string
+        memo_string.byteslice(0, limit(memo_string.bytesize))
+      end
+
+      private
+
+      # A memo with no terminator runs to the end of the file, so stop
+      # reading blocks once max_size bytes have been read.
+      def full?(memo_string) # :nodoc:
+        max_size && memo_string.bytesize >= max_size
       end
     end
   end

data/lib/dbf/memo/dbase4.rb

@@ -11,7 +11,7 @@ module DBF
         header = data.read(BLOCK_HEADER_SIZE)
         return nil unless header && header.bytesize == BLOCK_HEADER_SIZE
 
-        length = header.unpack1('x4L')
+        length = limit(header.unpack1('x4L'))
 
         # Bound the read by the bytes remaining so a crafted 32-bit length
         # field cannot force a ~4 GiB allocation from a small memo file.

data/lib/dbf/memo/foxpro.rb

@@ -5,18 +5,17 @@ module DBF
     class Foxpro < Base
       FPT_HEADER_SIZE = 512
 
-      def initialize(data, version)
-        @data = data
-        super
-      end
-
       def build_memo(start_block) # :nodoc:
-        @data.seek offset(start_block)
-        memo_type, memo_size, memo_string = @data.read(block_size).unpack('NNa*')
-        return nil unless memo_type == 1 && memo_size > 0
+        data.seek offset(start_block)
+        block = data.read(block_size)
+        return nil unless block
+
+        # memo_size is nil when the block header is truncated (< 8 bytes)
+        memo_type, memo_size, memo_string = block.unpack('NNa*')
+        return nil unless memo_type == 1 && memo_size.to_i.positive?
 
-        read_memo_content(memo_string, memo_size)
-      rescue StandardError
+        read_memo_content(memo_string, limit(memo_size))
+      rescue IOError, SystemCallError, RangeError
         nil
       end
 
@@ -28,16 +27,18 @@ module DBF
         # Bound the read by the bytes remaining so a crafted 32-bit memo_size
         # cannot force a ~4 GiB allocation from a small memo file.
         length = content_size(memo_size)
-        remaining = @data.size - @data.pos
+        remaining = data.size - data.pos
         length = remaining if length > remaining
-        memo_string << @data.read(length) if length.positive?
+        memo_string << data.read(length) if length.positive?
         memo_string
       end
 
       def block_size # :nodoc:
         @block_size ||= begin
-          @data.rewind
-          @data.read(FPT_HEADER_SIZE).unpack1('x6n') || 0
+          data.rewind
+          header = data.read(FPT_HEADER_SIZE)
+          # A header shorter than 8 bytes cannot contain the block size field
+          header && header.bytesize >= 8 ? header.unpack1('x6n') : 0
         end
       end
     end

data/lib/dbf/record.rb

@@ -3,6 +3,15 @@
 module DBF
   # An instance of DBF::Record represents a row in the DBF file
   class Record
+    # Column names come from the file, so they are never exposed as these
+    # methods: Ruby (and Rails) call them implicitly to convert or render an
+    # object, which would let a crafted file control how a record behaves.
+    # Such columns remain readable through #[] and #attributes.
+    RESERVED_METHODS = %w[
+      to_str to_ary to_hash to_proc to_int to_io to_path to_regexp to_open
+      to_model to_partial_path to_param to_key
+    ].freeze
+
     # Initialize a new DBF::Record
     #
     # @param data [String, StringIO] data
@@ -20,9 +29,7 @@ module DBF
     # @param [DBF::Record] other
     # @return [Boolean]
     def ==(other)
-      attributes == other.attributes
-    rescue NoMethodError
-      false
+      other.respond_to?(:attributes) && attributes == other.attributes
     end
 
     # Reads attributes by column name
@@ -114,7 +121,7 @@ module DBF
 
     def method_missing(method, *args) # :nodoc:
       key = method.to_s
-      if (index = underscored_column_names.index(key))
+      if (index = column_method_index(key))
         if @context.column_offsets && !@to_a
           column_value(index)
         else
@@ -126,7 +133,13 @@ module DBF
     end
 
     def respond_to_missing?(method, *) # :nodoc:
-      underscored_column_names.include?(method.to_s) || super
+      !column_method_index(method.to_s).nil? || super
+    end
+
+    def column_method_index(key) # :nodoc:
+      return nil if RESERVED_METHODS.include?(key)
+
+      underscored_column_names.index(key)
     end
 
     def underscored_column_names # :nodoc:

data/lib/dbf/record_context.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 module DBF
-  RecordContext = Struct.new(:columns, :version, :memo, :column_offsets, keyword_init: true)
+  # Immutable per-table state shared by every record during decoding
+  RecordContext = Data.define(:columns, :version, :memo, :column_offsets)
 end

data/lib/dbf/record_iterator.rb

@@ -2,46 +2,75 @@
 
 module DBF
   class RecordIterator
-    def initialize(data, context, header_length, record_length, record_count)
+    # Records are read in chunks of whole records totalling roughly this many
+    # bytes, so enumerating a multi-gigabyte file (for example a shapefile
+    # sidecar) needs only chunk-sized memory instead of the entire record
+    # section at once.
+    CHUNK_SIZE = 4 * 1024 * 1024
+
+    def initialize(data, context, header_length, record_length, record_count, chunk_size: CHUNK_SIZE)
       @data = data
       @context = context
       @header_length = header_length
       @record_length = record_length
       @record_count = record_count
+      @chunk_size = chunk_size
+    end
+
+    def each(&)
+      return enum_for(:each) unless block_given?
+
+      # A record_length of 0 from a crafted header cannot drive an unbounded
+      # loop: capacity is 0 and enumeration ends immediately.
+      remaining = record_capacity
+      @data.seek(@header_length)
+
+      while remaining.positive?
+        wanted = [per_chunk, remaining].min
+        buffer = @data.read(wanted * @record_length)
+        break unless buffer
+
+        whole_records = buffer.bytesize / @record_length
+        break if whole_records.zero?
+
+        yield_chunk(buffer, whole_records, &)
+        remaining -= whole_records
+
+        # A short read means the file ended earlier than the header promised
+        break if whole_records < wanted
+      end
     end
 
-    def each
-      buf = read_buffer
-      return unless buf
+    private
 
-      # Bound the iteration by the bytes actually read so a crafted
-      # record_count (or record_length == 0) cannot drive an unbounded loop.
-      max_records = @record_length > 0 ? buf.bytesize / @record_length : 0
-      count = @record_count < max_records ? @record_count : max_records
+    # Whole records per read; at least one so a record larger than the chunk
+    # size still makes progress. Only called when record_length is positive.
+    def per_chunk
+      @per_chunk ||= [@chunk_size / @record_length, 1].max
+    end
 
+    def yield_chunk(buffer, count)
       pos = 0
       count.times do
-        if buf.getbyte(pos) == 0x2A
+        if buffer.getbyte(pos) == 0x2A
           yield nil
         else
-          yield Record.new(buf, @context, pos + 1)
+          yield Record.new(buffer, @context, pos + 1)
         end
         pos += @record_length
       end
     end
 
-    private
-
-    def read_buffer
-      @data.seek(@header_length)
+    # Bound enumeration by the bytes actually available so a crafted header
+    # (huge record_length * record_count) cannot force reads past the real
+    # file size, while record_count still caps a file with trailing garbage.
+    def record_capacity
+      return 0 unless @record_length.positive?
 
-      # Bound the allocation by the bytes actually available so a crafted
-      # header (huge record_length * record_count) cannot force a giant read
-      # from a tiny file.
-      requested = @record_length * @record_count
       available = @data.size - @header_length
-      available = 0 if available.negative?
-      @data.read(requested < available ? requested : available)
+      return 0 if available.negative?
+
+      [@record_count, available / @record_length].min
     end
   end
 end

data/lib/dbf/schema.rb

@@ -43,10 +43,9 @@ module DBF
     # @param table_only [Boolean]
     # @return [String]
     def schema(format = :activerecord, table_only: false)
-      schema_method_name = schema_name(format)
-      send(schema_method_name, table_only: table_only)
-    rescue NameError
-      raise ArgumentError, ":#{format} is not a valid schema. Valid schemas are: #{FORMATS.join(', ')}."
+      raise ArgumentError, ":#{format} is not a valid schema. Valid schemas are: #{FORMATS.join(', ')}." unless FORMATS.include?(format.to_s.to_sym)
+
+      send(schema_name(format), table_only: table_only)
     end
 
     def schema_name(format) # :nodoc: