activemdb 0.1.0

data/History.txt

@@ -0,0 +1,4 @@
+== 0.1.0 / 2007-02-22
+
+
+

data/Manifest.txt

@@ -0,0 +1,19 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+db/sample.mdb
+irb.rc
+lib/active_mdb.rb
+lib/active_mdb/column.rb
+lib/active_mdb/mdb.rb
+lib/active_mdb/mdb_tools.rb
+lib/active_mdb/record.rb
+lib/active_mdb/table.rb
+support/a.insert
+test/test_activemdb.rb
+test/test_helper.rb
+test/test_mdb.rb
+test/test_mdb_tools.rb
+test/test_record.rb
+test/test_table.rb

data/README.txt

@@ -0,0 +1,57 @@
+ActiveMDB
+by Matthew King
+http://rubyforge.org/projects/activemdb/
+
+== DESCRIPTION:
+  
+Lib for getting info out of MS Access (.mdb) files, which uses ActiveRecord-ish reflection to parse table and column names. 
+
+Intended for exploration and migration, not production. ActiveMDB provides a thin wrapper around the mdb-tables, mdb-schema, mdb-sql, and mdb-export binaries from Brian Bruns's MDB Tools project (http://mdbtools.sourceforge.net/).
+
+== FEATURES/PROBLEMS:
+  
+* MDB, Table, and Record classes do reflection to provide easy attribute readers
+* I really need to refactor the above classes to something more like ActiveRecord::Base, so that you can subclass to make models.
+
+== SYNOPSIS:
+
+  @mdb = MDB.new('db/sample.mdb', :exclude => 'lookups')
+  @employees = @mdb.employees
+
+  # in the find_* methods, the entries in the hash 
+  # get turned into "WHERE #{key} like %#{value}%" conditions,
+  # unless the column is a boolean, in which case the WHERE uses "="
+  @employees.find_first :f_name => 'Matthew', :l_name => 'King'
+
+== REQUIREMENTS:
+
+* http://mdbtools.sourceforge.net/
+
+== INSTALL:
+
+* Sadly, no easy install at this time.  
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2007 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,17 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/active_mdb.rb'
+
+Hoe.new('activemdb', ActiveMDB::VERSION) do |p|
+  p.rubyforge_name = 'activemdb'
+  p.author = 'Matthew King'
+  p.email = 'automatthew@gmail.com'
+  p.summary = 'a reflective wrapper around MDB Tools, which lets POSIX platforms read MS Access (.mdb) files'
+  p.description = p.paragraphs_of('README.txt', 2).join("\n\n")
+  p.url = p.paragraphs_of('README.txt',0).first.split(/\n/)[2..-1]
+  # p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+
+# vim: syntax=Ruby

data/irb.rc

@@ -0,0 +1,4 @@
+require "#{File.dirname(__FILE__)}/lib/active_mdb"
+require 'pp'
+include MDBTools
+

data/lib/active_mdb.rb

@@ -0,0 +1,18 @@
+$:.unshift(File.dirname(__FILE__))
+module ActiveMDB
+  VERSION = '0.1.0'
+end
+
+
+require 'rubygems'
+require 'active_support/inflector'
+require 'active_mdb/mdb_tools'
+load 'active_mdb/mdb.rb'
+load 'active_mdb/table.rb'
+load 'active_mdb/record.rb'
+load 'active_mdb/column.rb'
+require 'faster_csv'
+
+
+
+

data/lib/active_mdb/column.rb

@@ -0,0 +1,21 @@
+class Column
+  include MDBTools
+  
+  attr_reader :method_name, :name, :type, :size
+  
+  def initialize(name, type, size)
+    @name = name
+    @method_name, @type, @size = methodize(name), methodize(type), size.to_i
+  end
+  
+  def self.new_from_describe(describe_hash)
+    self.new(describe_hash["Column Name"], describe_hash["Type"], describe_hash["Size"])
+  end
+
+  
+  def boolean?
+    self.type == 'boolean'
+  end
+  
+  
+end

