yob-activemdb 0.2.2

data/README.txt

@@ -0,0 +1,69 @@
+ActiveMDB
+by Matthew King
+http://rubyforge.org/projects/activemdb/
+
+== DESCRIPTION:
+  
+ActiveMDB is a developer's tool for exploration and migration of MS Access (.mdb) files. It uses ActiveRecord-ish reflection to parse table and column names and provide attribute readers.  Yes, it is  *READ ONLY*. ActiveMDB is little more than a wrapper of varying thickness around the utilities from Brian Bruns's MDB Tools project (http://mdbtools.sourceforge.net/).  Kudos to Mr. Bruns.
+
+== FEATURES/PROBLEMS:
+  
+* MDBTools - Straightforward wrapper around the CLI tools that you get with libmdb
+* ActiveMDB::Base - Subclass to make your models, just like the big shots do.
+
+
+== SYNOPSIS:
+
+  # When your Access database schema conforms to the 37s stylebook:
+  class Bacon < ActiveMDB::Base
+    set_mdb_file 'db/wherefore.mdb'
+  end
+
+  # in the find_* methods, the entries in the hash 
+  # get turned into "WHERE #{key} like %#{value}%" conditions,
+  # which fails when the column is a boolean, which is a regression from 0.1.0.
+  # I could fix this tonight, but my son is yelling at me to come out for dinner.
+  best_bacon = Bacon.find_all(:rind => 'creamy', :sodium_content => 'Awesome!' )
+  
+  # When it doesn't:
+  class Employee < ActiveMDB::Base
+    set_mdb_file 'db/sample.mdb'
+    set_table_name 'Employee'
+    set_primary_key 'Emp_Id'
+  end
+
+  paula = Employee.find_first(:Department => 'Engineering', :Specialty => 'paulaBeans')
+
+
+== REQUIREMENTS:
+
+* http://mdbtools.sourceforge.net/
+
+== INSTALL:
+
+* Sadly, no easy install of MDB Tools at this time.  It compiles on Mac OS X 10.4.x, both PPC and Intel.  Haven't tested on Linuxes yet, but that's what Parallels is for, right?
+
+== 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 = 'ActiveRecordy wrapper around MDB Tools, allowing POSIX platforms to read MS Access (.mdb) files'
+  p.description = p.paragraphs_of('README.txt', 2).join("\n\n")
+  p.url = 'http://activemdb.rubyforge.org/'
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+
+# vim: syntax=Ruby

data/lib/active_mdb.rb

@@ -0,0 +1,19 @@
+$:.unshift(File.dirname(__FILE__))
+module ActiveMDB
+  VERSION = '0.2.2'
+end
+
+
+require 'rubygems'
+require 'active_support'
+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'
+load 'active_mdb/base.rb'
+require 'faster_csv'
+
+
+
+

data/lib/active_mdb/base.rb

@@ -0,0 +1,184 @@
+module ActiveMDB
+  # Hi, I am an imitation of ActiveRecord.
+  class Base
+    
+    def initialize(attributes=nil)
+      @attributes = attributes unless attributes.nil?
+    end
+    
+    cattr_accessor :pluralize_table_names, :instance_writer => false
+    @@pluralize_table_names = true
+    
+    class << self # Class methods
+      attr_accessor :mdb_file
+      attr_reader :mdb
+      
+      # set the path to the MDB file
+      def set_mdb_file(file)
+        @mdb_file = file
+        @mdb = MDB.new(file)
+      end
+      
+      # set the name of the table in the MDB file
+      def table_name
+        table_name = Inflector.underscore(Inflector.demodulize(self.to_s))
+        table_name = Inflector.pluralize(table_name) if pluralize_table_names
+        table_name
+      end
+      
+      # borrowed from ActiveRecord
+      def set_table_name(value = nil, &block)
+        define_attr_method :table_name, value, &block
+      end
+      alias :table_name= :set_table_name
+      
+      # Returns an array of column objects for the table associated with this class.
+      def columns
+        unless @columns
+          @columns = @mdb.columns(table_name)
+          # @columns.each {|column| column.primary = column.name == primary_key}
+        end
+        @columns
+      end
+      
+      def column_names
+        @mdb.column_names(table_name)
+      end
+      
+      # returns 'id' unless you overwrite this method using set_primary_key
+      def primary_key
+        'id'
+      end
+
+      # specify the field to be used as a primary key for those
+      # operations that require one.  At this time, that isn't really
+      # anything except count.
+      def set_primary_key(value = nil, &block)
+        define_attr_method :primary_key, value, &block
+      end
+      alias :primary_key= :set_primary_key
+    
+      def table_exists?
+        @mdb.tables.include? table_name
+      end
+      
+      # How many?  Requires that the primary_key return a valid field.
+      def count
+        @mdb.count(table_name, primary_key)
+      end
+      
+      # the conditions hash keys are column names, the values are search values
+      # find_first :superhero_name => 'The Ironist', :powers => 'Wit'
+      #
+      # mdb-sql doesn't implement LIMIT yet, so this method pulls all results and
+      # calls Array#first on them.  Ooky.
+      def find_first(conditions_hash)
+        # rekey_hash(conditions_hash)
+        find_from_hash(conditions_hash).first 
+      end
+      
+      # the conditions hash keys are column names, the values are search values
+      # find_all :superhero_name => 'The Ironist', :powers => 'Wit'
+      def find_all(conditions_hash = {})
+        find_from_hash(conditions_hash)
+      end
+          
+      # borrowed from ActiveRecord.
+      def define_attr_method(name, value=nil, &block)
+        sing = class << self; self; end
+        sing.send :alias_method, "original_#{name}", name
+        if block_given?
+          sing.send :define_method, name, &block
+        else
+          # use eval instead of a block to work around a memory leak in dev
+          # mode in fcgi
+          sing.class_eval "def #{name}; #{value.to_s.inspect}; end"
+        end
+      end
+      
+      # relies on stuff that doesn't work right now
+      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
+          
+      # supply a conditions string that would nestle gently in a 
+      # WHERE clause, after the WHERE but before the.
+      def find_where(conditions)
+        MDBTools.sql_select_where(mdb_file, table_name, nil, conditions).collect! { |record| instantiate(record) }
+      end
+      
+      # takes a hash where the keys are column names (string or symbol)
+      # and the values are the associated values.
+      def find_from_hash(hash)
+        conditions = conditions_from_hash(hash)
+        find_where(conditions)
+      end
+      
+      # the conditions hash keys are column names, the values are search values
+      # e.g. search_with_hash(:first_name => 'Matthew', :last_name => 'King')
+      def conditions_from_hash(hash)
+        return nil if hash.nil? || hash.empty?
+        MDBTools.compile_conditions(hash) do |column_name, value|
+          column = column_for_method(column_name) || column_for_field(column_name)
+          raise ArgumentError, "No column corresponding to #{column_name}" unless column
+          case column.klass.to_s
+          when 'Fixnum', 'Float'
+            "#{column.name} = #{value}"
+          when 'String'
+            "#{column.name} LIKE '%#{value}%'"
+          when 'Object'
+            value = value ? 1 : 0
+            "#{column.name} IS #{value}"
+          end
+        end
+      end
+      
+      # given the name of a column, return the Column object
+      def column_for_field(column_name)
+        columns.detect {|c| c.name == column_name.to_s}
+      end
+      
+      def column_for_method(method_name)
+        columns.detect {|c| c.method_name == method_name.to_s}
+      end
+      
+      private
+      
+      def instantiate(record)
+        new_hash = {}
+        record.each do |name,value|
+          # begin
+            new_hash[MDBTools.methodize(name)] = column_for_field(name).type_cast(value)
+          # rescue
+          #   raise "No column for #{name}"
+          # end
+        end
+        self.new new_hash
+      end
+      
+      
+    end
+    
+    private
+    
+    def method_missing(method_id, *args, &block)
+       method_name = MDBTools.methodize(method_id.to_s)
+       spaced_method_name = method_name.gsub("_"," ")
+       if @attributes.include?(method_name)
+         value = @attributes[method_name]
+       elsif @attributes.include?(spaced_method_name)
+         value = @attributes[spaced_method_name]
+       else
+         super
+       end
+     end
+    
+  end
+end

data/lib/active_mdb/column.rb

@@ -0,0 +1,69 @@
+class Column
+  include MDBTools
+  
+  attr_reader :method_name, :name, :type, :size
+  
+  def initialize(name, type, size)
+    @name, @type = name, type
+    @method_name, @size = methodize(name), size.to_i
+  end
+  
+  # returns a new Column from a hash with the keys: 
+  # 'Column Name', 'Type', and 'Size'
+  def self.new_from_describe(describe_hash)
+    self.new(describe_hash["Column Name"], describe_hash["Type"], describe_hash["Size"])
+  end
+
+  # return Ruby class corresponding to data type.  
+  # Borrowed from ActiveRecord
+  def klass
+    case type
+      when 'Text', 'Character'  then String
+      when 'Long Integer'       then Fixnum
+      when 'Double'             then Float
+      when 'Currency', 'Float'  then Float
+      when 'DateTime (Short)'   then Time
+      when 'Boolean'            then Object
+      when 'Decimal'            then BigDecimal
+      when 'Binary'             then String
+    end
+  end
+  
+  # Casts value (which is a String) to an appropriate instance.
+  # Totally borrowed from ActiveRecord
+  def type_cast(value)
+    return nil if value.nil?
+    case type
+      when 'Text', 'Character'  then value
+      when 'Long Integer'       then value.to_i rescue value ? 1 : 0
+      when 'Currency', 'Float'  then value.to_f
+      when 'Double'             then value.to_f
+      when 'DateTime (Short)'   then self.class.string_to_time(value)
+      when 'Boolean'            then self.class.value_to_boolean(value)
+      when 'Decimal'            then self.class.value_to_decimal(value)
+      when 'Binary'             then self.class.binary_to_string(value)
+      else value
+    end
+  end
+  
+  def self.string_to_time(string)
+    string
+  end
+  
+  # provided any argument, returns the mdb-tools version 
+  # of truth (which is to say, 1 or 0)
+  def self.value_to_boolean(value)
+    if value == true || value == false
+      value
+    else
+      %w(true t 1).include?(value.to_s.downcase)
+    end
+  end
+  
+  # Are you a Boolean?
+  def boolean?
+    self.type == 'Boolean'
+  end
+  
+  
+end

data/lib/active_mdb/mdb.rb

@@ -0,0 +1,50 @@
+# require 'mdb_tools'
+  
+class MDB
+  include MDBTools
+  
+  attr_reader :mdb_file, :prefix, :exclude, :tables
+  
+  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'
+    @tables = mdb_tables(@mdb_file, :exclude => @exclude, :include => @include)
+    # @tables = create_table_objects
+  end
+  
+  # consumer of poor, weak MDBTools.faked_count
+  def count(table_name, attribute)
+    MDBTools.faked_count(@mdb_file, table_name, attribute)
+  end
+  
+  def columns(table_name)
+    MDBTools.describe_table(@mdb_file, table_name).map do |column|
+      Column.new_from_describe(column)
+    end
+  end
+  
+  def column_names(table_name)
+    MDBTools.field_names_for(@mdb_file, table_name)
+  end
+
+  
+  private
+
+  # Deprecated.
+  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,229 @@
+module MDBTools
+  
+  extend self
+  
+  DELIMITER = '::'
+  LINEBREAK = "\n"
+  SANITIZER = /^\w\.\_/ # dumb filter for SQL arguments
+  BACKENDS = %w{ access mysql oracle postgres sybase }
+  
+  # test for existence and usability of file
+  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
+  
+  # runs mdb_version.  A blank version indicates an unusable file
+  def valid_file?(file)
+    !mdb_version(file).blank?
+  end
+  
+  def mdb_version(file)
+    `mdb-ver #{file} 2> /dev/null`.chomp
+  end
+  
+  # raises an ArgumentError unless the mdb file contains a table with the specified name.
+  # returns the table name, otherwise.
+  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
+  
+  # uses mdb-tables tool to return an array of table names.
+  # You can filter the tables by passing an array of strings as
+  # either the :exclude or :include key to the options hash.
+  # The strings will be ORed into a regex.  Only one or the other of
+  # :exclude or :include, please.
+  #
+  # ex. mdb_tables('thing.mdb', :exclude => ['_Lookup'])
+  #
+  # ex. mdb_tables('thing.mdb', :include => ['tbl'])
+  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
+  
+  # takes an array of field names
+  # and some conditions to append in a WHERE clause
+  def sql_select_where(mdb_file, table_name, attributes = nil, conditions=nil)
+    if attributes.respond_to?(:join)
+      attributes = attributes.collect {|a| "\"#{a}\"" }.join(' ') 
+    elsif attributes.kind_of?(String)
+      attributes = "\"#{attributes}\""
+    else
+      attributes ||= '*'
+    end
+    where = conditions ? "where #{conditions}" : ""
+    sql = "select #{attributes} from #{table_name} #{where}"
+    mdb_sql(mdb_file, sql)
+  end
+  
+  # forks an IO.popen running mdb-sql and discarding STDERR to /dev/null.
+  # The sql argument should be a single statement, 'cause I don't know
+  # what will happen otherwise.  mdb-sql uses "\ngo" as the command terminator.
+  def mdb_sql(mdb_file,sql)
+    # libMDB barks on stderr quite frequently, so discard stderr entirely
+    command = "mdb-sql -Fp -d '#{DELIMITER}' #{mdb_file} 2> /dev/null \n"
+    array = []
+    IO.popen(command, 'r+') do |pipe|
+      pipe << "#{sql}\ngo\n"
+      pipe.close_write
+      pipe.readline
+      fields = pipe.readline.chomp.split(DELIMITER)
+      pipe.each do |row|
+        hash = {}
+        row = row.chomp.split(DELIMITER)
+        fields.each_index do |i|
+          hash[fields[i]] = row[i]
+        end
+        array << hash
+      end
+    end
+    array
+  end
+
+  # uses mdb-sql to retrieve an array of the table's field names
+  def field_names_for(mdb_file, table)
+    fields = `echo -n 'select * from #{table} where 1 = 2' | mdb-sql -Fp -d '#{DELIMITER}' #{mdb_file}`.chomp.sub(/^\n+/, '')
+    fields.split(DELIMITER)
+  end
+  
+
+  # takes a hash where keys are column names, values are search values
+  # and returns a string that you can use in a WHERE clause
+  #
+  # ex. compile_conditions(:first_name => 'Summer', :last_name => 'Roberts') 
+  # gives "first_name like '%Summer%' AND last_name like '%Roberts%'
+  #
+  # if you want to use an operator other than LIKE, give compile_conditions
+  # a block that accepts column_name and value and does something interesting
+  #
+  # compile_conditions(:age => 18) {|name, value| "#{name} = #{value}"}
+  #
+  # the condition phrases are all ANDed together before insertion into a WHERE clause
+  def compile_conditions(conditions_hash)
+    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
+  
+  # really dumb way to get a count.  Does a SELECT and call size on the results
+  def faked_count(*args)
+    sql_select_where(*args).size
+  end
+  
+  # convenience method, not really used with ActiveMDB.  
+  # Valid options are :format, :headers, and :sanitize, 
+  # which correspond rather directly to the underlying mdb-export arguments.
+  # Defaults to :format => 'sql', :headers => false, :sanitize => true
+  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
+  
+  # wrapper for DESCRIBE TABLE using mdb-sql
+  def describe_table(mdb_file, table_name)
+    command = "describe table \"#{table_name}\""
+    mdb_sql(mdb_file,command)
+  end
+  
+  # wrapper for mdb-schema, returns SQL statements
+  def mdb_schema(mdb_file, table_name)
+    schema = `mdb-schema -T #{table_name.dump} #{mdb_file}`
+  end
+
+  # convenience method for mdb_export to output CSV with headers.
+  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
+  
+
+  # helper to turn table names into standard format method names.
+  # Inside, it's just ActionView::Inflector.underscore
+  def methodize(table_name)
+    Inflector.underscore table_name
+  end
+  
+  def backends
+    BACKENDS
+  end
+  
+  # poor, weakly sanitizing gsub!.
+  def sanitize!(string)
+    string.gsub!(SANITIZER, '')
+  end
+  
+  # mdb-tools recognizes 1 and 0 as the boolean values.
+  # Make it so.
+  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,34 @@
+# require 'mdb_tools'
+
+# Deprecated way more than Table
+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,95 @@
+# require 'mdb_tools'  
+
+# Deprecated.  So very deprecated.
+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
+  
+  # returns an array of column names
+  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
+
+  # returns the first record that meets the equality (sometimes LIKE) conditions
+  # of the supplied hash.  No comparison operators available at the moment.
+  #
+  # find_first :superhero_name => 'The Ironist', :powers => 'Wit'
+  #
+  # mdb-sql doesn't implement LIMIT yet, so this method pulls all results and
+  # calls Array#first on them.  Ooky.
+  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_where(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_where(mdb_file, table_name, nil, conditions)
+  end
+  
+  
+end
+  

data/test/test_activemdb.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), "..", 'lib', 'active_mdb')
+require 'test/unit'
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class RealWorldTest < Test::Unit::TestCase
+  
+  RETREAT = File.join(File.dirname(__FILE__), '..', 'db', 'retreat.mdb')
+  
+  class Family < ActiveMDB::Base
+    set_mdb_file RETREAT
+    set_table_name 'tblFamilyData'
+  end
+  
+  class Cabin < ActiveMDB::Base
+    set_mdb_file RETREAT
+    set_table_name 'tCabins'
+  end
+  
+  def setup
+    @retreat = MDB.new(RETREAT)
+  end
+  
+  def test_tables
+    tables = ["JobAssignmentsByCabin","Switchboard Items","tblAdultChildCode","tblCities","tblFamilyData","tblGender","tblIndividData","tblStatusChurch","tblStatusIndiv","tCabinAssignments","tCabins","tCampRates","tCampScholarships","tJobs","tJobsR","tParkAreas","tPayments","tRetreatEnrollment","tSponsors","tblStatusFamily"]
+    assert_equal tables, @retreat.tables
+  end
+
+  def test_column_names
+    column_names = ["FamKey","LName", "HisName", "HerName", "HmAddress", "AddressNumber", "StreetDirection", "StreetName", "HmAddress2", "City", "State", "Zip", "HmPhone", "UnLstHmPho?"]
+    assert_equal column_names, Family.column_names
+  end
+  
+  def test_columns
+    column = Family.columns[2]
+    assert_kind_of Column, column
+    assert_respond_to column, 'type'
+    assert_respond_to column, 'name'
+    assert_respond_to column, 'size'
+    Family.columns.each do |c|
+      assert_not_nil c.name
+      assert_not_nil c.type
+    end
+  end
+  
+  def test_column_klass
+    column = Family.columns[1]
+    assert_equal String, column.klass
+    Family.columns.each do |c|
+      assert_not_nil c.klass
+      assert_kind_of Class, c.klass
+    end
+  end
+  
+
+end

data/test/test_base.rb

@@ -0,0 +1,125 @@
+require File.join(File.dirname(__FILE__), "..", 'lib', 'active_mdb')
+require 'test/unit'
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class BaseTest < Test::Unit::TestCase
+  
+  class NonExistentTable < ActiveMDB::Base
+    set_mdb_file TEST_DB
+  end
+  class Employee < ActiveMDB::Base
+    set_mdb_file TEST_DB
+    set_table_name 'Employee'
+    set_primary_key 'Emp_Id'
+  end
+  class Room < ActiveMDB::Base
+    set_mdb_file TEST_DB
+    set_table_name 'Room'
+    set_primary_key 'Room'
+  end
+  
+  class Person < ActiveMDB::Base
+    set_mdb_file RETREAT_DB
+    set_table_name 'tblIndividData'
+    set_primary_key 'IndKey'
+  end
+
+  
+  def test_setting_mdb_file
+    assert_equal TEST_DB, Employee.mdb_file
+  end
+  
+  def test_mdb_creation
+    mdb = Employee.mdb
+    assert_not_nil mdb
+    assert_respond_to mdb, :tables
+  end
+  
+  def test_get_table_name
+    assert_equal 'non_existent_tables', NonExistentTable.table_name
+    ActiveMDB::Base.pluralize_table_names = false
+    assert_equal 'non_existent_table', NonExistentTable.table_name
+  end
+  
+  def test_set_table_name
+    Employee.set_table_name('foo')
+    assert_equal 'foo', Employee.table_name
+    assert_equal 'Room', Room.table_name
+    Employee.set_table_name('Employee')
+  end
+  
+  def test_table_exists
+    assert !NonExistentTable.table_exists?
+    assert Room.table_exists?
+  end
+  
+  def test_get_and_set_primary_key
+    assert_equal 'Emp_Id', Employee.primary_key
+    Employee.set_primary_key 'employee_id'
+    assert_equal 'employee_id', Employee.primary_key
+  end
+  
+  def test_count
+    assert_equal 92, Room.count
+    assert_equal 53, Employee.count
+  end
+  
+  def test_instantiate
+    hash = {"Department"=>"Engineering", "Gender"=>"M", "Room"=>"6072", "Title"=>"Programmer", "Emp_Id"=>"1045", "First_Name"=>"Robert", "Last_Name"=>"Weinfeld"}
+    record = Employee.send(:instantiate, hash)
+    methodized_hash = {}
+    hash.each {|k,v| methodized_hash[MDBTools.methodize(k)] = v}
+    assert_equal methodized_hash, record.instance_variable_get('@attributes')
+    hash = {"Area"=>"135.38","Entity_Handle"=>"9D7A","Room"=>"6004","Room_Type"=>"STOR-GEN"}
+    record = Room.send(:instantiate, hash)
+    assert_kind_of Float, record.instance_variable_get('@attributes')['area']
+  end
+  
+  def test_find_from_hash
+    record = Employee.find_from_hash(:Room => '6072').first
+    assert_kind_of Employee, record
+    record = Room.find_first(:Area => 135.38)
+    assert_kind_of Room, record
+  end
+  
+  def test_find_where
+    weinstein = Employee.find_where( "Last_Name = 'Weinfeld'").first
+    assert_equal 'Robert', weinstein.First_Name
+  end
+  
+  def test_conditions_from_hash
+    hash = {:Room => '6072'}
+    conditions = "Room LIKE '%6072%'"
+    assert_equal conditions, Employee.conditions_from_hash(hash)
+    hash = {:Area => 45}
+    conditions = "Area = 45"
+    assert_equal conditions, Room.conditions_from_hash(hash)
+  end
+  
+  def test_attribute_magic
+    record = Employee.find_from_hash(:Room => '6072').first
+    assert_equal '6072', record.Room
+  end
+  
+  
+  def test_find_all_with_arg
+    assert_equal 2, Employee.find_all(:First_Name => 'G').size
+  end
+  
+  def test_find_all_without_arg
+    assert_nothing_raised { @employees = Employee.find_all }
+    assert_kind_of Employee, @employees.first
+  end
+  
+  def test_column_for_field
+    assert_kind_of Column, Employee.column_for_field(:Room)
+    assert_nil Employee.column_for_field('foo')
+  end
+  
+  def test_column_for_method
+    assert_kind_of Column, Employee.column_for_method(:room)
+  end
+
+  
+
+end

data/test/test_column.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), "..", 'lib', 'active_mdb')
+require 'test/unit'
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class ColumnTest < Test::Unit::TestCase
+  
+
+  
+  def setup
+    @c1 = Column.new('is_available', 'Boolean', 0)
+  end
+  
+  def test_boolean_column
+    assert_equal false, @c1.type_cast(0)
+  end
+  
+
+  
+  # def test_string_to_time
+  #   time = '05/18/76 00:00:00'
+  #   t2 = "02/17/47 00:00:00"
+  #   assert_equal 1976, Column.string_to_time(time).year
+  #   assert_equal 5, Column.string_to_time(time).month
+  # end
+  
+end

data/test/test_helper.rb

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

data/test/test_mdb.rb

@@ -0,0 +1,28 @@
+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.tables.include?('Inventory')
+  end
+  
+  def test_table_inclusion
+    create_mdb(:include => ['Inventory', 'Room'])
+    assert_equal ['Inventory', 'Room'], @db.tables.sort
+  end
+  
+
+  
+  
+
+  
+  
+end
+  

data/test/test_mdb_tools.rb

@@ -0,0 +1,136 @@
+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_valid_file
+    assert valid_file?(TEST_DB)
+    assert !valid_file?(NOT_A_DB)
+  end
+  
+  def test_mdb_version
+    assert_equal 'JET3', mdb_version(TEST_DB)
+    assert_equal '', mdb_version(NOT_A_DB)
+  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_describe_table
+    descriptions = describe_table(TEST_DB, 'Employee')
+    assert_kind_of Array, descriptions
+    assert_kind_of Hash, descriptions.first
+    assert_equal 3, descriptions.first.size
+    assert_not_nil descriptions.first['Type']
+  end
+  
+  def test_mdb_sql
+    result = [{"Department"=>"Human Resources", "Gender"=>"F", "Room"=>"6150", "Title"=>"Vice President", "Emp_Id"=>"1025", "First_Name"=>"Kathy", "Last_Name"=>"Ragerie"}]
+    assert_equal result, mdb_sql(TEST_DB, "select * from Employee where Room = '6150'")
+    bees =  mdb_sql(TEST_DB, "select * from Employee where Last_Name like 'B%'")
+    assert_kind_of Array, bees
+    b = bees.first
+    assert_kind_of Hash, b
+  end
+  
+  def test_field_names_for
+    fields = ["Last_Name","First_Name", "Gender", "Title", "Department", "Room", "Emp_Id"]
+    assert_equal fields, field_names_for(TEST_DB, 'Employee')
+  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_where
+    yo = {"Department"=>"Engineering", "Gender"=>"F", "Room"=>"6044", "Title"=>"Programmer", "Emp_Id"=>"1000", "First_Name"=>"Yolanda", "Last_Name"=>"Torbati"}
+    assert_equal yo, sql_select_where(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_where
+    sql_select_where(TEST_DB, 'Employee', nil, compile_conditions(:first_name => 'Yolanda'))
+  end
+  
+  def test_count
+    assert_equal 92, faked_count(TEST_DB, 'Room', 'Room', nil)
+  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,68 @@
+--- !ruby/object:Gem::Specification 
+name: yob-activemdb
+version: !ruby/object:Gem::Version 
+  version: 0.2.2
+platform: ruby
+authors: 
+- Matthew King
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-13 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: ActiveRecordy wrapper around MDB Tools, allowing POSIX platforms to read MS Access (.mdb) files
+email: automatthew@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/active_mdb/mdb_tools.rb
+- lib/active_mdb/column.rb
+- lib/active_mdb/record.rb
+- lib/active_mdb/table.rb
+- lib/active_mdb/mdb.rb
+- lib/active_mdb/base.rb
+- lib/active_mdb.rb
+- Rakefile
+- README.txt
+has_rdoc: true
+homepage: http://activemdb.rubyforge.org/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: ActiveRecordy wrapper around MDB Tools, allowing POSIX platforms to read MS Access (.mdb) files
+test_files: 
+- test/test_column.rb
+- test/test_record.rb
+- test/test_activemdb.rb
+- test/test_mdb_tools.rb
+- test/test_table.rb
+- test/test_mdb.rb
+- test/test_base.rb
+- test/test_helper.rb