soup 0.1.5 → 0.2.0

data/Manifest

@@ -1,10 +1,11 @@
-lib/active_record_tuple.rb
-lib/data_mapper_tuple.rb
-lib/sequel_tuple.rb
-lib/snip.rb
+lib/soup/snip.rb
+lib/soup/tuples/active_record_tuple.rb
+lib/soup/tuples/data_mapper_tuple.rb
+lib/soup/tuples/sequel_tuple.rb
 lib/soup.rb
+Manifest
 README
 spec/snip_spec.rb
-spec/soup_test.rb
+spec/soup_spec.rb
+spec/spec_helper.rb
 spec/spec_runner.rb
-Manifest

data/README

@@ -6,26 +6,28 @@ Terrifying. And so:
   require 'soup'
   Soup.prepare
 
-  s = Snip.new
-  s.name = "James"
-  s.skills = "Bowstaff, nunchuck"
-  s.save
+  
+  Soup << { 
+    :name => "James",
+    :skills => "Bowstaff, nunchuck" 
+  }
   
   # ...much later...
   
-  s = Snip['james']
+  s = Soup['james']
   s.skills # => "Bowstaff, nunchuck"
   
-  x = Snip.new
-  x.mane = "Lush and thick"
-  x.teeth = "Sharp and ready"
-  x.position = "Above my bed!!!"
-  x.save
+  Soup << {
+    :mane => "Lush and thick"
+    :teeth => "Sharp and ready"
+    :position => "Above my bed!!!" 
+  }
+
   
-The point is that you can set any attribute on a Snip, and it will be persisted without care. 
-With reckless abandon, really.
+The point is that you can set any attribute on a Soup data, and it will be persisted without 
+care. With reckless abandon, really.
 
-The data can be stored using anything - Snip doesn't really care much about the underlying 
+The data can be stored using anything - Soup doesn't really care much about the underlying 
 persistence layer. I've written implementations using DataMapper, ActiveRecord and Sequel... 
 there are other implementations of course. Unknowable implementations. 
 Terrifying implementations. You Fool! Warren is Dead!

data/lib/soup.rb

@@ -1,7 +1,10 @@
-require 'snip'
+# Let us require stuff in lib without saying lib/ all the time
+$LOAD_PATH.unshift(File.dirname(__FILE__)).uniq!
+
+require 'soup/snip'
 
 module Soup