data/lib/active_mdb/mdb.rb

@@ -0,0 +1,39 @@
+# require 'mdb_tools'
+  
+class MDB
+  include MDBTools
+  
+  attr_reader :mdb_file, :prefix, :exclude, :table_names
+  
+  def initialize(mdb_file, options = {})
+    @mdb_file = check_file(mdb_file)
+    @prefix = options[:prefix] || ''
+    @exclude, @include = options[:exclude], options[:include]
+    @export_syntax = options[:sql_syntax] || 'mysql'
+    @table_names = mdb_tables(@mdb_file, :exclude => @exclude, :include => @include)
+    @tables = create_table_objects
+  end
+  
+  def tables
+    @table_names.collect { |table| methodize(table)}
+  end
+  
+
+  
+  private
+  
+  def create_table_objects
+    tables = {}
+    @table_names.each do |table|
+      tables[table] = Table.new(self, table, @prefix)
+      metaclass = class << self; self; end
+      metaclass.send :define_method, methodize(table) do
+        tables[table]
+      end
+    end
+    tables
+  end
+  
+  
+end
+  

data/lib/active_mdb/mdb_tools.rb

@@ -0,0 +1,149 @@
+module MDBTools
+  include Inflector
+  
+  DELIMITER = '::'
+  LINEBREAK = "\n"
+  SANITIZER = /^\w\.\_/ # dumb filter for SQL arguments
+  BACKENDS = %w{ access mysql oracle postgres sybase }
+  
+  def check_file(mdb_file)
+    raise ArgumentError, "File not found: #{mdb_file}" unless File.exist?(mdb_file)
+    @mdb_version = `mdb-ver #{mdb_file} 2>&1`.chomp
+    if $? != 0
+      raise ArgumentError, "mdbtools cannot access #{mdb_file}"
+    end
+    mdb_file
+  end
+  
+  def check_table(mdb_file, table_name)
+    unless mdb_tables(mdb_file).include?(table_name)
+      raise ArgumentError, "mdbtools does not think a table named \"#{table_name}\" exists"
+    end
+    table_name
+  end
+  
+  def mdb_tables(mdb_file, options = {})
+    included, excluded = options[:include], options[:exclude]
+    return `mdb-tables -1 #{mdb_file}`.split(LINEBREAK) if not (included || excluded)
+    raise ArgumentError if (options[:include] && options [:exclude])
+    if options[:exclude]
+      regex = Regexp.new options[:exclude].to_a.join('|') 
+      tables = `mdb-tables -1 #{mdb_file}`.split(LINEBREAK).delete_if { |name| name =~ regex }
+    end
+    if options[:include]
+      regex = Regexp.new options[:include].to_a.join('|')
+      tables = `mdb-tables -1 #{mdb_file}`.split(LINEBREAK).select { |name| name =~ regex }
+    end
+    tables
+  end
+    
+  def sql_select(mdb_file, table_name, attributes = nil, conditions ={})
+    attributes ||= ['*']
+    sql = "select #{attributes.join(' ')} from #{table_name} where #{conditions}".dump
+    mdb_sql(mdb_file, sql)
+  end
+  
+  
+  def mdb_sql(mdb_file, sql)
+    # puts sql
+    result = `echo -n #{sql} | mdb-sql -Fp -H -d '#{DELIMITER}' #{mdb_file}`.strip
+    arrays = delimited_to_arrays(result)
+  end
+  
+  def compile_conditions(conditions_hash, *args)
+    conditions = conditions_hash.sort_by{|k,v| k.to_s}.map do |column_name, value|
+      if block_given?
+        yield column_name, value
+      else
+        "#{column_name} like '%#{value}%'"        
+      end
+    end.join(' AND ')
+  end
+  
+  def mdb_export(mdb_file, table_name, options = {})
+    defaults = {  :format => 'sql',
+                  :headers => false,
+                  :sanitize => true  }
+    options = defaults.merge options
+    
+    args = []
+    if options[:delimiter]
+      args << "-d #{options[:delimiter].dump}"
+    elsif options[:format] == 'sql'
+      args << "-I "
+    elsif options[:format] == 'csv'
+      args << "-d ',' "
+    else
+      raise ArgumentError, "Unknown format:  #{options[:format]}"
+    end
+    
+    args << "-H " unless options[:headers] == true
+    args << "-S" unless options[:sanitize] == false
+    `mdb-export #{args} #{mdb_file} #{table_name.to_s.dump}`
+  end
+  
+  def describe_table(mdb_file, table_name)
+    command = "describe table \"#{table_name}\"".dump
+    description = `echo -n #{command} | mdb-sql -Fp -d '#{DELIMITER}' #{mdb_file}`.strip
+    arrays = delimited_to_arrays(description)
+    arrays_to_hashes(arrays.shift, arrays)
+  end
+  
+  def mdb_schema(mdb_file, table_name)
+    schema = `mdb-schema -T #{table_name.dump} #{mdb_file}`
+  end
+
+  
+  def table_to_csv(mdb_file, table_name)
+    mdb_export(mdb_file, table_name, :format => 'csv', :headers => true)
+  end
+  
+  def delimited_to_arrays(text)
+    text.gsub!(/\r\n/,' ')
+    text.split(LINEBREAK).collect { |row| row.split(DELIMITER)}
+  end
+  
+  def arrays_to_hashes(headers, arrays)
+    arrays.collect do |record|
+      record_hash = Hash.new
+      until record.empty? do
+        headers.each do |header|
+          record_hash[header] = record.shift
+        end
+      end
+      record_hash
+    end
+  end
+  
+
+  
+  def methodize(table_name)
+    underscore table_name
+  end
+  
+  def backends
+    BACKENDS
+  end
+  
+  def sanitize!(string)
+    string.gsub!(SANITIZER, '')
+  end
+  
+  def mdb_truth(value)
+    case value
+    when false
+      0
+    when true
+      1
+    when 0
+      0
+    when 1
+      1
+    when "0"
+      0
+    when "1"
+      1
+    end
+  end
+  
+end

