soup 0.2.1 → 0.9.9

data/Manifest

@@ -1,12 +1,6 @@
 lib/soup/empty_class.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_spec.rb
-spec/spec_helper.rb
-spec/spec_runner.rb
+test/soup_test.rb

data/Rakefile

@@ -0,0 +1,115 @@
+require "rubygems"
+require "rake/gempackagetask"
+require "rake/rdoctask"
+
+task :default => :test
+
+require "rake/testtask"
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+# This builds the actual gem. For details of what all these options
+# mean, and other ones you can add, check the documentation here:
+#
+#   http://rubygems.org/read/chapter/20
+#
+spec = Gem::Specification.new do |s|
+  
+  # Change these as appropriate
+  s.name              = "soup"
+  s.version           = "0.9.9"
+  s.summary           = "A super-simple data store"
+  s.author            = "James Adam"
+  s.email             = "james@lazyatom.com"
+  s.homepage          = "http://lazyatom.com"
+
+  s.has_rdoc          = true
+  s.extra_rdoc_files  = %w(README)
+  s.rdoc_options      = %w(--main README)
+
+  # Add any extra files to include in the gem
+  s.files             = %w(Manifest Rakefile README) + Dir.glob("{test,lib}/**/*")
+   
+  s.require_paths     = ["lib"]
+  
+  # If you want to depend on other gems, add them here, along with any
+  # relevant versions
+  # s.add_dependency("some_other_gem", "~> 0.1.0")
+  
+  # If your tests use any gems, include them here
+  # s.add_development_dependency("mocha")
+
+  # If you want to publish automatically to rubyforge, you'll may need
+  # to tweak this, and the publishing task below too.
+  s.rubyforge_project = "soup"
+end
+
+# This task actually builds the gem. We also regenerate a static 
+# .gemspec file, which is useful if something (i.e. GitHub) will
+# be automatically building a gem for this project. If you're not
+# using GitHub, edit as appropriate.
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+  
+  # Generate the gemspec file for github.
+  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+  File.open(file, "w") {|f| f << spec.to_ruby }
+end
+
+# Generate documentation
+Rake::RDocTask.new do |rd|
+  rd.main = "README"
+  rd.rdoc_files.include("README", "lib/**/*.rb")
+  rd.rdoc_dir = "rdoc"
+end
+
+desc 'Clear out RDoc and generated packages'
+task :clean => [:clobber_rdoc, :clobber_package] do
+  rm "#{spec.name}.gemspec"
+end
+
+# If you want to publish to RubyForge automatically, here's a simple 
+# task to help do that. If you don't, just get rid of this.
+# Be sure to set up your Rubyforge account details with the Rubyforge
+# gem; you'll need to run `rubyforge setup` and `rubyforge config` at
+# the very least.
+begin
+  require "rake/contrib/sshpublisher"
+  namespace :rubyforge do
+    
+    desc "Release gem and RDoc documentation to RubyForge"
+    task :release => ["rubyforge:release:gem", "rubyforge:release:docs"]
+    
+    namespace :release do
+      desc "Release a new version of this gem"
+      task :gem => [:package] do
+        require 'rubyforge'
+        rubyforge = RubyForge.new
+        rubyforge.configure
+        rubyforge.login
+        rubyforge.userconfig['release_notes'] = spec.summary
+        path_to_gem = File.join(File.dirname(__FILE__), "pkg", "#{spec.name}-#{spec.version}.gem")
+        puts "Publishing #{spec.name}-#{spec.version.to_s} to Rubyforge..."
+        rubyforge.add_release(spec.rubyforge_project, spec.name, spec.version.to_s, path_to_gem)
+      end
+    
+      desc "Publish RDoc to RubyForge."
+      task :docs => [:rdoc] do
+        config = YAML.load(
+            File.read(File.expand_path('~/.rubyforge/user-config.yml'))
+        )
+ 
+        host = "#{config['username']}@rubyforge.org"
+        remote_dir = "/var/www/gforge-projects/soup/" # Should be the same as the rubyforge project name
+        local_dir = 'rdoc'
+ 
+        Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
+      end
+    end
+  end
+rescue LoadError
+  puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
+end

