soup 0.1.1

data/lib/active_record_tuple.rb

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'active_record'
+
+class Tuple < ActiveRecord::Base
+  def self.prepare_database
+    ActiveRecord::Migration.create_table :tuples, :force => true do |t|
+      t.column :snip_id, :integer
+      t.column :name, :string
+      t.column :value, :text
+      t.column :created_at, :datetime
+      t.column :updated_at, :datetime
+    end
+  end
+  
+  def self.for_snip(id)
+    find_all_by_snip_id(id)
+  end
+  
+  def self.find_matching(name, value_conditions=nil)
+    condition_sql = "name = '#{name}'"
+    condition_sql += " AND value #{value_conditions}" if value_conditions
+    find(:all, :conditions => condition_sql)
+  end
+  
+  def self.all_for_snip_named(name)
+    id = find_by_name_and_value("name", name).snip_id
+    for_snip(id)
+  end
+  
+  # TODO: *totally* not threadsafe.
+  def self.next_snip_id
+    maximum(:snip_id) + 1 rescue 1
+  end
+  
+  def save
+    super if new_record? || dirty?
+  end
+  
+  private 
+  
+  def dirty?
+    true # hmm.
+  end
+end

data/lib/data_mapper_tuple.rb

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'data_mapper'
+
+DataMapper::Database.setup({
+  :adapter  => 'sqlite3',
+  :database => 'soup_development.db'
+})
+
+# This tuple implementation is broken - there's a weird interaction
+# where values are not set within the web application.
+#
+class Tuple < DataMapper::Base
+  
+  property :snip_id, :integer
+  
+  property :name, :string
+  property :value, :text
+  
+  property :created_at, :datetime
+  property :updated_at, :datetime
+  
+  def self.prepare_database
+    DataMapper::Persistence.auto_migrate!
+  end
+  
+  def self.for_snip(id)
+    all(:snip_id => id)
+  end
+  
+  def self.all_for_snip_named(name)
+    id = first(:name => "name", :value => name).snip_id
+    for_snip(id)
+  end
+  
+  # TODO: *totally* not threadsafe.
+  def self.next_snip_id
+    database.query("SELECT MAX(snip_id) + 1 FROM tuples")[0] || 1
+  end
+
+  def save
+    if dirty? or new_record?
+      super
+    end
+  end
+  
+  alias_method :destroy, :destroy!
+end

data/lib/sequel_tuple.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'sequel'
+
+DB = Sequel.sqlite 'soup_development.db'
+  
+class Tuple < Sequel::Model(:tuples)
+  set_schema do
+    primary_key :id
+    integer :snip_id
+    string :name
+    string :value
+    datetime :created_at
+    datetime :updated_at
+  end
+  
+  def self.for_snip(id)
+    Tuple.filter(:snip_id => id).to_a
+  end
+
+  # TODO: *totally* not threadsafe.
+  def self.next_snip_id
+    max(:snip_id) + 1
+  end
+end
+  
+  
+# Create the table with this:
+#
+# Tuple.create_table

data/lib/snip.rb