data/lib/active_mdb/record.rb

@@ -0,0 +1,33 @@
+# require 'mdb_tools'
+
+class Record
+  include MDBTools
+  include Enumerable
+  
+  def initialize(mdb_table, line)
+    raise 'no results' unless line
+    @struct = mdb_table.record_struct
+    @data = @struct.new(*line)
+    create_accessors
+  end
+  
+  def each(&block)
+    @data.members.each {|k| yield k, @data[k] }
+  end
+  
+  def compact
+    self.select {|k,v| v && !v.empty? && v != "0" }
+  end
+  
+  private
+  
+  def create_accessors
+    meta = class << self; self; end
+    @struct.members.each do |att|
+      meta.send :define_method, att do
+        @data[att]
+      end
+    end
+  end
+  
+end

data/lib/active_mdb/table.rb

@@ -0,0 +1,89 @@
+# require 'mdb_tools'  
+
+class Table
+  include MDBTools
+  
+  attr_reader :mdb_file, :table_name, :columns, :record_struct, :schema
+  attr_accessor :primary_key
+  
+  
+  def initialize(mdb, table_name, prefix)
+    @mdb_file = check_file(mdb.mdb_file)
+    @table_name = check_table(@mdb_file, table_name)
+    # @schema = mdb_schema(@mdb_file, @table_name)
+    @columns = describe_table(mdb_file, table_name).map do |column|
+      Column.new_from_describe(column)
+    end
+    @record_struct = create_record_struct
+  end
+  
+  
+  def [](method_name)
+    self.columns.detect {|c| c.method_name == method_name }
+  end
+  
+  def column_names
+    columns.collect {|x| methodize(x.method_name).to_sym}
+  end
+  
+  def create_record_struct
+    attributes = columns.collect {|column| column.method_name.to_sym}
+    Struct.new( *attributes)
+  end
+  
+  def to_csv
+    table_to_csv(mdb_file, table_name)
+  end
+  
+  def to_sql
+    raise 'not implemented'
+  end
+  
+  def find_first(conditions_hash)
+    rekey_hash(conditions_hash)
+    result = sql_search(conditions_hash).first
+    create_record(result) 
+  end
+  
+  def find_all(conditions_hash={})
+    if conditions_hash.empty?
+      return sql_select(mdb_file, table_name, nil, '1 = 1').collect {|r| create_record(r)}
+    end
+    rekey_hash(conditions_hash)
+    sql_search(conditions_hash).collect {|r| create_record(r) }
+  end
+  
+  private
+  
+  def create_record(line)
+    Record.new(self, line)
+  end
+  
+  def rekey_hash(conditions_hash)
+    conditions_hash.each do |key,value|
+      column = self[key.to_s]
+      if column.boolean?
+        key = column.name + '!'
+      else
+        key = column.name
+      end
+    end
+  end
+  
+  # the conditions hash keys are column names, the values are search values
+  # e.g. sql_search(:first_name => 'Matthew', :last_name => 'King')
+  def sql_search(conditions_hash)
+    conditions = compile_conditions(conditions_hash) do |method_name,value|
+      column = self[method_name.to_s]
+      if column.boolean?
+        "#{column.name} = #{mdb_truth(value)}"
+      else
+        "#{column.name} like '%#{value}%'"
+      end
+    end
+    sql_select(mdb_file, table_name, nil, conditions)
+  end
+  
+  
+end
+  

