rbase-ff 0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 43fb9c0a12fadbc618c2447b8a3d9f67e30cc4b0
+  data.tar.gz: 8b9e1657d06949598eb524d32d844c7bf1a0e773
+SHA512:
+  metadata.gz: 0b6f2fc63244d75a344b963ce63a9b03b1b446db53fc5e72144770a8fd01f855e64c49f8817b62cfa3541b369fe13c3da31f5fd184b7129f4650652fba2c1b75
+  data.tar.gz: 2d540336e920c3e05b286d452afcfbaf07989f66944edb5d3e023186f8396f4b82f0608e0cae12e22c5c2b3725b333d5f2d40d3879aac9c71d24f490fe6f71b6

data/README.md

@@ -0,0 +1,27 @@
+rbase
+=====
+
+rbase gem (working with dbf files) for ruby 1.9.3 (iconv removed, some fixes)
+
+How to use
+==========
+
+```ruby
+require 'rubygems'
+require "date"
+require "rbase"
+
+RBase.create_table 'people' do |t|
+  t.column :name, :string, :size => 30
+  t.column :birthdate, :date
+  t.column :active, :boolean
+  t.column :tax, :integer, :size => 10, :decimal => 2
+end
+
+RBase::Table.open 'people' do |t|
+  t.create name: 'People-1', birthdate: Date.new(2017,1,2), active: true, tax: 5.2
+  t.create name: 'People-2', birthdate: Date.new(2018,1,2), active: true, tax: 6.2
+  t.create name: 'People-3', birthdate: Date.new(2019,1,2), active: true, tax: 7.2
+  t.create name: 'People-4', birthdate: Date.new(2020,1,2), active: true, tax: 8.2
+end
+```

data/lib/rbase/builder.rb

@@ -0,0 +1,34 @@
+require 'rbase/schema'
+
+module RBase
+  LANGUAGE_US_DOS = 0x01
+  LANGUAGE_INTL_DOS = 0x02
+  LANGUAGE_ANSI_WINDOWS = 0x03
+  LANGUAGE_RUSSIAN_DOS = 0x66
+  LANGUAGE_RUSSIAN_WINDOWS = 0xc9
+
+  # Create new XBase table file. Table file name will be equal to name with ".dbf" suffix.
+  #
+  # For list of available options see Table::create documentation.
+  #
+  # == Example
+  #
+  #   RBase.create_table 'people' do |t|
+  #     t.column :name, :string, :size => 30
+  #     t.column :birthdate, :date
+  #     t.column :active, :boolean
+  #     t.column :tax, :integer, :size => 10, :decimal => 2
+  #   end
+  #
+  # For documentation on column parameters see RBase::Schema.column documentation.
+  #
+  def self.create_table(name, options = {})
+    options[:language] ||= LANGUAGE_RUSSIAN_WINDOWS
+    
+    schema = Schema.new
+    yield schema if block_given?
+    
+    Table.create name, schema, options
+  end
+
+end

data/lib/rbase/columns.rb

