rbase 0.1

data/Rakefile

@@ -0,0 +1,26 @@
+require 'rake'
+require 'rubygems'
+
+task :default => ['gem']
+
+desc 'Create a gem'
+task :gem do
+  spec = Gem::Specification.new do |s|
+    s.name = 'rbase'
+    s.version = '0.1'
+    s.summary = 'Library to create/read/write to XBase databases (*.DBF files)'
+    s.files = Dir.glob('**/*').delete_if { |item| item.include?('.svn') }
+    s.require_path = 'lib'
+    s.autorequire = 'rbase'
+    s.authors = 'Maxim Kulkin, Leonardo Augusto Pires'
+    s.email = 'maxim.kulkin@gmail.com, leonardo.pires@gmail.com'
+    s.homepage = 'http://rbase.rubyforge.com/'
+    s.rubyforge_project = 'rbase'
+    s.has_rdoc = true
+
+    s.required_ruby_version = '>= 1.8.2'
+  end
+
+  Gem.manage_gems
+  Gem::Builder.new(spec).build
+end

data/lib/rbase.rb

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

data/lib/rbase/builder.rb

@@ -0,0 +1,31 @@
+require 'rbase/schema'
+
+module RBase
+  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
+  #
+  #   XBase.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 XBase::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,192 @@
+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
+
+      # 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
+    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)
+      end
+      
+      def pack(value)
+        [value].pack("A#{size}")
+      end
+
+      def unpack(data)
+        data.rstrip
+      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 decimal && decimal!=0
+          [format("%-#{size-decimal-1}.#{decimal}f", value)].pack("A#{size}")
+        else
+          [format("%-#{size}d", value)].pack("A#{size}")
+        end
+      end
+
+      def unpack(data)
+        return nil if data.rstrip == ''
+        data.rstrip.to_i
+      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
+    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
+    end
+    
+    
+    class MemoColumn < Column
+      column_type 'M'
+      
+      def initialize(name, options = {})
+        super name, options.merge(:size => 10)
+      end
+      
+      def pack(value)
+        # Not implemented yet.. using stub
+        [].pack('A10')
+      end
+      
+      def unpack(data)
+        # Not implemented yet.. using stub
+        ''
+      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)].pack("A#{size}")
+      end
+
+      def unpack(data)
+        data.rstrip.to_f
+      end
+    end
+
+  end
+end

data/lib/rbase/record.rb

@@ -0,0 +1,107 @@
+module RBase
+
+  # 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)
+      @table = table
+      @values_cached = {}
+      @values_changed = {}
+    end
+
+    private
+    
+    def load(index, data)
+      @table = table
+      @index = index
+      @data = data.dup
+    end
+    
+    def create(attributes = {})
+      attributes.each { |k, v| @values_changed[k.to_s.upcase] = v }
+    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
+
+    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(name)
+          @data[column.offset, column.size] = column.pack(value)
+          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)
+      @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
+      @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 XBase::Table opened
+    #
+    # == Example
+    #
+    #   users = XBase::Table.open('users')
+    #   File.open('users.dump.rb', 'w') do |f|
+    #     f.write XBase::SchemaDumper.dump(users)
+    #   end
+    #   users.close
+    #
+    def self.dump(table)
+      output = ''
+      output << "XBase.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,204 @@
+module RBase
+
+  class Table
+    private_class_method :new
+    
+    # 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)
+      table = new
+      table.instance_eval { open("#{name}.dbf") }
+      table
+    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 close
+      @file.close
+    end
+
+    attr_reader :name, :count, :columns, :last_modified_on, :language
+
+    # Return instance of XBase::Column for given column name
+    def column(name)
+      @name_to_columns[name]
+    end
+
+    # Create new record and populate it with given attributes
+    def create(attributes = {})
+      record = Record.new(self)
+      record.instance_eval { create(attributes) }
+      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)
+      @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')
+      @record_size = *header.unpack('@10v')
+
+      @file.pos = 32
+
+      @columns = []
+      @name_to_columns = {}
+      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, :offset => offset, :size => size, :decimal => decimal)
+        @name_to_columns[name.upcase.to_sym] = @columns.last
+      end
+    end
+    
+    def save(record)
+      if !record.index
+        @file.pos = @record_offset + @record_size*count
+        @file.write record.serialize
+        @file.write [26].pack('c')
+        self.count += 1
+      else
+        throw "Index out of bound" if index>=count
+        @file.pos = @record_offset + @record_size*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

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: rbase
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2006-09-11 00:00:00 +04:00
+summary: Library to create/read/write to XBase databases (*.DBF files)
+require_paths: 
+- lib
+email: maxim.kulkin@gmail.com, leonardo.pires@gmail.com
+homepage: http://rbase.rubyforge.com/
+rubyforge_project: rbase
+description: 
+autorequire: rbase
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.2
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Maxim Kulkin, Leonardo Augusto Pires
+files: 
+- Rakefile
+- lib
+- lib/rbase
+- lib/rbase.rb
+- lib/rbase/schema_dumper.rb
+- lib/rbase/record.rb
+- lib/rbase/columns.rb
+- lib/rbase/schema.rb
+- lib/rbase/builder.rb
+- lib/rbase/table.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+