christiank-turntable 0.4.4 → 0.5

data/turntable.rb

@@ -1,221 +1,132 @@
 #
-# turntable v0.4.4
-# Christian Koch < ckoch002@student.ucr.edu >
-#
-# This is free software. You are permitted to modify, implement, and otherwise
-# use this source code freely (as in beer and freedom).
+# turntable v0.5
+# Christian Koch <ckoch002@student.ucr.edu>
 #
 
-class Turntable
- 
-  @@version = '0.4.4'
-  
-  # Creates a new Turntable object and database file.
-  # Requires a filename and at least one column name.
-  def initialize filename, *args
-    raise 'Turntable.new requires a filename and at least one column name' if args.empty?
-    
-    @columns = []
-    @table = []
-    @filename = File.expand_path(filename)
-    
-    args.each do |column|
-      @columns.push column
-    end
-    
-    self.save_to @filename
-  end
-  
-  # Loads an external database file and returns the Turntable object.
-  def Turntable.load filename
-    raise "\"#{filename}\": file does not exist" unless File.exists?(filename)
-    
-    @filename = File.expand_path(filename)
-    f = File.open @filename, 'r'
-    return Marshal.load(f)
-    f.close
-  end
-  
-  # Returns the version number.
-  def Turntable.version
-    @@version
-  end
-  
-  # Reader methods for the object's columns and filename.
-  attr_reader :columns
-  attr_reader :filename
-  
-  # Pushes a new column. Fills the new fields with the empty string
-  # (because filling them with nil creates issues). Returns the the new table.
-  def add_column column_name
-    @columns.push column_name
-    @table.each { |row| row[column_name] = '' }
-  end
-    
-  # Returns true or false, depending on whether the result is empty.
-  def contains? hash
-    !self.select(hash).empty?
+require 'pstore'
+require 'ostruct'
+
+class Turntable < PStore
+
+  @@version = 'v0.5'
+
+  # Creates a new Turntable object and corresponding PStore.
+  def initialize file, *columns
+    raise ArgumentError, 'Turntable.new() requires a filename and at least one column' if columns.empty?
+
+    super(file)
+    @filename = File.expand_path(file)
+    @columns  = columns
+
+    # A quick hack for loading databases
+    @columns = columns[0] if columns.length == 1
   end
-  
-  # Deletes a row as dictated by a hash {:id => some_value}.
-  def delete hash
-    raise 'delete() requires :id => some_value' unless hash.has_key?(:id)
-    
-    before_table = @table.dup
-
-    # Delete the table for real here:
-    what_wasnt_deleted = @table.delete_if { |row| row[:id] == hash[:id] }
-    self.save_to @filename
-    
-    # Return the deleted row here:
-    return before_table - what_wasnt_deleted
+
+  # Loads an existing database if it exists, complains otherwise.
+  # Tries to reconstruct what @columns should be by looking at the first row.
+  def Turntable.load file
+    raise "#{file}: file cannot be found" unless File.exists?(file)
+
+    @filename = File.expand_path(file)
+    db = Turntable.new @filename, :foo
+    @columns = db.transaction { db[0].columns }
+
+    return Turntable.new(@filename, @columns)
   end
-  
-  # Eliminates an entire column.
-  def drop_column column_name
-    @columns.delete_if { |column| column == column_name }
-    @table.each { |row| row.delete column_name }
+
+  # Reader methods for this database's metadata.
+  attr_reader :filename, :columns
+  def version; @@version; end
+
+  # This hack should eliminate the need for transactions
+  #def in_transaction; true; end
+  #def in_transaction_wr; true; end
+
+  # The next best thing is to make transactions more domain-specific...
+  alias :update :transaction
+
+  # Returns the entire database as an array.
+  def all
+    as_array = []
+
+    self.transaction do
+      self.roots.each { |root| as_array.push self[root] }
+    end
+
+    return as_array
   end
-  
-  # Inserts a new row in the database. It requires that the number of arguments
-  # passed in equal the number of columns, just like any SQL INSERT.
-  # Columns named :id function like AUTOINCREMENT fields.
+  alias :select_all :all
+
+  # Pushes self with a new row.
+  # Columns named :id are autoincrement fields.
   def insert *args
-    unless args.length == @columns.length
-      raise "wrong number of arguments (#{args.length} for #{@columns.length})"
-    end
-    
-    row = {}
-    
-    @columns.each do |column_name|
-      if column_name == :id
-        if @table.empty?
-          row[:id] = 0
-        else
-          row[:id] = @table.last[:id] + 1
-        end
-        
-        args.shift
-      else
-        row[column_name] = args.shift
-      end
+    if args.length != @columns.length
+      raise ArgumentError, "wrong number of arguments (#{args.length} for #{columns.length})"
     end