@@ -0,0 +1,251 @@
+module RBase
+  module Columns
+
+    # Base class for all column types
+    class Column
+      @@types = {}
+      
+      # Assigns column type string to current class
+      def self.column_type(type)
+        @type = type
+        @@types[type] = self
+      end
+      
+      # Returns column type class that correspond to given column type string
+      def self.column_for(type)
+        throw "Unknown column type '#{type}'" unless @@types.has_key?(type)
+        @@types[type]
+      end
+      
+      # Returns column type as 1 character string
+      def self.type
+        @type
+      end
+      
+      # Returns column type as 1 character string
+      def type
+        self.class.type
+      end
+      
+      # Column name
+      attr_reader :name
+      
+      # Column offset from the beginning of the record
+      attr_reader :offset
+      
+      # Column size in characters
+      attr_reader :size
+      
+      # Number of decimal places
+      attr_reader :decimal
+
+      def initialize(name, options = {})
+        options.merge({:name => name, :type => self.class.type}).each { |k, v| self.instance_variable_set("@#{k}", v) }
+      end
+      
+      
+      def attach_to(table)
+        @table = table
+      end
+
+      # Packs column value for storing it in XBase file.
+      def pack(value)
+        throw "Not implemented"
+      end
+
+      # Unpacks stored in XBase column data into appropriate Ruby form.
+      def unpack(value)
+        throw "Not implemented"
+      end
+
+      def inspect
+        "#{name}(type=#{type}, size=#{size})"
+      end
+      
+      protected
+      
+      def table
+        @table
+      end
+    end
+
+
+    class CharacterColumn < Column
+      column_type 'C'
+      
+      def initialize(name, options = {})
+        if options[:size] && options[:decimal]
+          size = options[:decimal]*256 + options[:size] 
+        else
+          size = options[:size] || 254
+        end
+        
+        super name, options.merge(:size => size)
+
+        if options[:encoding]
+          @unpack_converter = Encoder.new(options[:encoding], 'utf-8')
+          @pack_converter = Encoder.new('utf-8', options[:encoding])
+        end
+      end
+      
+      def pack(value)
+	      value = value.to_s
+        value = @pack_converter.en(value) if @pack_converter
+        [value].pack("A#{size}")
+      end
+
+      def unpack(data)
+        value = data.rstrip
+        value = @unpack_converter.en(value) if @unpack_converter
+        value
+      end
+
+      def inspect
+        "#{name}(string #{size})"
+      end
+    end
+
+
+    class NumberColumn < Column
+      column_type 'N'
+      
+      def initialize(name, options = {})
+        size = options[:size] || 18
+        size = 18 if size > 18
+        
+        super name, options.merge(:size => size)
+      end
+      
+      def pack(value)
+        if value
+          if float?
+            [format("%#{size-decimal-1}.#{decimal}f", value)].pack("A#{size}")
+          else
+            [format("%#{size}d", value)].pack("A#{size}")
+          end
+        else
+          " "*size
+        end
+      end
+
+      def unpack(data)
+        return nil if data.strip == ''
+        data.rstrip.to_i
+      end
+
+      def inspect
+        if float?
+          "#{name}(decimal)"
+        else
+          "#{name}(integer)"
+        end
+      end
+
+      def float?
+        decimal && decimal != 0
+      end
+    end
+
+
+    class LogicalColumn < Column
+      column_type 'L'
+      
+      def initialize(name, options = {})
+        super name, options.merge(:size => 1)
+      end
+
+      def pack(value)
+        case value
+        when true then 'T'
+        when false then 'F'
+        else '?'
+        end
+      end
+
+      def unpack(data)
+        case data.upcase
+        when 'Y', 'T'
+          true
+        when 'N', 'F'
+          false
+        else
+          nil
+        end
+      end
+
+      def inspect
+        "#{name}(boolean)"
+      end
+    end
+
+
+    class DateColumn < Column
+      column_type 'D'
+      
+      def initialize(name, options = {})
+        super name, options.merge(:size => 8)
+      end
+
+      def pack(value)
+        value ? value.strftime('%Y%m%d'): ' '*8
+      end
+
+      def unpack(data)
+        return nil if data.rstrip == ''
+        Date.new(*data.unpack("a4a2a2").map { |s| s.to_i})
+      end
+
+      def inspect
+        "#{name}(date)"
+      end
+    end
+    
+    
+    class MemoColumn < Column
+      column_type 'M'
+      
+      def initialize(name, options = {})
+        super name, options.merge(:size => 10)
+      end
+      
+      def pack(value)
+        packed_value = table.memo.write(value)
+        [format("%-10d", packed_value)].pack('A10')
+      end
+      
+      def unpack(data)
+        table.memo.read(data.to_i)
+      end
+
+      def inspect
+        "#{name}(memo)"
+      end
+    end
+
+
+    class FloatColumn < Column
+      column_type 'F'
+      
+      def initialize(name, options = {})
+        super name, options.merge(:size => 20)
+      end
+      
+      def decimal
+        (@decimal && @decimal <= 15) ? @decimal : 2
+      end
+
+      def pack(value)
+        [format("%-#{size-decimal-1}.#{decimal}f", value || 0.0)].pack("A#{size}")
+      end
+
+      def unpack(data)
+        data.rstrip.to_f
+      end
+
+      def inspect
+        "#{name}(float)"
+      end
+    end
+
+  end
+end

