turntable 0.0.1

data/README

@@ -0,0 +1,50 @@
+#
+# Turntable
+# The hip-hop Ruby database
+#
+# Christian Koch <cfkoch@sdf.lonestar.org>
+#
+
+Turntable is a pure Ruby implementation of a relational database, similar in
+spirit to SQLite. Unlike Sequel or any other object-relational mapper, Turntable
+is built with Ruby from the ground up, and implements Rubyisms whenever
+possible. It never goes anywhere near SQL.
+
+Turntable databases include the Enumerable mixin, so all the methods available
+there are also available for you:
+
+  turntable.
+    select { |film| film[:title] =~ /\AG/ }.
+    sort_by { |film| film[:year] }.
+    reverse.
+    detect { |film| film[:director] == "Francis Ford Coppola" }
+
+#####
+
+Turntable is released under a simplified BSD-style license.
+
+Copyright (c) 2011 Christian Koch
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

data/TODO

@@ -0,0 +1,18 @@
+In no particular order:
+
+* Somehow make every Row aware of its associated TableHeader without actually
+  shipping every Row with the TableHeader. 
+
+* Make Turntable marshallable. 
+
+* Figure out the best/most efficient way to serialize increasingly larger
+  tables.
+
+* Implement all of the SortedSet methods which are not present in Enumerable in
+  such a way that does not require calling Turntable::Table#rows. (#delete_if,
+  first, etc.)
+
+* Write simpler #inspect representations of all objects.
+
+* Add the strict typing functionality, or figure out what to do with it at
+  least.

data/lib/turntable.rb

@@ -0,0 +1,14 @@
+#
+# turntable.rb
+#
+
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+require 'turntable/columndefinition'
+require 'turntable/tableheader'
+require 'turntable/row'
+require 'turntable/table'
+
+module Turntable
+  VERSION = '0.0.1'
+end

data/lib/turntable/columndefinition.rb

@@ -0,0 +1,39 @@
+#
+# columndefinition.rb
+#
+
+module Turntable
+
+  # A Turntable::ColumnDefinition consists of a name, its position within a
+  # Turntable::TableHeader, and, optionally, its associated type. 
+  #
+  # ColumnDefinitions are meant to be created and manipulated by a TableHeader.
+  # ColumnDefinition and its methods are not intended to be used directly by the
+  # end user.
+  #
+  class ColumnDefinition
+
+    include Comparable
+
+    # A ColumnDefinition is ``less than'' another if its position is smaller.
+    # Likewise, a ColumnDefinition is ``greater than'' another if its position
+    # is greater.
+    #
+    def <=>(another)
+      (self.position > another.position) ? (1) : (-1)
+    end
+
+    attr_accessor :name
+    attr_reader :position, :type
+
+    # Creates a new ColumnDefinition. This method should not be used directly.
+    # Instead, create a new Turntable::TableHeader.
+    #
+    def initialize(name, position, type=nil)
+      @name     = name
+      @position = position
+      @type     = type
+    end
+  end
+
+end

data/lib/turntable/row.rb

@@ -0,0 +1,42 @@
+#
+# row.rb
+#
+
+require 'turntable/tableheader'
+
+module Turntable
+
+  # A Turntable::Row represents one row in a Turntable::Table, according to the
+  # table's Turntable::TableHeader.
+  #
+  class Row
+
+    include Comparable
+
+    # A Row is ``less than'' another if its position is smaller. Likewise, a Row
+    # is ``greater than'' another if its position is larger.
+    #
+    def <=>(another)
+      (self.position > another.position) ? (1) : (-1)
+    end
+
+    attr_reader :data, :position
+
+    # This method is not meant to be used directly. Refer to Turntable::Table.
+    #
+    def initialize(header, position, data_array)
+      @header   = header  # FIXME This makes IRB really ugly
+      @position = position
+      @data     = data_array
+    end
+
+    # Returns the data found at a specific column.
+    # TODO @data should have this close by...
+    #
+    def [](column_name)
+      i = @header.detect { |column| column.name == column_name }.position
+      @data[i]
+    end
+
+  end
+end

