soup 1.0.3 → 1.0.4

data/Rakefile

@@ -21,7 +21,7 @@ spec = Gem::Specification.new do |s|
   
   # Change these as appropriate
   s.name              = "soup"
-  s.version           = "1.0.3"
+  s.version           = "1.0.4"
   s.summary           = "A super-simple data store"
   s.author            = "James Adam"
   s.email             = "james@lazyatom.com"
@@ -41,7 +41,7 @@ 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("shoulda")
+  s.add_development_dependency("kintama")
 end
 
 # This task actually builds the gem. We also regenerate a static

data/lib/soup/backends/file_backend.rb

@@ -10,12 +10,12 @@ class Soup
       end
 
       def names
-        Dir[path_for("*")].map { |s| File.basename(s, ".snip") }
+        Dir[File.join(@base_path, "*")].map { |s| File.basename(s).split(".").first }
       end
 
       def load_snip(name)
-        path = path_for(name)
-        if File.exist?(path)
+        path = Dir[File.join(@base_path, "*")].find { |s| File.basename(s).split(".").first == name }
+        if path
           file = File.new(path)
           data = file.read
           default_attributes = {:name => name, :updated_at => file.mtime, :created_at => file.mtime}
@@ -27,6 +27,8 @@ class Soup
             attributes = default_attributes
           end
           attributes.update(:content => content) if content && content.length > 0
+          extension = File.extname(path).gsub(/^\./, '')
+          attributes.update(:extension => extension) if extension != "snip"
           Snip.new(attributes, self)
         else
           nil
@@ -34,7 +36,7 @@ class Soup
       end
 
       def save_snip(attributes)
-        File.open(path_for(attributes[:name]), 'w') do |f|
+        File.open(path_for(attributes[:name], attributes[:extension]), 'w') do |f|
           attributes_without_content = attributes.dup
           f.write attributes_without_content.delete(:content)
           f.write attributes_without_content.to_yaml.gsub(/^---\s/, "\n") if attributes_without_content.any?
@@ -54,12 +56,14 @@ class Soup
 
       private
 
-      def path_for(name)
-        File.join(@base_path, name + ".snip")
+      def path_for(name, extension=nil)
+        snip_extension = ".snip"
+        snip_extension += ".#{extension}" if extension
+        File.join(@base_path, name + snip_extension)
       end
 
       def all_snips
-        Dir[path_for("*")].map do |key|
+        Dir[File.join(@base_path, "*")].map do |key|
           load_snip(File.basename(key, ".snip"))
         end
       end

data/test/file_backend_test.rb

@@ -2,15 +2,13 @@ require "test_helper"
 require "ftools"
 require "time"
 
-class FileBackendTest < Test::Unit::TestCase
-  context "The file-based backend" do
-    setup do
-      @base_path = File.join(File.dirname(__FILE__), *%w[.. tmp soup])
-      @soup = Soup.new(Soup::Backends::FileBackend.new(@base_path))
-    end
+context "The file-based backend" do
+  setup do
+    @soup = Soup.new(Soup::Backends::FileBackend.new(@base_path))
+  end
 
-    should "parse attributes from lines starting with colon" do
-      write_snip "snip", %{
+  should "parse attributes from lines starting with colon" do
+    write_snip "snip", %{
 Here is the content
 of the snip
 
@@ -20,49 +18,57 @@ of the snip
   stuff
   things
 :blah: yes
-      }
+    }
 
-      snip = @soup["snip"]
-      assert_equal "Here is the content\nof the snip", snip.content
-      assert_equal "thing", snip.name
-    end
+    snip = @soup["snip"]
+    assert_equal "Here is the content\nof the snip", snip.content
+    assert_equal "thing", snip.name
+  end
 
-    should "write a snip in the simple format" do
-      @soup << {:content => "Here is the content", :name => "dave"}
+  should "write a snip in the simple format" do
+    @soup << {:content => "Here is the content", :name => "dave"}
+    assert_equal %{Here is the content\n\n:name: dave\n}, File.read(path_for("dave"))
+  end
 
-      assert_equal %{Here is the content\n\n:name: dave\n}, File.read(path_for("dave"))
-    end
+  should "not require snip attributes to give content" do
+    write_snip "test", "snip content"
+    assert_equal "snip content", @soup["test"].content
+  end
 
-    should "take name from filename if not supplied" do
-      write_snip "blahface", "The snip content"
-      assert_equal "blahface", @soup["blahface"].name
-    end
+  should "take updated_at and created_at from file timestamps if not supplied" do
+    @soup << {:name => "snip", :content => "whatever"}
+    time = Time.parse("2010-11-04 14:56")
+    File.utime(time, time, path_for("snip"))
+  end
 
-    should "not require snip attributes to give content" do
-      write_snip "test", "snip content"
-      assert_equal "snip content", @soup["test"].content
-    end
+  should "take name from filename if not supplied" do
+    write_snip "blahface", "The snip content"
+    assert_equal "blahface", @soup["blahface"].name
+  end
 
-    should "take updated_at and created_at from file timestamps if not supplied" do
-      @soup << {:name => "snip", :content => "whatever"}
-      time = Time.parse("2010-11-04 14:56")
-      File.utime(time, time, path_for("snip"))
+  should "take updated_at and created_at from file timestamps if not supplied" do
+    @soup << {:name => "snip", :content => "whatever"}
+    time = Time.parse("2010-11-04 14:56")
+    File.utime(time, time, path_for("snip"))
 
-      snip = @soup["snip"]
-      assert_equal time, snip.updated_at
-      assert_equal time, snip.created_at
-    end
+    snip = @soup["snip"]
+    assert_equal time, snip.updated_at
+    assert_equal time, snip.created_at
+  end
 
-    should "take created_at from attributes if supplied" do
-      created_at = Time.parse("2010-11-04 14:56")
-      @soup << {:name => "snip", :content => "whatever", :created_at => created_at}
+  should "take created_at from attributes if supplied" do
+    created_at = Time.parse("2010-11-04 14:56")
+    @soup << {:name => "snip", :content => "whatever", :created_at => created_at}
 
-      snip = @soup["snip"]
-      assert_equal created_at.to_i, snip.created_at.to_i
-    end
+    snip = @soup["snip"]
+    assert_equal created_at.to_i, snip.created_at.to_i
   end
 
-  private
+  should "set the extension attribute if one is present" do
+    File.open(File.join(@base_path, "test_snip.snip.markdown"), "w") { |f| f.write "This is the content" }
+    snip = @soup["test_snip"]
+    assert_equal "markdown", snip.extension
+  end
 
   def path_for(name)
     File.join(@base_path, name + ".snip")

data/test/multi_soup_backend_test.rb

@@ -1,76 +1,73 @@
 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::FileBackend.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
+context "A Soup with multiple backends" do
+  setup do
+    @basic_soup_backend_one = Soup::Backends::YAMLBackend.new(File.join(@base_path, "soup_one"))
+    @basic_soup_backend_two = Soup::Backends::FileBackend.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
 
-    should "return nil when the requested snip is not present in any backend" do
-      assert_nil @soup["snip"]
-    end
+  teardown do
+    FileUtils.rm_rf(@base_path)
+  end
 
-    should "return a snip if any backend contains it" do
-      @soup_one << {:name => "snip", :body => "hello"}
-      assert_equal "hello", @soup["snip"].body
+  should "return nil when the requested snip is not present in any backend" do
+    assert_nil @soup["snip"]
+  end
 
-      @soup_two << {:name => "other_snip", :body => "hi!"}
-      assert_equal "hi!", @soup["other_snip"].body
-    end
+  should "return a snip if any backend contains it" do
+    @soup_one << {:name => "snip", :body => "hello"}
+    assert_equal "hello", @soup["snip"].body
 
-    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
+    @soup_two << {:name => "other_snip", :body => "hi!"}
+    assert_equal "hi!", @soup["other_snip"].body
+  end
 
-      should "load the snip from the backend with the higher precidence" do
-        assert_equal "from soup one", @soup["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
 
-    context "when snips with a certain attribute exist in multiple backends" do
-      setup do
-        @soup_one << {:name => "snip1", :active => true}
-        @soup_two << {:name => "snip2", :active => true}
-      end
+    should "load the snip from the backend with the higher precidence" do
+      assert_equal "from soup one", @soup["snip"].body
+    end
+  end
 
-      should "find matching snips from all backends" do
-        assert_equal 2, @soup[:active => true].length
-      end
+  context "when snips with a certain attribute exist in multiple backends" do
+    setup do
+      @soup_one << {:name => "snip1", :active => true}
+      @soup_two << {:name => "snip2", :active => true}
     end
 
-    should "save snips" do
-      @soup << {:name => "snip", :body => "bad snip"}
-      @soup.destroy("snip")
-      assert_nil @soup["snip"]
+    should "find matching snips from all backends" do
+      assert_equal 2, @soup[:active => true].length
     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
+  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
+    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

data/test/snip_test.rb

@@ -1,41 +1,38 @@
 require 'test_helper'
 
-class SnipTest < Test::Unit::TestCase
-  context "A snip" do
-    setup do
-      @snip = Soup::Snip.new({:name => "james", :content => "is awesome"}, nil)
-    end
+context "A snip" do
+  setup do
+    @snip = Soup::Snip.new({:name => "james", :content => "is awesome"}, nil)
+  end
 
-    should "be equal to another snip with the same attributes" do
-      other_snip = Soup::Snip.new({:name => "james", :content => "is awesome"}, nil)
-      assert other_snip == @snip
-    end
+  should "be equal to another snip with the same attributes" do
+    other_snip = Soup::Snip.new({:name => "james", :content => "is awesome"}, nil)
+    assert other_snip == @snip
+  end
 
-    should "not be equal to another snip with differing attributes" do
-      other_snip = Soup::Snip.new({:name => "james", :content => "is really awesome"}, nil)
-      assert other_snip != @snip
-    end
+  should "not be equal to another snip with differing attributes" do
+    other_snip = Soup::Snip.new({:name => "james", :content => "is really awesome"}, nil)
+    assert other_snip != @snip
+  end
 
-    should "be comparable in arrays" do
-      other_snip = Soup::Snip.new({:name => "james", :content => "is awesome"}, nil)
-      assert [@snip] == [other_snip]
-    end
+  should "be comparable in arrays" do
+    other_snip = Soup::Snip.new({:name => "james", :content => "is awesome"}, nil)
+    assert [@snip] == [other_snip]
+  end
 
-    context "loaded from the soup" do
-      setup do
-        @base_path = File.join(File.dirname(__FILE__), *%w[.. tmp soup])
-        backend = Soup::Backends::FileBackend.new(@base_path)
-        @soup = Soup.new(backend)
-      end
+  context "loaded from the soup" do
+    setup do
+      backend = Soup::Backends::FileBackend.new(@base_path)
+      @soup = Soup.new(backend)
+    end
 
-      teardown do
-        FileUtils.rm_rf(@base_path)
-      end
+    teardown do
+      FileUtils.rm_rf(@base_path)
+    end
 
-      should "ignore empty content when comparing" do
-        @soup << {:name => 'test'}
-        assert_equal Soup::Snip.new({:name => 'test'}, nil), @soup['test']
-      end
+    should "ignore empty content when comparing" do
+      @soup << {:name => 'test'}
+      assert_equal Soup::Snip.new({:name => 'test'}, nil), @soup['test']
     end
   end
 end

data/test/soup_test.rb

@@ -1,71 +1,68 @@
 require "test_helper"
 
-class SoupTest < Test::Unit::TestCase
-
-  def self.each_backend(&block)
-    base_path = File.join(File.dirname(__FILE__), *%w[.. tmp soup])
-    backends = [
-      yaml_backend = Soup::Backends::YAMLBackend.new(base_path),
-      file_backend = Soup::Backends::FileBackend.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
+def each_backend(&block)
+  base_path = File.join(File.dirname(__FILE__), *%w[.. tmp soup])
+  backends = [
+    yaml_backend = Soup::Backends::YAMLBackend.new(base_path),
+    file_backend = Soup::Backends::FileBackend.new(base_path),
+    Soup::Backends::MultiSoup.new(yaml_backend)
+  ]
+  backends.each do |backend|
+    describe backend.class do
+      setup do
+        @soup = Soup.new(backend)
+      end
+      teardown do
+        FileUtils.rm_rf(base_path)
       end
+      instance_eval(&block)
     end
   end
+end
 
-  each_backend do
-    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
+each_backend do
+  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
 
-    should "return a snip when storing content" do
-      snip = @soup << {:name => 'test', :content => "I like stuff, and things"}
-      assert_equal "I like stuff, and things", snip.content
-    end
+  should "return a snip when storing content" do
+    snip = @soup << {:name => 'test', :content => "I like stuff, and things"}
+    assert_equal "I like stuff, and things", snip.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
+  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 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 "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 [@murray], @soup[:powers => 'yes', :colour => 'red']
-      end
+    should "match using all parameters" do
+      assert_equal [@murray], @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 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
+    should "return an empty array if no matching snips exist" do
+      assert_equal [], @soup[:powers => 'maybe']
     end
+  end
 
-    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

@@ -1,3 +1,8 @@
-require 'test/unit'
-require 'shoulda'
-require 'soup'
+# require 'rubygems'
+$LOAD_PATH.unshift "/Users/james/Code/lazyatom/jtest/lib"
+require 'kintama'
+require 'soup'
+
+Kintama.setup do
+  @base_path = File.join(File.dirname(__FILE__), *%w[.. tmp soup])
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: soup
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 31
   prerelease: 
   segments: 
   - 1
   - 0
-  - 3
-  version: 1.0.3
+  - 4
+  version: 1.0.4
 platform: ruby
 authors: 
 - James Adam
@@ -15,11 +15,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-22 00:00:00 +00:00
+date: 2011-03-01 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: shoulda
+  name: kintama
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false