data/lib/rbase/encoder.rb

@@ -0,0 +1,11 @@
+class Encoder
+
+  def initialize(from, to)
+    @from, @to = from, to
+  end
+
+  def en(str)
+    str.force_encoding(@from).encode(@to)
+  end
+
+end

data/lib/rbase/memo_file.rb

@@ -0,0 +1,63 @@
+module RBase
+  module MemoFile
+  
+    class DummyMemoFile
+      def read(index)
+        ''
+      end
+      
+      def write(value)
+        nil
+      end
+    end
+
+    class DBase3MemoFile
+      HEADER_SIZE = 512
+      BLOCK_SIZE = 512
+      BLOCK_TERMINATOR = "\x1a\x1a"
+      
+      def initialize(name)
+        @file = File.open(name)
+        
+        @header = @file.read(HEADER_SIZE)
+        @next_block = header.unpack('@0L')
+        @version = header.unpack('@16c')
+      end
+      
+      def read(index)
+        @file.pos = index*BLOCK_SIZE + HEADER_SIZE
+
+        result = ''
+        loop do
+          data = @file.read(BLOCK_SIZE)
+          terminator_pos = data.index(BLOCK_TERMINATOR)
+          if terminator_pos
+            break result + data[0, terminator_pos]
+          end
+          result += data
+        end
+      end
+      
+      def write(value)
+        @file.pos = @next_block*BLOCK_SIZE + HEADER_SIZE
+        value += BLOCK_TERMINATOR
+        blocks_num = (value.length+511)/512
+        @file.write [value].pack("a#{512*blocks_num}")
+        
+        position = @next_block
+        @next_block += blocks_num
+        update_header
+        
+        position
+      end
+      
+      protected
+      
+      def update_header
+        @file.pos = 0
+        @file.write [@next_block].pack("L")
+      end
+    end
+
+  end
+end

data/lib/rbase/record.rb

@@ -0,0 +1,141 @@
+module RBase
+
+  class StandardError < Exception; end
+
+  class UnknownColumnError < StandardError
+    attr_reader :name
+
+    def initialize(name)
+      super("Unknown column '#{name}'")
+      @name = name
+    end
+  end
+
+  class InvalidValueError < StandardError
+    attr_reader :column, :value
+
+    def initialize(column, value)
+      super("Invalid value #{value.inspect} for column #{column.inspect}")
+      @column, @value = column, value
+    end
+  end
+
+  # Class that contains data for particular table row.
+  # Should not be created explicitly (use Table#create to create records)
+  #
+  # == Accessing attributes
+  #
+  # You can read and assign values to row's columns using simple property syntax:
+  #
+  #   user = users_table[0]
+  #   user.name = 'Bob'
+  #   user.birth_date = Date.new(1980, 2, 29)
+  #   user.save
+  #
+  #   puts user.name
+  #   puts user.birth_date
+  #
+  class Record
+    attr_reader :table, :index
+
+    def initialize(table, attributes = {})
+      @table = table
+      @values_cached = {}
+      @values_changed = {}
+
+      attributes.each { |k, v| @values_changed[k.to_s.upcase] = v }
+    end
+
+    private
+
+    def load(index, data)
+      @table = table
+      @index = index
+      @data = data.dup
+    end
+
+    public
+
+    # Returns true if record was never saved to database; otherwise return false.
+    def new_record?
+      @data.nil?
+    end
+
+    # Save record to database.
+    def save
+      record = self
+      @table.instance_eval { save(record) }
+    end
+
+    # Delete record from database.
+    def delete
+      @deleted = true
+      save
+    end
+
+    # Returns true if record was marked as deleted; otherwise return false.
+    def deleted?
+      @deleted ||= new_record? ? false : @data[0, 1] == '*'
+    end
+
+    # Clone record.
+    def clone
+      c = self.class.new(@table, @values_changed)
+      c.instance_variable_set("@values_cached", @values_cached)
+      c.instance_variable_set("@data", @data)
+      c
+    end
+
+    def method_missing(sym, *args)
+      name = sym.to_s
+      if /=$/ =~ name && args.size == 1
+        set_value(name[0..-2], args.first)
+      else
+        get_value(name)
+      end
+    end
+
+    def serialize
+      if new_record?
+        @data = deleted? ? '*' : ' '
+        @data << @table.columns.collect do |column|
+          column.pack(@values_changed[column.name])
+        end.join
+      else
+        @data[0, 1] = deleted? ? '*' : ' '
+        @values_changed.each do |k, v|
+          column = @table.column(k)
+          raise UnknownColumnError.new(k) unless column
+          begin
+            @data[column.offset, column.size] = column.pack(v)
+          rescue Object => e
+            raise InvalidValueError.new(column, v)
+          end
+          @values_cached[k] = v
+        end
+      end
+      @data
+    end
+
+    protected
+
+    # Returns value of specified column
+    def get_value(name)
+      name = name.to_s.upcase.to_sym
+      return @values_changed[name] if @values_changed.has_key?(name)
+      return nil if new_record?
+      column = @table.column(name)
+      raise UnknownColumnError.new(name) unless column
+      @values_cached[name] ||= column.unpack(@data[column.offset, column.size])
+    end
+
+    # Sets value of specified column.
+    def set_value(name, value)
+      name = name.to_s.upcase.to_sym
+      raise UnknownColumnError.new(name) unless @table.column(name)
+      @values_changed[name] = value
+    end
+  end
+
+end
+