data/support/a.insert

@@ -0,0 +1,7 @@
+INSERT INTO ActivityLookup (ActivityID, ActivitySeq, ActivityCode, ActivityDesc) VALUES (1,0000000000000001.,"Conversation","QA conversation with the contact - face to face")
+INSERT INTO ActivityLookup (ActivityID, ActivitySeq, ActivityCode, ActivityDesc) VALUES (2,0000000000000002.,"Phone Call","A Phone Call with the contact")
+INSERT INTO ActivityLookup (ActivityID, ActivitySeq, ActivityCode, ActivityDesc) VALUES (3,0000000000000003.,"Mail","Sent something to the contact via mail")
+INSERT INTO ActivityLookup (ActivityID, ActivitySeq, ActivityCode, ActivityDesc) VALUES (4,0000000000000004.,"eMail","Sent something to the contact via email")
+INSERT INTO ActivityLookup (ActivityID, ActivitySeq, ActivityCode, ActivityDesc) VALUES (5,0000000000000005.,"Visit","Visited the contact for a delivery or conversation")
+INSERT INTO ActivityLookup (ActivityID, ActivitySeq, ActivityCode, ActivityDesc) VALUES (6,0000000000000006.,"Meeting","Had a meeting with the contact")
+INSERT INTO ActivityLookup (ActivityID, ActivitySeq, ActivityCode, ActivityDesc) VALUES (7,0000000000000007.,"Research","Research is needed on a topic for followup/action")

data/test/test_helper.rb

@@ -0,0 +1,16 @@
+require 'test/unit'
+
+class Test::Unit::TestCase
+  
+  TEST_DB =  File.join(File.dirname(__FILE__), '..', 'db', 'sample.mdb')
+
+  
+  protected
+  
+  def create_mdb(options={})
+    excluded = options[:exclude]
+    included = options[:include]
+    assert_nothing_raised { @db = MDB.new(TEST_DB, :exclude => excluded, :include => included ) }
+  end
+  
+end

data/test/test_mdb.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), "..", 'lib', 'active_mdb')
+require 'test/unit'
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class MDBTest < Test::Unit::TestCase
+  
+
+
+  def setup
+    
+  end
+  
+  def test_table_exclusion
+    create_mdb(:exclude => ['Inventory'])
+    assert !@db.table_names.include?('Inventory')
+  end
+  
+  def test_table_inclusion
+    create_mdb(:include => ['Inventory', 'Room'])
+    assert_equal ['Inventory', 'Room'], @db.table_names.sort
+  end
+  
+  def test_reflection
+    create_mdb
+    assert_respond_to @db, 'computer'
+    assert_respond_to @db, 'employee'
+    assert_respond_to @db, 'room'
+  end
+  
+  
+
+  
+  
+end
+  