data/lib/soup.rb

@@ -2,95 +2,121 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__)).uniq!
 
 require 'soup/snip'
+require 'yaml'
+require 'fileutils'
 
-module Soup
-  VERSION = "0.2.1"
-  
-  DEFAULT_CONFIG = {
-    :adapter  => 'sqlite3',
-    :database => 'soup.db'
-  }
-  
-  DEFAULT_TUPLE_IMPLEMENTATION = "active_record_tuple"
-  
-  # Set the base of this soup, i.e. where to get the data. This is the
-  # database configuration, i.e.
-  #
-  #   Soup.base = {:database => 'my_soup.db'}
-  #
-  def self.base=(database_config)
-    @database_config = database_config
-  end
-  
-  # Call this to set which tuple implementation to use, i.e.
-  #
-  #   Soup.flavour = :active_record
-  #
-  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 || DEFAULT_TUPLE_IMPLEMENTATION)
-    when "active_record_tuple", nil
-      Soup::Tuples::ActiveRecordTuple
-    when "data_mapper_tuple"
-      Soup::Tuples::DataMapperTuple
-    when "sequel_tuple"
-      Soup::Tuples::SequelTuple
-    end
+class Soup
+  VERSION = "0.9.9"
+
+  # You can access a default soup using this methods.
+
+  def self.default_instance #:nodoc:
+    @@instance ||= new
+  end
+
+  def self.[](*args)
+    default_instance[*args]
+  end
+
+  def self.<<(attributes)
+    default_instance << attributes
+  end
+
+  def self.sieve(*args)
+    default_instance.sieve(*args)
   end
-  
+
+  def self.destroy(*args)
+    default_instance.destroy(*args)
+  end
+
+  attr_reader :base_path
+
   # Get the soup ready!
-  def self.prepare
-    require "soup/tuples/#{@tuple_implementation || DEFAULT_TUPLE_IMPLEMENTATION}"
-    tuple_class.prepare_database(DEFAULT_CONFIG.merge(@database_config || {}))
+  def initialize(base_path=nil)
+    @base_path = base_path || "soup"
+    FileUtils.mkdir_p(base_path)
   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)
+
+  # A shorthand for #sieve, with the addition that only a name may be
+  # supplied (i.e. Soup['my snip'])
+  def [](conditions)
+    conditions = {:name => conditions} unless conditions.respond_to?(:keys)
+    sieve(conditions)
   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
+  def <<(attributes)
+    save_snip(attributes)
+    Snip.new(attributes, self)
   end
-  
-  # A shortcut to sieve by name attribute only
-  def self.[](*args)
-    results = if args[0].is_a?(Hash) || args.length > 1
-      sieve(*args)
+
+  # 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 sieve(conditions)
+    conditions = symbolize_keys(conditions)
+    if conditions.keys == [:name]
+      load_snip(conditions[:name])
     else
-      sieve(:name => args[0])
+      all_snips.select do |s|
+        conditions.inject(true) do |matches, (key, value)|
+          matches && (s.__send__(key) == value)
+        end
+      end
     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
+
+  def destroy(name)
+    File.delete(path_for(name))
+  end
+
+  def all_snips
+    Dir[path_for("*")].map do |path|
+      load_snip(File.basename(path, ".yml"))
     end
-    File.open(filename, 'w') do |f|
-      f.puts snips.to_yaml
+  end
+
+  private
+
+  def save_snip(attributes)
+    attributes = symbolize_keys(attributes)
+    File.open(path_for(attributes[:name]), 'w') do |f|
+      content = attributes.delete(:content)
+      f.write content
+      f.write attributes.to_yaml.gsub(/^---\s/, attribute_token)
+    end
+  end
+
+  def load_snip(name)
+    path = path_for(name)
+    if File.exist?(path)
+      file = File.read(path)
+      attribute_start = file.index(attribute_token)
+      content = file.slice(0...attribute_start)
+      attributes = YAML.load(file.slice(attribute_start..-1)).merge(:content => content)
+      Snip.new(attributes, self)
+    else
+      nil
     end
   end
-end
+
+  def path_for(filename)
+    File.join(base_path, filename + ".yml")
+  end
+
+  def attribute_token
+    "--- # Soup attributes"
+  end
+
+  def symbolize_keys(hash)
+    hash.inject({}) { |h,(k,v)| h[k.to_sym] = v; h }
+  end
+end

data/lib/soup/empty_class.rb

@@ -1,5 +1,5 @@
 # Based on Builder's BlankSlate object
-module Soup
+class Soup
   class EmptyClass
     instance_methods.each { |m| undef_method(m) unless m =~ /^(__|instance_eval|respond_to\?)/ }
   end

data/lib/soup/snip.rb

@@ -1,148 +1,38 @@
-require 'rubygems'
 require 'soup/empty_class'
 
-# methods called on Tuple:
-# Tuple.for_snip(id)
-# Tuple.find_matching(tuple_name, tuple_value_conditions)
-# Tuple.find_matching_hash(key => value, key2 => value2, ...)
-# Tuple.next_snip_id
-# Tuple#save
-# Tuple#name
-# Tuple#value
-# Tuple#destroy
-
 class Snip < Soup::EmptyClass
+  attr_reader :attributes
   
-  # Returns all snips which match the given criteria, i.e. which have a tuple that
-  # matches the given conditions. For example:
-  #
-  #   Snip.sieve(:created_at, "> '2007-01-01'")
-  #
-  # should return all Snips who have a 'created_at' value greater than '2007-01-01'.
-  #
-  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
-  # with the matching snip_id, gathered into a magical snip.)
-  #
-  def self.find(id)
-    raise "not found" unless (tuples = Soup.tuple_class.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 respond_to?(method)
-    attributes.keys.include?(method.to_s)
+  def initialize(attributes = {}, soup = Soup)
+    @attributes = attributes
+    @soup = soup
   end
-  
+
   def save
-    raise "Saving would be pointless - there's no data!" if @tuples.empty?
-    set_id_if_necessary
-    each_tuple { |t| t.save }
+    @soup << @attributes
     self
   end
-  
+
   def destroy
-    each_tuple { |t| t.destroy }
-  end
-  
-  def reload
-    return self unless self.id
-    replace_tuples(Soup.tuple_class.for_snip(id))
+    @soup.destroy(self.name)
     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}>"
+    "<Snip name:#{self.name}>"
   end
-  
-  def to_yaml(*args)
-    attributes.to_yaml(*args)
+
+  def respond_to?(method)
+    @attributes.keys.include?(method.to_s)
   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
-  
-  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
+    if method.to_s =~ /(.*)=\Z/
+      @attributes[$1.to_sym] = value
     else
-      attributes = {:snip_id => self.id, :name => name.to_s, :value => value}
-      tuple = @tuples[name.to_s] = Soup.tuple_class.new(attributes)
+      @attributes[method]
     end
-    tuple.value
-  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(Soup.tuple_class.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
-  
-end
+end

data/test/soup_test.rb

@@ -0,0 +1,54 @@
+require 'test/unit'
+require 'shoulda'
+require 'soup'
+
+class SoupTest < Test::Unit::TestCase
+
+  context "Given a soup" do
+    setup do
+      @soup = Soup.new(File.join(File.dirname(__FILE__), *%w[.. tmp soup]))
+    end
+
+    should "be able to store content" do
+      @soup << {:name => 'test', :content => "I like stuff, and things"}
+      assert_equal "I like stuff, and things", @soup['test'].content
+    end
+
+    context "when sieving the soup" do
+      setup do
+        @james = @soup << {:name => 'james', :spirit_guide => 'fox', :colour => 'blue', :powers => 'yes'}
+        @murray = @soup << {:name => 'murray', :spirit_guide => 'chaffinch', :colour => 'red', :powers => 'yes'}
+      end
+
+      should "find snips by name if the parameter is a string" do
+        assert_equal @james, @soup['james']
+      end
+
+      should "find snips using exact matching of keys and values if the parameter is a hash" do
+        assert_equal @murray, @soup[:name => 'murray']
+      end
+
+      should "match using all parameters" do
+        assert_equal @james, @soup[:powers => 'yes', :colour => 'red']
+      end
+
+      should "return an array if more than one snip matches" do
+        assert_equal [@james, @murray], @soup[:powers => 'yes']
+      end
+
+      should "return an empty array if no matching snips exist" do
+        assert_equal [], @soup[:powers => 'maybe']
+      end
+    end
+
+    context "when deleting snips" do
+      should "allow deletion of snips" do
+        snip = @soup << {:name => 'test', :content => 'content'}
+        assert_equal snip, @soup['test']
+
+        @soup['test'].destroy
+        assert @soup['test'].nil?
+      end
+    end
+  end
+end

metadata

@@ -1,67 +1,62 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: soup
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
-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: 
+  version: 0.9.9
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - James Adam
-files: 
-- lib/soup/empty_class.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_spec.rb
-- spec/spec_helper.rb
-- spec/spec_runner.rb
-- soup.gemspec
-test_files: []
-
-rdoc_options: []
+autorequire: 
+bindir: bin
+cert_chain: []
 
-extra_rdoc_files: []
+date: 2009-10-12 00:00:00 +01:00
+default_executable: 
+dependencies: []
 
+description: 
+email: james@lazyatom.com
 executables: []
 
 extensions: []
 
+extra_rdoc_files: 
+- README
+files: 
+- Manifest
+- Rakefile
+- README
+- test/soup_test.rb
+- lib/soup/empty_class.rb
+- lib/soup/snip.rb
+- lib/soup.rb
+has_rdoc: true
+homepage: http://lazyatom.com
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+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: []
 
-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: 
+rubyforge_project: soup
+rubygems_version: 1.3.3
+signing_key: 
+specification_version: 3
+summary: A super-simple data store
+test_files: []
+

data/lib/soup/tuples/active_record_tuple.rb

@@ -1,48 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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,68 +0,0 @@
-
-# Gem::Specification for Soup-0.2.1
-# Originally generated by Echoe
-
-Gem::Specification.new do |s|
-  s.name = %q{soup}
-  s.version = "0.2.1"
-  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.homepage = %q{}
-  s.rubyforge_project = %q{soup}
-  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/empty_class.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_spec.rb", "spec/spec_helper.rb", "spec/spec_runner.rb", "soup.gemspec"]
-  s.add_dependency(%q<activerecord>, [">= 2.0.2"])
-end
-
-
-# # Original Rakefile source (requires the Echoe gem):
-# 
-# require 'rubygems'
-# 
-# require 'lib/soup'
-# 
-# begin
-#   require 'echoe'
-# 
-#   Echoe.new("soup", Soup::VERSION) do |soup|
-#     soup.author = ["James Adam"]
-#     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 --prompt simple -rubygems -r ./lib/soup.rb"
-# end
-# 
-# task :default => [:spec, :show_rcov]

data/spec/snip_spec.rb

@@ -1,102 +0,0 @@
-require File.join(File.dirname(__FILE__), "spec_helper")
-
-describe Snip do
-  before(:each) do
-    Soup.base = {:database => "soup_test.db"}
-    Soup.prepare
-    clear_database
-  end
-  
-  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
-
-  describe "when being created with attributes" do
-  
-    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 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 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
-
-  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 not overwrite an existing id created via __id" do
-      @snip = Snip.new(:__id => 100)
-      @snip.name = "something_else"
-      @snip.save
-    
-      other_snip = Soup['something_else']
-      other_snip.id.should == 100
-    end
-  end
-end

data/spec/soup_spec.rb

@@ -1,148 +0,0 @@
-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

@@ -1,8 +0,0 @@
-$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

data/spec/spec_runner.rb

@@ -1,12 +0,0 @@
-#!/usr/bin/env ruby
-
-# We need to do a bit of extra work here, because Snip will undefine a 
-# whole bunch of stuff that spec adds, like the Object#should method.
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
-require 'soup'
-
-# This is basically the contents of rspec's own spec runner. It's just
-# that we needed to require 'soup' before it.
-require 'rubygems'
-require 'spec'
-exit ::Spec::Runner::CommandLine.run(rspec_options)