data/lib/rbase/schema.rb

@@ -0,0 +1,52 @@
+require 'rbase/columns'
+
+module RBase
+
+  class Schema
+    # Returns list of all columns defined.
+    attr_reader :columns
+
+    def initialize
+      @columns = []
+    end
+
+    # Declares new column.
+    #
+    # Options:
+    #
+    # * :size - size of the column in characters
+    # * :decimal - number of decimal positions
+    #
+    # There are column types that require it's size to be specified (but they still have reasonable defaults).
+    # But some column types (e.g. :date type) have fixes size that cannot be overriden.
+    #
+    # There are several column types available:
+    #
+    # * :string - corresponds to fixed length character column. Column size is limited to 254 (default).
+    # * :date - date column type
+    # * :boolean - logical column type
+    # * :integer - number column type. Number is stored in human readable form
+    #   (text representation), so you should specify it's size in characters. Maximum column size is 18 (default).
+    #   If :decimal option not equal to 0, number contains <:decimal> fraction positions.
+    #   You should adjust :size keeping :decimal positions + 1 (for decimal point) in mind.
+    # * :memo - memo column. Memo is a text field that can be more than 254 chars long. Memo data is stored in separate file.
+    #   This column type is not yet supported.
+    #
+    #
+    def column(name, type, options = {})
+      name = name.to_s.upcase
+      case type
+      when :string then type = 'C'
+      when :integer then type = 'N'
+      when :float then
+        type = 'N'
+        options[:decimal] ||= 6
+      when :boolean then type = 'L'
+      when :date then type = 'D'
+      end
+      
+      @columns << Columns::Column.column_for(type).new(name, options)
+    end
+  end
+
+end

data/lib/rbase/schema_dumper.rb

@@ -0,0 +1,29 @@
+module RBase
+
+  class SchemaDumper
+    # Produce ruby schema for a given table.
+    #
+    # Parameters
+    #   table - instance of RBase::Table opened
+    #
+    # == Example
+    #
+    #   users = RBase::Table.open('users')
+    #   File.open('users.dump.rb', 'w') do |f|
+    #     f.write RBase::SchemaDumper.dump(users)
+    #   end
+    #   users.close
+    #
+    def self.dump(table)
+      output = ''
+      output << "RBase.create_table :#{table.name} do |t|\n"
+      
+      table.columns.each do |column|
+        output << "  t.column '#{column.name}', '#{column.type}', :size => #{column.size}#{ (column.decimal && column.decimal > 0) ? ", :decimal => #{column.decimal}" : ''}\n"
+      end
+      
+      output << "end\n"
+    end
+  end
+  
+end

data/lib/rbase/table.rb