data/test/test_mdb_tools.rb

@@ -0,0 +1,100 @@
+require File.join(File.dirname(__FILE__), "..", 'lib', 'active_mdb')
+require 'test/unit'
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+
+class MDBToolsTest < Test::Unit::TestCase
+  include MDBTools
+  
+  EXCLUDE = ['Inventory']
+  TEST_TABLES = %w{ Room Computer Employee  }
+  TORBATI_Y = {"Department"=>"Engineering",
+   "Gender"=>"F",
+   "Room"=>"6044",
+   "Title"=>"Programmer",
+   "Emp_Id"=>"1000",
+   "First_Name"=>"Yolanda",
+   "Last_Name"=>"Torbati"}
+  README = File.join(File.dirname(__FILE__), "..", "README")
+  
+  def setup
+    @employees_csv = mdb_export(TEST_DB, 'Employee', :format => 'csv', :headers => true)
+  end
+  
+  def test_check_file
+    assert_nothing_raised { check_file TEST_DB }
+    assert_raise(ArgumentError) { check_file 'completely_bogus_filename' }
+    # the README file is obviously not an Access database
+    assert_raise(ArgumentError) { check_file README}
+  end
+  
+  def test_check_table
+    assert_nothing_raised { check_table TEST_DB, 'Employee'}
+    assert_raises(ArgumentError) { check_table TEST_DB, 'foobarbaz' }
+  end
+  
+  def test_mdb_tables
+    tables1 = mdb_tables(TEST_DB, :exclude => EXCLUDE)
+    assert_equal TEST_TABLES, tables1
+
+    assert_raises( ArgumentError) { mdb_tables(TEST_DB, :include => [], :exclude => []) }
+    tables4 = mdb_tables(TEST_DB, :exclude => 'Room')
+    assert_equal %w{Computer Employee Inventory}, tables4
+  end
+  
+  def test_mdb_tables_with_include
+    tables = mdb_tables(TEST_DB, :include => ['Room', 'Computer'])
+    assert_equal ['Room', 'Computer'], tables
+  end
+  
+  def test_mdb_tables_with_nils
+    assert_nothing_raised do
+      tables = mdb_tables(TEST_DB, :include => nil, :exclude => nil)
+      assert_not_nil tables
+    end
+  end
+  
+  def test_mdb_schema
+    assert_nothing_raised { @schema = mdb_schema(TEST_DB, 'Employee') }
+    assert_match /DROP TABLE/, @schema
+  end
+  
+  
+  # def test_csv_to_hashes
+  #   employee_hash = csv_to_hashes(@employees_csv)
+  #   assert_equal TORBATI_Y, employee_hash.first
+  # end
+  
+  def test_sql_select
+    assert_equal ["Torbati","Yolanda", "F", "Programmer", "Engineering", "6044", "1000"], 
+        sql_select(TEST_DB, 'Employee', ['*'], "First_Name LIKE 'Yolanda'" ).first
+  end
+  
+  def test_compile_conditions
+    conditions = {:foo => 'bar', :baz => 1, :nark => 'noo'}
+    assert_equal "baz like '%1%' AND foo like '%bar%' AND nark like '%noo%'", compile_conditions(conditions)
+  end
+  
+  def test_compiled_sql_select
+    sql_select(TEST_DB, 'Employee', nil, compile_conditions(:first_name => 'Yolanda'))
+  end
+  
+  def test_export_table_to_sql
+    # this test is dependent on specific content in the sample database
+    export = mdb_export(TEST_DB, 'Computer', :format => 'sql').split(LINEBREAK)
+    assert_equal 172, export.size
+    assert export.first =~ /INSERT INTO.*MITSUBISHI.*HL6605ATK/
+  end
+  
+  def test_export_table_to_csv
+    export = mdb_export(TEST_DB, 'Employee', :format => 'csv').split(LINEBREAK)
+    assert_equal 53, export.size
+    assert export.first =~ /\"Torbati\",/
+  end
+  
+  def test_backends
+    assert_nothing_raised { backends }
+  end
+  
+  
+end