-  VERSION = "0.1.5"
+  VERSION = "0.2.0"
   
   DEFAULT_CONFIG = {
     :adapter  => 'sqlite3',
@@ -25,22 +28,69 @@ module Soup
   #
   def self.flavour=(tuple_implementation)
     @tuple_implementation = "#{tuple_implementation}_tuple"
+    # We want to reset the tuple class if we re-flavour the soup.
+    @tuple_class = nil
   end
   
   def self.tuple_class
-    @tuple_class ||= case @tuple_implementation
+    @tuple_class ||= case (@tuple_implementation || DEFAULT_TUPLE_IMPLEMENTATION)
     when "active_record_tuple", nil
-      ActiveRecordTuple
+      Soup::Tuples::ActiveRecordTuple
     when "data_mapper_tuple"
-      DataMapperTuple
+      Soup::Tuples::DataMapperTuple
     when "sequel_tuple"
-      SequelTuple
+      Soup::Tuples::SequelTuple
     end
   end
   
   # Get the soup ready!
   def self.prepare
-    require @tuple_implementation || DEFAULT_TUPLE_IMPLEMENTATION
+    require "soup/tuples/#{@tuple_implementation || DEFAULT_TUPLE_IMPLEMENTATION}"
     tuple_class.prepare_database(DEFAULT_CONFIG.merge(@database_config || {}))
   end
+  
+  # The main interface
+  # ==================
+  
+  # Finds bits in the soup that make the given attribute hash.
+  # This method should eventually be delegated to the underlying persistence
+  # layers (i.e. Snips and Tuples, or another document database). The expected
+  # behaviour is 
+  def self.sieve(*args)
+    Snip.sieve(*args)
+  end
+  
+  # Puts some data into the soup, and returns an object that contains
+  # that data. The object should respond to accessing and setting its
+  # attributes as if they were defined using attr_accessor on the object's
+  # class.
+  def self.<<(attributes)
+    s = Snip.new(attributes)
+    s.save
+    s
+  end
+  
+  # A shortcut to sieve by name attribute only
+  def self.[](*args)
+    results = if args[0].is_a?(Hash) || args.length > 1
+      sieve(*args)
+    else
+      sieve(:name => args[0])
+    end
+    results.length == 1 ? results.first : results
+  end
+  
+  # ==== (interface ends) =====
+  
+  # Save the current state of the soup into a YAML file.
+  def self.preserve(filename='soup.yml')
+    snips = {}
+    1.upto(Soup.tuple_class.next_snip_id) do |id|
+      snip = Snip.find(id) rescue nil
+      snips[snip.id] = snip if snip
+    end
+    File.open(filename, 'w') do |f|
+      f.puts snips.to_yaml
+    end
+  end
 end

data/lib/{snip.rb → soup/snip.rb}

@@ -1,43 +1,37 @@
 require 'rubygems'
-
-# Based on Builder's BlankSlate object
-class EmptyClass
-  instance_methods.each { |m| undef_method(m) unless m =~ /^(__|instance_eval|respond_to\?)/ }
-end
+require 'soup/empty_class'
 
 # methods called on Tuple:
 # Tuple.for_snip(id)
 # Tuple.find_matching(tuple_name, tuple_value_conditions)
-# Tuple.all_for_snip_named(name)
+# Tuple.find_matching_hash(key => value, key2 => value2, ...)
 # Tuple.next_snip_id
 # Tuple#save
 # Tuple#name
 # Tuple#value
 # Tuple#destroy
 
-class Snip < EmptyClass
-  
-  # Returns the snip with the given name (i.e. the snip with the tuple of "name" -> name)
-  #
-  def self.[](name)
-      tuples = Soup.tuple_class.all_for_snip_named(name)
-      snip = Snip.new(:__id => tuples.first.snip_id)
-      snip.replace_tuples(tuples)
-      snip
-    rescue
-      return nil
-  end
+class Snip < Soup::EmptyClass
   
   # 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'")
+  #   Snip.sieve(: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 = Soup.tuple_class.find_matching(name, tuple_value_conditions)
-    matching_tuples.map { |t| t.snip_id }.uniq.map { |snip_id| find(snip_id) }
+  def self.sieve(*args)
+    if args.length > 1
+      name = args[0]
+      tuple_value_conditions = args[1]
+      matching_tuples = Soup.tuple_class.find_matching(name, tuple_value_conditions)
+      matching_tuples.map { |t| t.snip_id }.uniq.map { |snip_id| find(snip_id) }
+    else
+      pairs = args[0].inject([]) { |ary, (name, value)| ary << [name, value] }
+      matching_tuples = pairs.map { |(name, value)| Soup.tuple_class.find_matching(name, "='#{value}'") }.flatten
+      snips = matching_tuples.map { |t| t.snip_id }.uniq.map { |snip_id| find(snip_id) }
+      snips.reject { |s| pairs.map { |(name, value)| s.get_value(name) == value }.include?(false) }
+    end
   end
   
   # Returns the snip with the given ID (i.e. the collection of all tuples
@@ -96,6 +90,10 @@ class Snip < EmptyClass
     "<Snip id:#{self.id || "unset"} name:#{self.name}>"
   end
   
+  def to_yaml(*args)
+    attributes.to_yaml(*args)
+  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.
@@ -109,6 +107,21 @@ class Snip < EmptyClass
     @id
   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] = Soup.tuple_class.new(attributes)
+    end
+    tuple.value
+  end
+  
   
   private
   