data/lib/turntable/table.rb

@@ -0,0 +1,64 @@
+#
+# table.rb
+#
+
+require 'set'
+require 'turntable/row'
+
+module Turntable
+
+  # Turntable::Table is Turntable's main interface. It maintains an ordered list
+  # of Turntable::Row objects, according to a given Turntable::TableHeader.
+  #
+  # Internally, Turntable::Table implements a SortedSet. See the documentation
+  # for Turntable::TableHeader for the reasons why. Additionally, the SortedSet
+  # ensures that two otherwise identical rows will have differing positions
+  # within the table.
+  #
+  # Turntable::Table includes Enumerable, so every method there is available
+  # here. Also, calling Turntable::Table#rows returns the internal SortedSet, so
+  # you can gain access to the instance methods available for sets that way.
+  class Table
+
+    include Enumerable
+
+    def each
+      @rows.each { |row| yield row }
+    end
+
+    attr_reader :header
+    attr_accessor :rows
+
+    # Associates a TableHeader with a new, empty Table.
+    #
+    def initialize(header)
+      @rows = SortedSet.new
+      @header = header
+    end
+
+    # Append a new Row to the Table.
+    #
+    #   t = Turntable::Table.new(some_header)
+    #   t.push "LP4", "Ratatat", 2010
+    #
+    def push(*data)
+      r = Row.new(@header, get_new_position, data)
+      @rows << r
+    end
+
+    # Determines the position of a new row. If there are no rows, then simply
+    # return 0.
+    #
+    def get_new_position
+      (@rows.empty?) ? (0) : (@rows.sort.last.position + 1)
+    end
+    private :get_new_position
+
+    # Retreives a row by its position.
+    #
+    def [](position)
+      @rows.detect { |row| row.position == position }
+    end
+
+  end
+end

data/lib/turntable/tableheader.rb

@@ -0,0 +1,49 @@
+#
+# tableheader.rb
+#
+
+require 'set'
+require 'turntable/columndefinition'
+
+module Turntable
+  
+  # A Turntable::TableHeader maintains an ordered list of ColumnDefinition
+  # objects. This list is implemented as a SortedSet for three reasons:
+  #
+  #   * It's apparently faster than Array.
+  #   * The columns appear in order in IRB.
+  #   * It ensures there are no duplicate column definitions.
+  #
+  class TableHeader
+
+    include Enumerable
+
+    def each
+      @columns.each { |column| yield column }
+    end
+
+    attr_reader :columns
+
+    # Creates a new TableHeader. The given column names should be symbols.
+    #
+    #   Turntable::TableHeader.new(:album, :artist, :year)
+    #
+    def initialize(*column_names)
+      @columns = SortedSet.new
+      column_names.each_with_index do |column, i|
+        @columns << Turntable::ColumnDefinition.new(column, i)
+      end
+    end
+
+    # Returns a ColumnDefinition by specifying its position within the
+    # TableHeader.
+    #
+    #   th = Turntable::TableHeader.new(:album, :artist, :year)
+    #   th[1]   # => #<Turntable::ColumnDefinition @name=... @position=...>
+    #
+    def [](position)
+      @columns.detect { |column| column.position == position }
+    end
+
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: turntable
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Christian Koch
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-31 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: |
+  Turntable is a pure Ruby implementation of a relational database, similar in
+  spirit to SQLite. Unlike Sequel or any other object-relational mapper, Turntable
+  is built with Ruby from the ground up, and implements Rubyisms whenever
+  possible.
+
+email: cfkoch@sdf.lonestar.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- TODO
+- lib/turntable.rb
+- lib/turntable/columndefinition.rb
+- lib/turntable/row.rb
+- lib/turntable/table.rb
+- lib/turntable/tableheader.rb
+has_rdoc: true
+homepage: 
+licenses: 
+- 2-clause BSD
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: The hip-hop Ruby database.
+test_files: []
+