@@ -0,0 +1,142 @@
+require 'rubygems'
+require 'blankslate'
+
+# methods called on Tuple:
+# Tuple.for_snip(id)
+# Tuple.find_matching(tuple_name, tuple_value_conditions)
+# Tuple.all_for_snip_named(name)
+# Tuple.next_snip_id
+# Tuple#save
+# Tuple#name
+# Tuple#value
+# Tuple#destroy
+
+class Snip < BlankSlate
+  
+  # Returns the snip with the given name (i.e. the snip with the tuple of "name" -> name)
+  #
+  def self.[](name)
+      tuples = Tuple.all_for_snip_named(name)
+      snip = Snip.new(:__id => tuples.first.snip_id)
+      snip.replace_tuples(tuples)
+      snip
+    rescue
+      return nil
+  end
+  
+  # Returns all snips which match the given criteria, i.e. which have a tuple that
+  # matches the given conditions. For example:
+  #
+  #   Snip.with(:created_at, "> '2007-01-01'")
+  #
+  # should return all Snips who have a 'created_at' value greater than '2007-01-01'.
+  #
+  def self.with(name, tuple_value_conditions=nil)
+    matching_tuples = Tuple.find_matching(name, tuple_value_conditions)
+    matching_tuples.map { |t| t.snip_id }.uniq.map { |snip_id| find(snip_id) }
+  end
+  
+  # Returns the snip with the given ID (i.e. the collection of all tuples
+  # with the matching snip_id, gathered into a magical snip.)
+  #
+  def self.find(id)
+    raise "not found" unless (tuples = Tuple.for_snip(id)).any?
+    snip = Snip.new(:__id => id)
+    snip.replace_tuples(tuples)
+    snip
+  end
+  
+  attr_reader :tuples
+  
+  def initialize(attributes = {})
+    set_id(attributes.delete(:__id))
+    @tuples = {}
+    attributes.each { |name, value| set_value(name, value) }
+  end
+  
+  def save
+    raise "Saving would be pointless - there's no data!" if @tuples.empty?
+    set_id_if_necessary
+    each_tuple { |t| t.save }
+    self
+  end
+  
+  def destroy
+    each_tuple { |t| t.destroy }
+  end
+  
+  def reload
+    return self unless self.id
+    replace_tuples(Tuple.for_snip(id))
+    self
+  end
+  
+  def attributes
+    @tuples.inject({}) { |h, (name, t)| h[name] = t.value; h }
+  end
+
+  def replace_tuples(new_tuples)
+    @tuples.clear
+    new_tuples.each { |tuple| @tuples[tuple.name] = tuple }
+  end
+  
+  def to_s
+    "<Snip id:#{self.id || "unset"} #{tuples_as_string}>"
+  end
+  
+  def inspect
+    "<Snip id:#{self.id || "unset"} name:#{self.name}>"
+  end
+  
+  def method_missing(method, *args)
+    value = args.length > 1 ? args : args.first
+    if method.to_s =~ /(.*)=\Z/ # || value - could be a nice DSL touch.
+      set_value($1, value)
+    else
+      get_value(method.to_s)
+    end
+  end
+  
+  def id #:nodoc: why is ID special?
+    @id
+  end
+  
+  
+  private
+  
+  def each_tuple
+    @tuples.values.each { |tuple| yield tuple }
+  end
+  
+  def set_id(id)
+    @id = id
+    self
+  end
+
+  def set_id_if_necessary
+    if self.id.nil?
+      set_id(Tuple.next_snip_id)
+      @tuples.values.each { |tuple| tuple.snip_id = self.id }
+    end
+  end
+  
+  def tuples_as_string
+    @tuples.inject("") { |hash, (name, tuple)| hash += " #{name}:'#{tuple.value}'" }.strip
+  end
+  
+  def get_value(name)
+    @tuples[name.to_s] ? @tuples[name.to_s].value : nil
+  end
+  
+  def set_value(name, value)
+    tuple = @tuples[name.to_s] 
+    if tuple
+      tuple.value = value
+    else
+      attributes = {:snip_id => self.id, :name => name.to_s, :value => value}
+      tuple = @tuples[name.to_s] = Tuple.new(attributes)
+    end
+    tuple.value
+  end
+  
+end

data/lib/soup.rb

@@ -0,0 +1,7 @@
+# require 'data_mapper_tuple'
+# or 
+require 'active_record_tuple'
+# or 
+# require 'sequel_tuple'
+
+require 'snip'

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: soup
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- James Adam
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-03-04 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: 
+email: james@lazyatom.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/active_record_tuple.rb
+- lib/data_mapper_tuple.rb
+- lib/sequel_tuple.rb
+- lib/snip.rb
+- lib/soup.rb
+has_rdoc: false
+homepage: 
+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: soup
+rubygems_version: 0.9.5
+signing_key: 
+specification_version: 2
+summary: I suppose it's a document database. Or a tuple store. But really, it's just data sloshing around, waiting to be used.
+test_files: []
+