@@ -132,19 +145,4 @@ class Snip < EmptyClass
     @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] = Soup.tuple_class.new(attributes)
-    end
-    tuple.value
-  end
-  
 end

data/lib/soup/tuples/active_record_tuple.rb

@@ -0,0 +1,48 @@
+require 'rubygems'
+gem 'activerecord', '>=2.0.2'
+require 'activerecord'
+
+module Soup
+  module Tuples
+    class ActiveRecordTuple < ActiveRecord::Base
+      set_table_name :tuples
+  
+      def self.prepare_database(config)
+        ActiveRecord::Base.establish_connection(config)
+        return if connection.tables.include?("tuples")  # NOTE - this probably isn't good enough (what if the schema has changed?)
+        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
+  
+      # 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
+  end
+end

data/lib/soup/tuples/data_mapper_tuple.rb

@@ -0,0 +1,50 @@
+require 'rubygems'
+gem 'datamapper'
+require 'data_mapper'
+
+module Soup
+  module Tuples
+
+    # This tuple implementation is broken - there's a weird interaction
+    # where values are not set within the web application.
+    #
+    class DataMapperTuple < DataMapper::Base  
+      def self.prepare_database(config)
+        DataMapper::Database.setup(config)
+        # NOTE: so um, this property stuff doesn't like it if you're not connected to the db
+        # lets only have it once we are?  Seems mental.
+        self.class_eval {
+          set_table_name 'tuples'
+      
+          property :snip_id, :integer
+
+          property :name, :string
+          property :value, :text
+
+          property :created_at, :datetime
+          property :updated_at, :datetime
+        }
+        return if self.table.exists? # NOTE - this probably isn't good enough (what if the schema has changed?)
+        DataMapper::Persistence.auto_migrate! 
+      end
+  
+      def self.for_snip(id)
+        all(:snip_id => 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
+    
+  end
+end

data/lib/soup/tuples/sequel_tuple.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+gem 'sequel'
+require 'sequel'
+
+DB = Sequel.sqlite 'soup_development.db'
+
+module Soup
+  module Tuples
+  
+    class SequelTuple < 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.prepare_database(config)
+        # ummm... how to connect?
+        create_table # TODO: detect if the table already exists
+      end
+  
+      def self.for_snip(id)
+        filter(:snip_id => id).to_a
+      end
+
+      # TODO: *totally* not threadsafe.
+      def self.next_snip_id
+        max(:snip_id) + 1
+      end
+    end
+    
+  end
+end

data/soup.gemspec

@@ -1,26 +1,19 @@
 
-# Gem::Specification for Soup-0.1.5
+# Gem::Specification for Soup-0.2.0
 # Originally generated by Echoe
 
 Gem::Specification.new do |s|
   s.name = %q{soup}
-  s.version = "0.1.5"
-
-  s.specification_version = 2 if s.respond_to? :specification_version=
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["James Adam"]
-  s.date = %q{2008-03-17}
-  s.description = %q{Soup is a bit of everything, summoned from nothing. Soup is like an imaginary friend - comforting,}
+  s.version = "0.2.0"
+  s.date = %q{2008-04-17}
+  s.summary = %q{Soup is a bit of everything, summoned from nothing. Soup is like an imaginary friend - comforting,}
   s.email = ["james@lazyatom.com"]
-  s.files = ["lib/active_record_tuple.rb", "lib/data_mapper_tuple.rb", "lib/sequel_tuple.rb", "lib/snip.rb", "lib/soup.rb", "README", "spec/snip_spec.rb", "spec/soup_test.rb", "spec/spec_runner.rb", "Manifest", "soup.gemspec"]
-  s.has_rdoc = true
   s.homepage = %q{}
-  s.require_paths = ["lib"]
   s.rubyforge_project = %q{soup}
-  s.rubygems_version = %q{0.9.5}
-  s.summary = %q{Soup is a bit of everything, summoned from nothing. Soup is like an imaginary friend - comforting,}
-
+  s.description = %q{Soup is a bit of everything, summoned from nothing. Soup is like an imaginary friend - comforting,}
+  s.has_rdoc = true
+  s.authors = ["James Adam"]
+  s.files = ["lib/soup/snip.rb", "lib/soup/tuples/active_record_tuple.rb", "lib/soup/tuples/data_mapper_tuple.rb", "lib/soup/tuples/sequel_tuple.rb", "lib/soup.rb", "Manifest", "README", "spec/snip_spec.rb", "spec/soup_spec.rb", "spec/spec_helper.rb", "spec/spec_runner.rb", "soup.gemspec"]
   s.add_dependency(%q<activerecord>, [">= 2.0.2"])
 end
 
@@ -39,20 +32,37 @@ end
 #     soup.email = ["james@lazyatom.com"]
 #     soup.description = File.readlines("README").first
 #     soup.dependencies = ["activerecord >=2.0.2"]
+#     soup.clean_pattern = ["*.db", "meta", "pkg"]
+#     soup.ignore_pattern = [".git", "*.db", "meta"]
 #   end
-# 
+#   
 # rescue LoadError
 #   puts "You need to install the echoe gem to perform meta operations on this gem"
 # end
 # 
+# begin
+#   require 'spec'
+#   require 'spec/rake/spectask'
+#   
+#   Spec::Rake::SpecTask.new do |t|
+#     t.spec_opts = ["--format", "specdoc", "--colour"]
+#     t.spec_files = Dir['spec/**/*_spec.rb'].sort
+#     t.libs = ['lib']
+#     #t.rcov = true
+#     #t.rcov_dir = 'meta/coverage'
+#   end
+#   
+#   task :show_rcov do
+#     system 'open meta/coverage/index.html' if PLATFORM['darwin']
+#   end
+#   
+# rescue LoadError
+#   puts "You need RSpec installed to run the spec (default) task on this gem"
+# end
+# 
 # desc "Open an irb session preloaded with this library"
 # task :console do
-#   sh "irb -rubygems -r ./lib/soup.rb"
+#   sh "irb --prompt simple -rubygems -r ./lib/soup.rb"
 # end
 # 
-# # We have to run our own spec runner, because Snip will try to undefine
-# # rspec's should methods using the default one
-# task(:test) do
-#   files = FileList['spec/**/*_spec.rb']
-#   system "ruby spec/spec_runner.rb #{files} --format specdoc"
-# end
+# task :default => [:spec, :show_rcov]

data/spec/snip_spec.rb

@@ -1,46 +1,102 @@
-Soup.base = {:database => "soup_test.db"}
-Soup.prepare
+require File.join(File.dirname(__FILE__), "spec_helper")
 
-describe Snip, "when newly created" do
-  before(:each) { @snip = Snip.new }
-  
-  it "should not have a name" do
-    @snip.name.should be_nil
+describe Snip do
+  before(:each) do
+    Soup.base = {:database => "soup_test.db"}
+    Soup.prepare
+    clear_database
   end
   
-  it "should return nil for any attributes" do
-    @snip.other_attribute.should be_nil
+  describe "when newly created" do
+    before(:each) { @snip = Snip.new }
+  
+    it "should not have a name" do
+      @snip.name.should be_nil
+    end
+  
+    it "should return nil for any attributes" do
+      @snip.other_attribute.should be_nil
+    end
+  
+    it "should not have an id yet" do
+      @snip.id.should be_nil
+    end
   end
-end
 
-
-describe Snip, "when setting attributes" do
-  before(:each) { @snip = Snip.new }
+  describe "when being created with attributes" do
   
-  it "should allow setting attributes" do
-    @snip.something = "blah"
-    @snip.something.should == "blah"
-  end
+    it "should set attributes as passed in" do
+      @snip = Snip.new(:beats => 'phat', :rhymes => 100)
+      @snip.beats.should == 'phat'
+      @snip.rhymes.should == 100
+    end
   
-  it "should not respond to attributes that have not been set" do
-    @snip.should_not respond_to(:monkey)
+    it "should ignore any id passed in" do
+      @snip = Snip.new(:id => 1000) 
+      @snip.id.should be_nil
+    end
+  
+    it "should not ignore the secret __id" do
+      @snip = Snip.new(:__id => 1000)
+      @snip.id.should == 1000
+    end
   end
+
+  describe "when setting attributes" do
+    before(:each) { @snip = Snip.new }
   
-  it "should respond to attributes that have been set" do
-    @snip.monkey = true
-    @snip.should respond_to(:monkey)
+    it "should allow setting attributes" do
+      @snip.something = "blah"
+      @snip.something.should == "blah"
+    end
+  
+    it "should not respond to attributes that have not been set" do
+      @snip.should_not respond_to(:monkey)
+    end
+  
+    it "should respond to attributes that have been set" do
+      @snip.monkey = true
+      @snip.should respond_to(:monkey)
+    end
+  
+    it "should not allow setting of the id" do
+      @snip.id = 100
+      @snip.id.should_not == 100
+      @snip.id.should be_nil
+    end
   end
-end
 
-describe Snip, "when saving" do
-  before(:each) { @snip = Snip.new }
+  describe "when saving" do
+    before(:each) { @snip = Snip.new }
+  
+    it "should not save if there's no data" do
+      lambda { @snip.save }.should raise_error
+    end
+  
+    it "should return all attributes when reloading" do
+      @snip.name = "something"
+      @snip.jazz = "smooth"
+      @snip.save
+    
+      other_snip = Soup['something']
+      other_snip.jazz.should == "smooth"
+    end
+  
+    it "should generate an id" do
+      @snip.name = "something"
+      @snip.save
+    
+      other_snip = Soup['something']
+      other_snip.id.should_not be_nil
+    end
   
-  it "should return all attributes when reloading" do
-    @snip.name = "something"
-    @snip.jazz = "smooth"
-    @snip.save
+    it "should not overwrite an existing id created via __id" do
+      @snip = Snip.new(:__id => 100)
+      @snip.name = "something_else"
+      @snip.save
     
-    other_snip = Snip['something']
-    other_snip.jazz.should == "smooth"
+      other_snip = Soup['something_else']
+      other_snip.id.should == 100
+    end
   end
 end

data/spec/soup_spec.rb

@@ -0,0 +1,148 @@
+require 'soup'
+
+describe Soup do
+
+  describe "when unflavoured or based" do
+    before(:each) { Soup.class_eval { @database_config = nil; @tuple_class = nil } }
+    it "should use the default database config" do
+      # I think this set of mock / expectations might be super wrong
+      Soup::DEFAULT_CONFIG.should_receive(:merge).with({}).and_return(Soup::DEFAULT_CONFIG)
+      Soup.tuple_class.should_receive(:prepare_database).with(Soup::DEFAULT_CONFIG)
+      Soup.prepare
+    end
+  
+    it "should use the default tuple implementation" do
+      # No real idea how to mock the require, or use aught but Secret Knowledge that AR == Default
+      Soup.tuple_class.should == Soup::Tuples::ActiveRecordTuple
+      Soup::Tuples::ActiveRecordTuple.should_receive(:prepare_database)
+      Soup.prepare
+    end
+  
+  end
+
+  describe "when being based" do
+    before(:each) { Soup.class_eval { @database_config = nil; @tuple_class = nil } }
+  
+    it "should allow the base of the soup to be set" do
+      Soup.should respond_to(:base=)
+    end
+  
+    it "should use the new base when preparing the soup" do
+      bouillabaisse = {:database => 'fishy.db', :adapter => 'fishdb'} 
+      Soup.base = bouillabaisse
+      Soup.tuple_class.should_receive(:prepare_database).with(bouillabaisse)
+      Soup.prepare
+    end
+  
+    it "should merge incomplete bases with the default" do
+      tasteless = {:database => 'water.db'}
+      Soup.base = tasteless
+      Soup.tuple_class.should_receive(:prepare_database).with(Soup::DEFAULT_CONFIG.merge(tasteless))
+      Soup.prepare
+    end
+  
+    it "should allow the base to be reset" do
+      bouillabaisse = {:database => 'fishy.db', :adapter => 'fishdb'} 
+      Soup.base = bouillabaisse
+      Soup.tuple_class.should_receive(:prepare_database).once.with(bouillabaisse).ordered
+      Soup.prepare
+    
+      gazpacho = {:database => 'tomato.db', :adapter => 'colddb'}
+      Soup.base = gazpacho
+      Soup.tuple_class.should_receive(:prepare_database).once.with(gazpacho).ordered
+      Soup.prepare
+    end
+  
+    it "should not allow old bases to interfere with new ones" do
+      bouillabaisse = {:database => 'fishy.db', :adapter => 'fishdb'} 
+      Soup.base = bouillabaisse
+      Soup.tuple_class.should_receive(:prepare_database).once.with(bouillabaisse).ordered
+      Soup.prepare
+    
+      tasteless = {:database => 'water.db'}
+      Soup.base = tasteless
+      Soup.tuple_class.should_receive(:prepare_database).once.with(Soup::DEFAULT_CONFIG.merge(tasteless)).ordered
+      Soup.tuple_class.should_not_receive(:prepare_database).with(bouillabaisse.merge(tasteless))
+      Soup.prepare
+    end
+  end
+
+  describe "when being flavoured" do
+    before(:each) { Soup.class_eval { @database_config = nil; @tuple_class = nil } }
+ 
+    it "should allow the soup to be flavoured" do
+      Soup.should respond_to(:flavour=)
+    end
+  
+    it "should determine the tuple class based on the flavour" do
+      require 'soup/tuples/data_mapper_tuple'
+      Soup.flavour = :data_mapper
+      Soup.tuple_class.should == Soup::Tuples::DataMapperTuple
+    end
+  
+    it "should allow the flavour to be set multiple times" do
+      require 'soup/tuples/data_mapper_tuple'
+      Soup.flavour = :data_mapper
+      Soup.tuple_class.should == Soup::Tuples::DataMapperTuple
+    
+      require 'soup/tuples/sequel_tuple'
+      Soup.flavour = :sequel
+      Soup.tuple_class.should_not == Soup::Tuples::DataMapperTuple
+      Soup.tuple_class.should == Soup::Tuples::SequelTuple
+    end
+  
+    it "should use have no tuple class if the flavour is unknowable" do
+      Soup.flavour = :shoggoth
+      Soup.tuple_class.should == nil
+    end
+  end
+
+  describe "when adding data to the Soup directly" do
+    before(:each) do
+      Soup.base = {:database => "soup_test.db"}
+      Soup.flavour = :active_record
+      Soup.prepare
+      clear_database
+    end
+  
+    it "should create a new snip" do
+      attributes = {:name => 'monkey'}
+      Snip.should_receive(:new).with(attributes).and_return(mock('snip', :null_object => true))
+      Soup << attributes
+    end
+  
+    it "should save the snip" do
+      attributes = {:name => 'monkey'}
+      Snip.should_receive(:new).with(attributes).and_return(snip = mock('snip'))
+      snip.should_receive(:save)
+      Soup << attributes    
+    end
+  end
+
+  describe "when sieving the soup" do
+    before(:each) do
+      Soup.base = {:database => "soup_test.db"}
+      Soup.flavour = :active_record
+      Soup.prepare
+      clear_database
+      @james = Soup << {:name => 'james', :spirit_guide => 'fox', :colour => 'blue', :powers => 'yes'}
+      @murray = Soup << {:name => 'murray', :spirit_guide => 'chaffinch', :colour => 'red', :powers => 'yes'}
+    end
+    
+    it "should find snips by name if the parameter is a string" do
+      Soup['james'].should == @james
+    end
+    
+    it "should find snips using exact matching of keys and values if the parameter is a hash" do
+      Soup[:name => 'murray'].should == @murray
+    end
+    
+    it "should match using all parameters" do
+      Soup[:powers => 'yes', :colour => 'red'].should == @james
+    end
+
+    it "should return an array if more than one snip matches" do
+      Soup[:powers => 'yes'].should == [@james, @murray]
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), *%w[.. lib]))
+
+require 'soup'
+require "soup/tuples/active_record_tuple"
+
+def clear_database
+  Soup::Tuples::ActiveRecordTuple.destroy_all
+end

metadata

@@ -1,72 +1,66 @@
 --- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
 name: soup
 version: !ruby/object:Gem::Version 
-  version: 0.1.5
+  version: 0.2.0
+date: 2008-04-17 00:00:00 +01:00
+summary: Soup is a bit of everything, summoned from nothing. Soup is like an imaginary friend - comforting,
+require_paths: 
+- lib
+email: 
+- james@lazyatom.com
+homepage: ""
+rubyforge_project: soup
+description: Soup is a bit of everything, summoned from nothing. Soup is like an imaginary friend - comforting,
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
 platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
 authors: 
 - James Adam
-autorequire: 
-bindir: bin
-cert_chain: []
-
-date: 2008-03-17 00:00:00 +00:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: activerecord
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 2.0.2
-    version: 
-description: Soup is a bit of everything, summoned from nothing. Soup is like an imaginary friend - comforting,
-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/snip.rb
+- lib/soup/tuples/active_record_tuple.rb
+- lib/soup/tuples/data_mapper_tuple.rb
+- lib/soup/tuples/sequel_tuple.rb
 - lib/soup.rb
+- Manifest
 - README
 - spec/snip_spec.rb
-- spec/soup_test.rb
+- spec/soup_spec.rb
+- spec/spec_helper.rb
 - spec/spec_runner.rb