@@ -0,0 +1,239 @@
+module RBase
+
+  class Table
+    private_class_method :new
+
+    include Enumerable
+
+    # Create new XBase table file. Table file name will be equal to name with ".dbf" suffix.
+    #
+    # Allowed options
+    #  * :language - language character set used in database. Can be one of LANGUAGE_* constants
+    def self.create(name, schema, options = {})
+      date = Date.today
+
+      record_size = 1+schema.columns.inject(0) { |size, column| size + column.size }
+
+      data = ''
+      # data << [0xf5].pack('C') # version
+      data << [0x3].pack('C') # version
+      data << [date.year % 100, date.month, date.day].pack('CCC') # last modification date
+      data << [0].pack('L') # number of records
+      # data << [32+schema.columns.size*32+263+1].pack('v') # data size
+      data << [32+schema.columns.size*32+1].pack('v') # data size
+      data << [record_size].pack('v') # record size
+      data << [].pack('x2') # reserved
+      data << [].pack('x') # incomplete transaction
+      data << [].pack('x') # encyption flag
+      data << [].pack('x4') # reserved
+      data << [].pack('x8') # reserved
+      data << [0].pack('c') # mdx flag
+      data << [options[:language]].pack('C') # language driver
+      data << [].pack('x2') # reserved
+
+      offset = 1 # take into account 1 byte for deleted flag
+      data << schema.columns.collect do |column|
+        s = ''
+        s << [column.name.to_s[0..9]].pack('a11') # field name
+        s << [column.type].pack('a') # field type
+        s << [offset].pack('L') # field data offset
+        s << [column.size].pack('C') # field size
+        s << [column.decimal || 0].pack('C') # decimal count
+        s << [].pack('x2') # reserved
+        s << [].pack('x') # work area id
+        s << [].pack('x2') # reserved
+        s << [].pack('x') # flag for SET FIELDS
+        s << [].pack('x7') # reserved
+        s << [].pack('x') # index field flag
+        offset += column.size
+        s
+      end.join
+
+      data << [13].pack('C') # terminator
+
+      data << [26].pack('C') # end of file
+
+      File.open("#{name}.dbf", 'wb') do |f|
+        f.write data
+      end
+    end
+
+    # Open table with given name.
+    # Table name should be like file name without ".dbf" suffix.
+    def self.open(name, options = {})
+      table = new
+      table.instance_eval { open("#{name}.dbf", options) }
+      if block_given?
+        result = yield table
+        table.close
+        result
+      else
+        table
+      end
+    end
+
+    # Physically remove records that were marked as deleted from file.
+    def pack
+      packed_count = 0
+      count.times do |i|
+        @file.pos = @record_offset + @record_size*i
+        data = @file.read(@record_size)
+        unless data[0, 1]=='*'
+          if i!=packed_count
+            @file.pos = @record_offset + @record_size*packed_count
+            @file.write data
+          end
+          packed_count += 1
+        end
+      end
+
+      file_end = @record_offset + @record_size*packed_count
+      @file.pos = file_end
+      @file.write "\x1a"
+      @file.truncate file_end+1
+
+      self.count = packed_count
+      update_header
+    end
+
+    def clear
+      file_end = @record_offset
+      @file.pos = file_end
+      @file.write "\x1a"
+      @file.truncate file_end+1
+
+      self.count = 0
+      update_header
+    end
+
+    def close
+      @file.close
+    end
+
+    attr_reader :name, :count, :columns, :last_modified_on, :language
+
+    # Return instance of RBase::Column for given column name
+    def column(name)
+      @name_to_columns[name]
+    end
+
+    # Returns instance of MemoFile that is associated with table
+    def memo
+      return @memo_file
+    end
+
+    # Create new record, populate it with given attributes
+    def build(attributes = {})
+      Record.new(self, attributes)
+    end
+
+    # Create new record, populate it with given attributes and save it
+    def create(attributes = {})
+      record = build(attributes)
+      record.save
+      record
+    end
+
+    # Load record stored in position 'index'
+    def load(index)
+      @file.pos = @record_offset + @record_size*index
+      data = @file.read(@record_size)
+      record = Record.new(self)
+      record.instance_eval { load(index, data) }
+      record
+    end
+
+    alias_method :[], :load
+
+    def []=(index, record)
+      record.instance_eval { @index = index }
+      save(record)
+    end
+
+    # Iterate through all (even deleted) records
+    def each_with_deleted
+      return unless block_given?
+
+      count.times do |i|
+        yield load(i)
+      end
+    end
+
+    # Iterate through all non-deleted records
+    def each
+      return unless block_given?
+
+      self.each_with_deleted do |record|
+        yield record unless record.deleted?
+      end
+    end
+
+    private
+
+    def open(name, options = {})
+      @name = File.basename(name, '.dbf')
+      @file = File.open(name, "r+b")
+      header = @file.read(32)
+
+      year, month, day = *header.unpack('@1ccc')
+      year += 2000 if year >= 100
+
+      @last_modified_on = Date.new(year, month, day)
+      @count = header.unpack('@4V').first
+      @language = header.unpack('@29c').first
+
+      @record_offset = header.unpack('@8v').first
+      @record_size = header.unpack('@10v').first
+
+      @file.pos = 32
+
+      @columns = []
+      @name_to_columns = {}
+      column_options = {}
+      column_options[:encoding] = options[:encoding] if options[:encoding]
+      while true do
+        column_data = @file.read(32)
+        break if column_data[0, 1] == "\x0d"
+        name, type, offset, size, decimal = *column_data.unpack('@0a11aLCC')
+        name = name.strip
+        @columns << Columns::Column.column_for(type).new(name, options.merge(:offset => offset, :size => size, :decimal => decimal))
+        @name_to_columns[name.upcase.to_sym] = @columns.last
+      end
+
+      @columns.each { |column| column.attach_to(self) }
+
+      @memo_file = MemoFile::DummyMemoFile.new
+    end
+
+    def save(record)
+      if !record.index
+        @file.pos = @record_offset + @record_size*count
+        @file.write record.serialize
+        @file.write [26].pack('c')
+        record.instance_variable_set(:@index, count)
+        self.count = count + 1
+      else
+        throw "Index out of bound" if record.index>=count
+        @file.pos = @record_offset + @record_size*record.index
+        @file.write record.serialize
+      end
+      update_header
+    end
+
+    def count=(value)
+      @count = value
+    end
+
+    def last_modified_on=(value)
+      @last_modified_on = value
+    end
+
+    def update_header
+      @last_modified_on = Date.today
+      @file.pos = 1
+      @file.write([last_modified_on.year % 100, last_modified_on.month, last_modified_on.day].pack('ccc'))
+      @file.write([count].pack('V'))
+    end
+  end
+
+end

