soup 0.9.9.2 → 0.9.10

data/README

@@ -4,26 +4,25 @@ and will often talk to you, but when you look closely, they don't exist.
 Terrifying. And so:
 
   require 'soup'
-  Soup.prepare
+  soup = Soup.new(File.join("soup", __FILE__))
 
-  
-  Soup << { 
+  soup << { 
     :name => "James",
     :skills => "Bowstaff, nunchuck" 
   }
-  
+
   # ...much later...
-  
-  s = Soup['james']
+
+  s = soup['james']
   s.skills # => "Bowstaff, nunchuck"
-  
-  Soup << {
+
+  soup << {
     :mane => "Lush and thick"
     :teeth => "Sharp and ready"
     :position => "Above my bed!!!" 
   }
 
-  
+
 The point is that you can set any attribute on a Soup data, and it will be persisted without 
 care. With reckless abandon, really.
 

data/Rakefile

@@ -7,6 +7,7 @@ task :default => :test
 require "rake/testtask"
 Rake::TestTask.new do |t|
   t.libs << "test"
+  t.ruby_opts << "-rubygems"
   t.test_files = FileList["test/**/*_test.rb"]
   t.verbose = true
 end
@@ -20,7 +21,7 @@ spec = Gem::Specification.new do |s|
   
   # Change these as appropriate
   s.name              = "soup"
-  s.version           = "0.9.9.2"
+  s.version           = "0.9.10"
   s.summary           = "A super-simple data store"
   s.author            = "James Adam"
   s.email             = "james@lazyatom.com"
@@ -40,25 +41,25 @@ spec = Gem::Specification.new do |s|
   # 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"
+  s.add_development_dependency("shoulda")
 end
 
-# This task actually builds the gem. We also regenerate a static 
+# 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.
+end
+
+desc "Build the gemspec file #{spec.name}.gemspec"
+task :gemspec do
   file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
   File.open(file, "w") {|f| f << spec.to_ruby }
 end
 
+task :package => :gemspec
+
 # Generate documentation
 Rake::RDocTask.new do |rd|
   rd.main = "README"
@@ -70,46 +71,3 @@ 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

@@ -1,12 +1,12 @@
 # Let us require stuff in lib without saying lib/ all the time
 $LOAD_PATH.unshift(File.dirname(__FILE__)).uniq!
 
-require 'soup/snip'
 require 'yaml'
 require 'fileutils'
 
 class Soup
-  VERSION = "0.9.9"
+  autoload :Backends, 'soup/backends'
+  autoload :Snip, 'soup/snip'
 
   # You can access a default soup using this methods.
 
@@ -22,7 +22,7 @@ class Soup
     default_instance << attributes
   end
 
-  def self.sieve(*args)
+  def self.with(*args)
     default_instance.sieve(*args)
   end
 
@@ -30,22 +30,20 @@ class Soup
     default_instance.destroy(*args)
   end
 
-  attr_reader :base_path
-
   # Get the soup ready!
-  def initialize(base_path=nil)
-    @base_path = base_path || "soup"
-    FileUtils.mkdir_p(base_path)
+  def initialize(backend=nil)
+    @backend = backend || Soup::Backends::YAMLBackend.new
+    @backend.prepare
   end
 
   # The main interface
   # ==================
 
-  # A shorthand for #sieve, with the addition that only a name may be
-  # supplied (i.e. Soup['my snip'])
+  # A shorthand for #with, 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)
+    with(conditions)
   end
 
   # Puts some data into the soup, and returns an object that contains
@@ -53,72 +51,23 @@ class Soup
   # attributes as if they were defined using attr_accessor on the object's
   # class.
   def <<(attributes)
-    save_snip(attributes)
-    Snip.new(attributes, self)
+    @backend.save_snip(symbolize_keys(attributes))
   end
 
   # 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
-      all_snips.select do |s|
-        conditions.inject(true) do |matches, (key, value)|
-          matches && (s.__send__(key) == value)
-        end
-      end
-    end
+  def with(conditions)
+    @backend.find(symbolize_keys(conditions))
   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
+    @backend.destroy(name)
   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) if attributes.any?
-    end
-  end
-
-  def load_snip(name)
-    path = path_for(name)
-    if File.exist?(path)
-      file = File.read(path)
-      if attribute_start = file.index(attribute_token)
-        content = file.slice(0...attribute_start)
-        attributes = {:name => name}.merge(YAML.load(file.slice(attribute_start..-1)).merge(:content => content))
-      else
-        attributes = {:content => file, :name => name}
-      end
-      Snip.new(attributes, self)
-    else
-      nil
-    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

data/lib/soup/backends.rb

@@ -0,0 +1,13 @@
+class Soup
+  # Backends should implement (or delegate) the following API:
+  # * #prepare - will be called when a Soup is created
+  # * #names - should return the names of all snips contained
+  # * #load_snip(name) - should return a Soup::Snip, or nil if it couldn't be loaded
+  # * #save_snip(attribute_hash) - should store and return a Soup::Snip, or nil if it couldn't be saved
+  # * #destroy(name) - should return true if the snip was removed, or false if otherwise
+  module Backends
+    autoload :YAMLBackend, 'soup/backends/yaml_backend'
+    autoload :MultiSoup, 'soup/backends/multi_soup'
+    autoload :ReadOnly, 'soup/backends/read_only'
+  end
+end

data/lib/soup/backends/multi_soup.rb

@@ -0,0 +1,22 @@
+class Soup
+  module Backends
+    class MultiSoup
+      def initialize(*backends)
+        @backends = backends
+      end
+
+      def prepare
+        @backends.each { |b| b.prepare }
+      end
+
+      def method_missing(*args)
+        @backends.each do |backend|
+          if result = backend.__send__(*args)
+            return result
+          end
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/soup/backends/read_only.rb

@@ -0,0 +1,17 @@
+class Soup
+  module Backends
+    class ReadOnly
+      def initialize(backend)
+        @backend = backend
+      end
+
+      def save_snip(*args)
+        false
+      end
+
+      def method_missing(*args)
+        @backend.__send__(*args)
+      end
+    end
+  end
+end

data/lib/soup/backends/yaml_backend.rb

@@ -0,0 +1,78 @@
+class Soup
+  module Backends
+    class YAMLBackend
+      ATTRIBUTE_TOKEN = "--- # Soup attributes"
+
+      def initialize(path="soup")
+        @base_path = path
+      end
+
+      def prepare
+        FileUtils.mkdir_p(@base_path)
+      end
+
+      def names
+        Dir[path_for("*")].map { |s| File.basename(s, ".yml") }
+      end
+
+      def find(conditions)
+        if conditions.keys == [:name]
+          load_snip(conditions[:name])
+        else
+          all_snips.select do |s|
+            conditions.inject(true) do |matches, (key, value)|
+              matches && (s.__send__(key) == value)
+            end
+          end
+        end
+      end
+
+      def load_snip(name)
+        path = path_for(name)
+        if File.exist?(path)
+          file = File.read(path)
+          if attribute_start = file.index(ATTRIBUTE_TOKEN)
+            content = file.slice(0...attribute_start)
+            attributes = {:name => name}.merge(YAML.load(file.slice(attribute_start..-1)).merge(:content => content))
+          else
+            attributes = {:content => file, :name => name}
+          end
+          Snip.new(attributes, self)
+        else
+          nil
+        end
+      end
+
+      def save_snip(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) if attributes.any?
+        end
+        Snip.new(attributes, self)
+      end
+
+      def destroy(name)
+        path = path_for(name)
+        if File.exist?(path)
+          File.delete(path)
+          true
+        else
+          nil
+        end
+      end
+
+      private
+
+      def path_for(name)
+        File.join(@base_path, name + ".yml")
+      end
+
+      def all_snips
+        Dir[path_for("*")].map do |key|
+          load_snip(File.basename(key, ".yml"))
+        end
+      end
+    end
+  end
+end

data/lib/soup/snip.rb

@@ -1,38 +1,39 @@
 require 'soup/empty_class'
 
-class Snip < Soup::EmptyClass
-  attr_reader :attributes
-  
-  def initialize(attributes = {}, soup = Soup)
-    @attributes = attributes
-    @soup = soup
-  end
+class Soup
+  class Snip < Soup::EmptyClass
+    attr_reader :attributes
 
-  def save
-    @soup << @attributes
-    self
-  end
+    def initialize(attributes, backend)
+      @attributes = attributes
+      @backend = backend
+    end
 
-  def destroy
-    @soup.destroy(self.name)
-    self
-  end
+    def save
+      @backend.save_snip(@attributes)
+      self
+    end
 
-  def inspect
-    "<Snip name:#{self.name}>"
-  end
+    def destroy
+      @backend.destroy(self.name)
+      self
+    end
 
-  def respond_to?(method)
-    @attributes.keys.include?(method.to_s)
-  end
+    def inspect
+      "<Snip name:#{self.name}>"
+    end
 
-  def method_missing(method, *args)
-    value = args.length > 1 ? args : args.first
-    if method.to_s =~ /(.*)=\Z/
-      @attributes[$1.to_sym] = value
-    else
-      @attributes[method]
+    def respond_to?(method)
+      @attributes.keys.include?(method.to_s)
     end
-  end
 
+    def method_missing(method, *args)
+      value = args.length > 1 ? args : args.first
+      if method.to_s =~ /(.*)=\Z/
+        @attributes[$1.to_sym] = value
+      else
+        @attributes[method]
+      end
+    end
+  end
 end

data/test/multi_soup_backend_test.rb

@@ -0,0 +1,65 @@
+require "test_helper"
+
+class MultiSoupBackendTest < Test::Unit::TestCase
+  context "A Soup with multiple backends" do
+    setup do
+      @base_path = File.join(File.dirname(__FILE__), *%w[.. tmp soup])
+      @basic_soup_backend_one = Soup::Backends::YAMLBackend.new(File.join(@base_path, "soup_one"))
+      @basic_soup_backend_two = Soup::Backends::YAMLBackend.new(File.join(@base_path, "soup_two"))
+      @soup_one = Soup.new(@basic_soup_backend_one)
+      @soup_two = Soup.new(@basic_soup_backend_two)
+      multi_soup_backend = Soup::Backends::MultiSoup.new(@basic_soup_backend_one, @basic_soup_backend_two)
+      @soup = Soup.new(multi_soup_backend)
+    end
+
+    teardown do
+      FileUtils.rm_rf(@base_path)
+    end
+
+    should "return nil when the requested snip is not present in any backend" do
+      assert_nil @soup["snip"]
+    end
+
+    should "return a snip if any backend contains it" do
+      @soup_one << {:name => "snip", :body => "hello"}
+      assert_equal "hello", @soup["snip"].body
+
+      @soup_two << {:name => "other_snip", :body => "hi!"}
+      assert_equal "hi!", @soup["other_snip"].body
+    end
+
+    context "when snips of the same name exist in multiple backends" do
+      setup do
+        @soup_one << {:name => "snip", :body => "from soup one"}
+        @soup_two << {:name => "snip", :body => "from soup two"}
+      end
+
+      should "load the snip from the backend with the higher precidence" do
+        assert_equal "from soup one", @soup["snip"].body
+      end
+    end
+
+    should "save snips" do
+      @soup << {:name => "snip", :body => "bad snip"}
+      @soup.destroy("snip")
+      assert_nil @soup["snip"]
+    end
+
+    context "when a backend is read-only" do
+      setup do
+        readonly_backend = Soup::Backends::ReadOnly.new(@basic_soup_backend_one)
+        @soup_one = Soup.new(readonly_backend)
+        @soup_two = Soup.new(@basic_soup_backend_two)
+        multi_soup_backend = Soup::Backends::MultiSoup.new(readonly_backend, @basic_soup_backend_two)
+        @soup = Soup.new(multi_soup_backend)
+      end
+
+      should "store snips in the writeable backend" do
+        @soup << {:name => "snip", :body => "hello"}
+        assert_equal "hello", @soup["snip"].body
+        assert_nil @soup_one["snip"]
+        assert_not_nil @soup_two["snip"]
+      end
+    end
+  end
+end

data/test/soup_test.rb

@@ -1,14 +1,27 @@
-require 'test/unit'
-require 'shoulda'
-require 'soup'
+require "test_helper"
 
 class SoupTest < Test::Unit::TestCase
 
-  context "Given a soup" do
-    setup do
-      @soup = Soup.new(File.join(File.dirname(__FILE__), *%w[.. tmp soup]))
+  def self.each_backend(&block)
+    base_path = File.join(File.dirname(__FILE__), *%w[.. tmp soup])
+    backends = [
+      yaml_backend = Soup::Backends::YAMLBackend.new(base_path),
+      Soup::Backends::MultiSoup.new(yaml_backend)
+    ]
+    backends.each do |backend|
+      context "The #{backend.class.name} Soup backend" do
+        setup do
+          @soup = Soup.new(backend)
+        end
+        teardown do
+          FileUtils.rm_rf(base_path)
+        end
+        yield backend
+      end
     end
+  end
 
+  each_backend do |backend|
     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
@@ -41,14 +54,12 @@ class SoupTest < Test::Unit::TestCase
       end
     end
 
-    context "when deleting snips" do
-      should "allow deletion of snips" do
-        snip = @soup << {:name => 'test', :content => 'content'}
-        assert_equal snip, @soup['test']
+    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
+      @soup['test'].destroy
+      assert @soup['test'].nil?
     end
   end
 end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'test/unit'
+require 'shoulda'
+require 'soup'

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: soup
 version: !ruby/object:Gem::Version 
-  version: 0.9.9.2
+  prerelease: false
+  segments: 
+  - 0
+  - 9
+  - 10
+  version: 0.9.10
 platform: ruby
 authors: 
 - James Adam
@@ -9,10 +14,21 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-16 00:00:00 +00:00
+date: 2010-05-30 00:00:00 +02:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
 description: 
 email: james@lazyatom.com
 executables: []
@@ -25,7 +41,13 @@ files:
 - Manifest
 - Rakefile
 - README
+- test/multi_soup_backend_test.rb
 - test/soup_test.rb
+- test/test_helper.rb
+- lib/soup/backends/multi_soup.rb
+- lib/soup/backends/read_only.rb
+- lib/soup/backends/yaml_backend.rb
+- lib/soup/backends.rb
 - lib/soup/empty_class.rb
 - lib/soup/snip.rb
 - lib/soup.rb
@@ -43,18 +65,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
-rubyforge_project: soup
-rubygems_version: 1.3.5
+rubyforge_project: 
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: A super-simple data store