-    
-    @table.push row
-    self.save_to @filename
+
+    row = Row.new
+    self.all.empty? ? (row.id = 0) : (row.id = self.all.last.id + 1)
+    row.columns = @columns
+    @columns.each { |column| eval "row.#{column} = args.shift" }
+
+    self.transaction { self[row.id] = row }
+
     return row
   end
-  
-  # Customize inspect() so dealing with Turntable in IRB is much cleaner.
-  def inspect
-    self.to_s
-  end
-  
-  # Print a "plain text" table to STDOUT
-  # TODO: create a table.each.columns.each protected method, or something
-  def puts_formatted
-    warn 'Warning: puts_formatted() is deprecated, use to_stdout()'
-    to_stdout
+
+  # The select statement. Equivalent to self.all.select() if there's a block,
+  # otherwise just return the specified row. In a perfect world, we should be
+  # able to access individual rows with just db[x].
+  def select *id
+    if block_given?
+      result = []
+      self.all.each { |row| result.push(row) if yield(row) }
+      return result
+    else
+      raise ArgumentError, 'select requires a block or 1 id number' if id.length != 1
+      return self.all[ id[0] ]
+    end
   end
-  
+
+  # Prints a plain text representation of the table to STDOUT
   def to_stdout
-    @table.each do |row|
+    self.all.each do |row|
+      print '|'
+      print row.id
       @columns.each do |column|
-        print "|#{row[column]}"
+        print '|'
+        print eval("row.#{column}")
       end
-      puts "|"
+      puts '|'
     end
     return nil
   end
-  
-  # Returns a subset of the table which satisfies given conditions.
-  # TODO: get compound conditions to work somehow
-  def select hash
-    result_set = []
-    
-    hash.each do |column, value|
-      this_set = @table.collect do |row|
-        row = row if row[column] == value
-      end
-      
-      result_set += this_set.compact
-    end
-    
-    return result_set
-  end
-  
-  # Returns the entire table, an array of hashes.
-  def select_all
-    @table
-  end
-  
-  alias :all :select_all
-  
-  # Replaces many columns at a time, but currently only on one row at a time.
-  def update hash
-    raise 'update() requires at least :id => some_value' unless hash.has_key?(:id)
-    
-    id = hash[:id]
-    hash.delete_if { |column, value| column == :id }
-    
-    hash.each do |column, value|
-      @table[id][column] = value
-    end
-    
-    self.save_to @filename
-    return @table[id]
-  end
-  
-  protected
-    # Marshals the database object to an external file.
-    def save_to filename
-      if File.exists? filename
-        f = File.open filename, 'w'
-      else
-        f = File.new filename, 'w'
-      end
-      
-      Marshal.dump self, f
-      f.close
-    end
+
 end
 
-class Array
-
-  # Rearranges an array of hashes according to a specified column name.
-  # TODO: how to check for @columns, even though it's a Turntable variable?
-  def order_by column_name
-      
-    # Convert all row-hashes into arrays
-    rearranged_table = self.collect { |row| row.to_a }
-    
-    # Convert all column-name-symbols into strings,
-    # then switch the first element of each row the desired order_by column
-    # (because the first element is where sort() looks)
-    rearranged_table.each do |row|
-      row.each { |column| column[0] = column[0].to_s if (column[0].class == Symbol) }
-      row.switch 0, ( row.index(row.assoc(column_name.to_s)) )
-    end
-    
-    # Sort everything properly, and convert it back to hashes and symbols
-    rearranged_table.sort.collect do |row|
-      this_row_hash = {}
-      this_column_hash = {}
-      
-      row.each do |column|
-        column[0] = column[0].to_sym
-        this_column_hash[ column[0] ] = column[1]
-      end
+class Row < OpenStruct
 
-      this_row_hash.update this_column_hash
+  # Custom inspect() to make dealing with rows in IRB cleaner
+  def inspect
+    str = "#<#{self.class}"
+    Thread.current[InspectKey] ||= []
+    if Thread.current[InspectKey].include?(self) then
+      str << " ..."
+    else
+      for k,v in @table
+        Thread.current[InspectKey] << v
+        begin
+          str << " #{k}=#{v.inspect}," unless k == :columns
+        ensure
+          Thread.current[InspectKey].pop
+        end
+      end
     end
+    str[-1, 1] = ""
+    str << ">"
   end
-  
-  # Exchanges two elements' positions within an array.
-  def switch index1, index2
-    old_array = self.dup
-    self[index1] = old_array[index2]
-    self[index2] = old_array[index1]
-  end
-  
+
 end
+
+# Quick hack to shut up Object#id deprecation warnings
+class Object; undef id; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: christiank-turntable
 version: !ruby/object:Gem::Version 
-  version: 0.4.4
+  version: "0.5"
 platform: ruby
 authors: 
 - Christian Koch
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-31 00:00:00 -07:00
+date: 2009-06-08 00:00:00 -07:00
 default_executable: 
 dependencies: []