-- Manifest
 - soup.gemspec
-has_rdoc: true
-homepage: ""
-post_install_message: 
+test_files: []
+
 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: []
+extra_rdoc_files: []
 
-rubyforge_project: soup
-rubygems_version: 0.9.5
-signing_key: 
-specification_version: 2
-summary: Soup is a bit of everything, summoned from nothing. Soup is like an imaginary friend - comforting,
-test_files: []
+executables: []
+
+extensions: []
+
+requirements: []
 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.2
+    version: 

data/lib/active_record_tuple.rb

@@ -1,49 +0,0 @@
-require 'rubygems'
-gem 'activerecord', '>=2.0.2'
-require 'activerecord'
-
-class ActiveRecordTuple < ActiveRecord::Base
-  set_table_name :tuples
-  
-  def self.prepare_database(config)
-    ActiveRecord::Base.establish_connection(config)
-    return if connection.tables.include?("tuples")
-    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

@@ -1,43 +0,0 @@
-require 'rubygems'
-gem 'data_mapper'
-
-# This tuple implementation is broken - there's a weird interaction
-# where values are not set within the web application.
-#
-class DataMapperTuple < DataMapper::Base
-  
-  property :snip_id, :integer
-  
-  property :name, :string
-  property :value, :text
-  
-  property :created_at, :datetime
-  property :updated_at, :datetime
-  
-  def self.prepare_database(config)
-    DataMapper::Database.setup(config)
-    DataMapper::Persistence.auto_migrate! # TODO: detect if the table exists
-  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

@@ -1,29 +0,0 @@
-require 'rubygems'
-gem 'sequel'
-
-DB = Sequel.sqlite 'soup_development.db'
-  
-class SequelTuple < 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.prepare_database(config)
-    # ummm... how to connect?
-    create_table # TODO: detect if the table already exists
-  end
-  
-  def self.for_snip(id)
-    filter(:snip_id => id).to_a
-  end
-
-  # TODO: *totally* not threadsafe.
-  def self.next_snip_id
-    max(:snip_id) + 1
-  end
-end