data/test/test_record.rb

@@ -0,0 +1,24 @@
+require File.join(File.dirname(__FILE__), "..", 'lib', 'active_mdb')
+require 'test/unit'
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class RecordTest < Test::Unit::TestCase
+
+  def setup
+    create_mdb
+    @employee = @db.employee
+    @line = ["Torbati","Yolanda", "F", "Programmer", "Engineering", "6044", "1000"]
+    assert_nothing_raised { @record = Record.new(@employee, @line) }
+  end
+  
+  def test_reflection
+    assert_respond_to @record, 'gender'
+    assert_respond_to @record, 'emp_id'
+    assert_equal 'Yolanda', @record.first_name
+  end
+  
+  def test_display
+    
+  end
+
+end

data/test/test_table.rb

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__), "..", 'lib', 'active_mdb')
+require 'test/unit'
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class TableTest < Test::Unit::TestCase
+  
+  
+  def setup
+    create_mdb
+    @employee = @db.employee
+  end
+  
+  def test_columns
+    columns = @employee.columns
+    assert_kind_of Array, columns
+    assert_kind_of Column, columns.first
+    assert_equal 7, columns.size
+  end
+  
+  def test_create_record_struct
+    assert_kind_of Class, @employee.record_struct
+    members = @employee.record_struct.members
+    assert_equal 7, members.size
+    assert members.include?('emp_id')
+  end
+  
+  def test_to_csv
+    csv_text = @employee.to_csv
+    assert_kind_of String, csv_text
+    arrays = csv_text.split(MDBTools::LINEBREAK)
+    
+    # grab the headers and test for content
+    assert arrays.shift.include?('Emp_Id')
+    assert_equal 53, arrays.size
+  end
+  
+  def test_find_first
+    y = @employee.find_first(:first_name => 'Yolanda')
+    assert_kind_of Record, y
+    assert_equal 'Yolanda', y.first_name
+  end
+  
+  def test_find_all
+    a_names = @employee.find_all(:last_name => 'A')
+    assert_kind_of Array, a_names
+    assert_kind_of Record, a_names.first
+    assert_equal 2, a_names.size
+  end
+  
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: activemdb
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-03-12 00:00:00 -05:00
+summary: a reflective wrapper around MDB Tools, which lets POSIX platforms read MS Access (.mdb) files
+require_paths: 
+- lib
+email: automatthew@gmail.com
+homepage: http://rubyforge.org/projects/activemdb/
+rubyforge_project: activemdb
+description: Intended for exploration and migration, not production. ActiveMDB provides a thin wrapper around the mdb-tables, mdb-schema, mdb-sql, and mdb-export binaries from Brian Bruns's MDB Tools project (http://mdbtools.sourceforge.net/).
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Matthew King
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- db/sample.mdb
+- irb.rc
+- lib/active_mdb.rb
+- lib/active_mdb/column.rb
+- lib/active_mdb/mdb.rb
+- lib/active_mdb/mdb_tools.rb
+- lib/active_mdb/record.rb
+- lib/active_mdb/table.rb
+- support/a.insert
+- test/test_activemdb.rb
+- test/test_helper.rb
+- test/test_mdb.rb
+- test/test_mdb_tools.rb
+- test/test_record.rb
+- test/test_table.rb
+test_files: 
+- test/test_activemdb.rb
+- test/test_helper.rb
+- test/test_mdb.rb
+- test/test_mdb_tools.rb
+- test/test_record.rb
+- test/test_table.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.0
+    version: