christiank-turntable 0.7.1.1 → 0.999.1

data/bin/sqlite3-to-turntable

@@ -27,6 +27,9 @@ p sqlite_db_columns
 # Turntable ids and SQL ids are different...
 if sqlite_db_columns.index 'id'
   sqlite_db_columns[sqlite_db_columns.index('id')] = 'old_id'
+else
+  raise "#{table_name} needs an INTEGER PRIMARY KEY column called 'id'"
+  exit 1
 end
 
 # Convert the remaining column names to symbols
@@ -34,6 +37,6 @@ sqlite_db_columns.collect! { |column| column.to_sym }
 
 # Create the new Turntable and fill it up
 turntable_db = Turntable.new "#{table_name}.turn", sqlite_db_columns
-sqlite_db_rows.each { |row| turntable_db.insert_array row }
+sqlite_db_rows.each { |row| turntable_db.push row }
 
-puts "Created #{turntable_db.filename}"
+puts "Created #{turntable_db[:filename]}"

data/turntable.rb

@@ -1,157 +1,131 @@
 #
-# turntable v0.7.1.1
+# Turntable v0.999.1
 # Christian Koch <ckoch002@student.ucr.edu>
 #
+# Turntable is an alternative relational database for Ruby. A Turntable object
+# is actually a dictionary of row objects (which in turn are dictionaries)
+# which adhere to the row/column model and are marshalled to an external file.
+#
 
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
 require 'dictionary'
 require 'ostruct'
 
-class Turntable < Array
+class Turntable
+
+  VERSION = 'v0.999.1'
 
-  @@version = 'v0.7.1.1'
+  include Enumerable
+  def each
+    all_numbered_rows.each { |row| yield row }
+  end
 
-  # Creates a new Turntable database. Accepts either a list of column names, or
-  # an array of symbols which contain the same thing. Requires at least 2
-  # column names.
+  # Creates a new Turntable object and corresponding file. Requires a filename
+  # and a list of column names, or one array which represents the column names.
   def initialize filename, *columns
+    raise ArgumentError, 'expecting column names' if columns.empty?
+
+    @table = Dictionary.new
     if columns.length == 1
-      if columns[0].is_a?(Array) and (columns.all? { |c| c.is_a?(Symbol) })
-        @columns = columns[0]
-      else
-        raise ArgumentError, 'Turntable.new() requires a filename and at least two column names'
-      end
-    elsif columns.empty?
-      raise ArgumentError, 'Turntable.new() requires a filename and at least two column names'
+      columns[0].unshift :id
+      @table[:columns] = columns[0]
     else
-      @columns = columns
+      columns.unshift :id
+      @table[:columns] = columns
     end
 
-    @filename = File.expand_path(filename)
-
-    self.save_to @filename
+    @table[:filename] = File.expand_path(filename)
   end
 
-  # Loads an existing Turntable. You can't just Marshal.load() the database
-  # because that also marshals back the old @filename, in case the database is
-  # moved or renamed. Instead, we load the old database and then reassign
-  # its @filename. However, I don't want @filename to be writeable by the user. 
-  # So, I'm exploiting the Object#send hack, which may or may not be a good
-  # idea. There's got to be a non-controversial way of doing this.
+  # Loads an existing Turntable database file.
   def Turntable.load filename
-    @filename = File.expand_path(filename)
+    filename = File.expand_path(filename)
+    raise ArgumentError, "#{filename}: file not found" unless File.file?(filename)
 
-    f = File.open @filename
+    f = File.open filename
+    f.rewind
     turn = Marshal.load f
     f.close
 
-    turn.send :filename=, @filename
+    turn.update { turn[:filename] = filename } unless turn[:filename] == filename
     turn
   end
 
-  # Reader methods for this Turntable's metadata.
-  def Turntable.version; @@version; end
-  attr_reader :filename, :columns
-
-  # Inserts a new column to the database. All preexisting rows are filled with
-  # nil. Returns the new columns list.
-  def add_column column_name
-    @columns.push column_name
-    self.each { |row| eval "row.#{column_name} = nil" }
+  # Allows you to access Turntable rows and/or metadata like an array or hash.
+  def [](index)
+    @table[index]
+  end
 
-    self.save_to @filename
-    self.columns
+  # Only metadata can be written with []= notation.
+  def []=(index, value)
+    @table[index] = value unless index.is_a?(Fixnum)
   end
 
-  # Removes a specific row (actually, replaces the specified row with nil).
-  # Returns the deleted row.
-  def delete id
-    before_table = self.dup
-    self.update { self[id] = nil }
-    self.save_to @filename
-    before_table[id]
+  # Inserts a new column. Fills all of the pre-existing rows with nil. Returns
+  # the new databse.
+  def add_column column_name
+    raise ArgumentError, "column #{column_name} already exists" if @table[:columns].include?(column_name)
+
+    @table[:columns].push column_name
+    @table.each { |key, value| eval("@table[key].#{column_name} = nil") if key.is_a?(Fixnum) }
+    self.update
+    @table
   end
 
-  # Returns a boolean, indicating whether the select statement would return
-  # any data.
-  def include?
+  # Returns an array of all of the non-metadata rows.
+  def all_numbered_rows
     result = []
-    self.each { |row| result.push(row) if yield(row) }
-    result.any?
+    @table.each_key { |key| result.push(@table[key]) if key.is_a?(Fixnum) }
+    result
   end
 
-  # Pushes self with a new row. It accepts a list of values to be inserted, or
-  # one array which contains the same thing. Returns the newly created row.
-  def insert *args
-    args = one_array_or_list(args, @columns)
-
-    row = Row.new
-    self.empty? ? (row.id = 0) : (row.id = self.last.id + 1)
-    @columns.each { |column| eval "row.#{column} = args.shift" }
-    self.push row
-
-    self.save_to @filename
-    row
+  # Removes a given row. Returns the new database.
+  def delete id
+    @table.delete id
+    self.update
+    @table
   end
   
-  # Custom inspect() makes working in IRB much cleaner.
-  def inspect
-    "#<#{self.class}:#{self.object_id} @filename=#{self.filename.inspect}, @columns=#{self.columns.inspect}>"
-  end
-
-  # Prints the entire database to STDOUT. It's just a wrapper for
-  # Array#to_stdout.
-  def to_stdout
-    self.to_a.to_stdout
+  # A much healthier inspect() makes dealing with Turntable in IRB easier.
+  def inspect; self.to_s; end
+
+  # Returns a dictionary of all this Turntable's metadata.
+  def metadata
+    result = Dictionary.new
+    @table.each { |key, value| result[key] = value unless key.is_a?(Fixnum) }
+    result
   end
+  
+  # Pushes self with a new row. Accepts either a list of arguments, or one
+  # array which represents the same thing.
+  def push *args
+    args = args[0] if args.length == 1 and args[0].is_a?(Array)
 
-  # Changes to preexisting rows must occur inside an update() block. It's sort
-  # of like PStore#transaction.
-  def update
-    what_happened = yield
-    self.save_to @filename
-    what_happened
-  end
-
-  protected
-    # Users shouldn't reassign @filename themselves.
-    attr_writer :filename
-
-    # Checks whether the user provided one array of values, or a list which
-    # contains the same thing.
-    def one_array_or_list args, columns
-      if args.length == 1
-        unless args[0].is_a?(Array) and (args[0].length == columns.length)
-          raise ArgumentError, "wrong number of elements (#{args.length} for #{columns.length})"
-        end
-        return args[0]
-      else
-        if args.length != @columns.length
-          raise ArgumentError, "wrong number of arguments (#{args.length} for #{columns.length})"
-        end
-        return args
-      end
-    end
-
-    # Saves self to an external file.
-    def save_to filename
-      f = File.new filename, 'w'
-      Marshal.dump self, f
-      f.close
+    if args.length != (@table[:columns].length - 1)
+      raise ArgumentError, "wrong number of arguments (#{args.length} for #{@table[:columns].length - 1})"
     end
+    
+    @before_table = @table.dup
 
-end
+    row = Row.new
+    row.id = all_numbered_rows.empty? ? (0) : (all_numbered_rows.last.id + 1)
+    @table[:columns].dup.delete_if { |column| column == :id }.each { |column| eval "row.#{column} = args.shift" }
+    @table[row.id] = row
 
-class Array
+    @pushing = true
+    self.update
+    row
+  end 
 
-  # Returns an array of rows in a HTML-formatted table.
+  # Returns a string ready for HTML.
   def to_html
     string = "<table>\n"
 
     string += "\t<tr>\n"
-    self.first.table.each_key { |column| string += "\t\t<th>#{column}</th>\n" }
+    @table[:columns].each { |column| string += "\t\t<th>#{column}</th>\n" }
     string += "\t</tr>\n"
 
-    self.compact.each do |row|
+    self.each do |row|
       string += "\t<tr>\n"
       row.table.each_value { |value| string += "\t\t<td>#{value}</td>\n" }
       string += "\t</tr>\n"
@@ -159,18 +133,13 @@ class Array
     string += '</table>'
   end
 
-  # Prints an array of rows to STDOUT.
-  def to_stdout
-    puts self.to_textile
-  end
-
-  # Returns an array of rows in a Textile-formatted table.
+  # Returns a string ready for Textile.
   def to_textile
     string = ''
 
-    self.first.table.each_key { |column| string += "|_.#{column}" }
+    @table[:columns].each { |column| string += "|_.#{column}" }
     string += "|\n"
-    self.compact.each do |row|
+    self.each do |row|
       row.table.each_value { |value| string += "|#{value}" }
       string += "|\n"
     end
@@ -178,13 +147,46 @@ class Array
     string
   end
 
+  # Any changes to the external file must occur within this block. If something
+  # goes wrong (like trying to push a Proc object) then no changes are made.
+  def update
+    @pushing ? (@before_table) : (@before_table = @table.dup)
+    what_happened = yield if block_given?
+
+    begin
+      f = File.new @table[:filename], 'w'
+      Marshal.dump self, f
+    rescue
+      warn 'warning: invalid update parameters, changes were not commited'
+      @table = @before_table
+      f.rewind
+      Marshal.dump self, f
+    ensure
+      f.close
+      @pushing = false
+    end
+
+    what_happened if block_given?
+  end
+
 end
 
-# Rows are custom OpenStructs, based on dictionaries and not hashes.
+# Rows are custom OpenStructs, made with dictionaries and not hashes.
 class Row < OpenStruct
   def initialize; @table = Dictionary.new; end
   public :table
 end
 
-# Turn off Object#id warnings.
-class Object; undef id; end
+class Object
+
+  # Turn off Object#id warnings.
+  undef id
+  
+  # Just like regular puts(), except putting a Turntable calls
+  # Turntable#to_textile.
+  def puts obj
+    super obj
+    puts obj.to_textile if obj.is_a?(Turntable)
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: christiank-turntable
 version: !ruby/object:Gem::Version 
-  version: 0.7.1.1
+  version: 0.999.1
 platform: ruby
 authors: 
 - Christian Koch
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-10 00:00:00 -07:00
+date: 2009-07-13 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -23,14 +23,14 @@ extra_rdoc_files: []
 
 files: 
 - turntable.rb
-- dictionary.rb
+- lib/dictionary.rb
 has_rdoc: false
 homepage: http://github.com/christiank/Turntable
 post_install_message: 
 rdoc_options: []
 
 require_paths: 
-- .
+- lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="