data/lib/rbase.rb

@@ -0,0 +1,8 @@
+require 'rbase/encoder'
+require 'rbase/columns'
+require 'rbase/schema'
+require 'rbase/memo_file'
+require 'rbase/table'
+require 'rbase/record'
+require 'rbase/schema_dumper'
+require 'rbase/builder'

data/rbase.gemspec

@@ -0,0 +1,13 @@
+Gem::Specification.new do |s|
+  s.name = 'rbase-ff'
+  s.version = '0.9'
+  s.summary = 'Library to create/read/write to XBase databases (*.DBF files)'
+  s.require_path = 'lib'
+  s.files = Dir.glob('**/*').delete_if { |item| item =~ /^\./ }
+  s.authors = 'Maxim Kulkin, Leonardo Augusto Pires, Tom Lahti'
+  s.email = 'maxim.kulkin@gmail.com, leonardo.pires@gmail.com, uidzip@gmail.com'
+  s.homepage = 'http://github.com/uidzip/rbase'
+  s.has_rdoc = true
+
+  s.required_ruby_version = '>= 1.9.3'
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: rbase-ff
+version: !ruby/object:Gem::Version
+  version: '0.9'
+platform: ruby
+authors:
+- Maxim Kulkin, Leonardo Augusto Pires, Tom Lahti
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-11 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: maxim.kulkin@gmail.com, leonardo.pires@gmail.com, uidzip@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/rbase.rb
+- lib/rbase/builder.rb
+- lib/rbase/columns.rb
+- lib/rbase/encoder.rb
+- lib/rbase/memo_file.rb
+- lib/rbase/record.rb
+- lib/rbase/schema.rb
+- lib/rbase/schema_dumper.rb
+- lib/rbase/table.rb
+- rbase.gemspec
+homepage: http://github.com/uidzip/rbase
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Library to create/read/write to XBase databases (*.DBF files)
+test_files: []