doc_storage 0.9

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 David Majda
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,123 @@
+= DocStorage
+
+http://github.com/dmajda/doc_storage
+
+DocStorage is a simple Ruby library for manipulating documents containing a text
+and metadata. These documents can be used to implement a blog, wiki, or similar
+application without a relational database.
+
+The library distinguishes between <em>simple documents</em> and <em>multipart
+documents</em>. A simple document looks like a RFC 822 message and it is
+suitable for storing a text associated with some metadata (e.g. a blog article
+with a title and a publication date). A multipart document is loosely based on
+the MIME multipart message format and allows storing multiple simple documents
+(e.g. blog comments, each with an author and a publication date) in one file.
+
+== Document Format
+
+A simple document looks like this:
+
+  Title: My blog article
+  Datetime: 2009-11-01 18:03:27
+
+  Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc vel lorem
+  massa. Sed blandit orci id leo blandit ut fermentum lacus ullamcorper.
+  Suspendisse metus sapien, consectetur vitae imperdiet vel, ornare a metus.
+  In imperdiet euismod mi, nec volutpat lorem porta id.
+
+
+A multipart document looks like this:
+
+  Boundary: =====
+  
+  --=====
+  Author: Fan
+  Datetime: 2009-11-01 20:07:15
+  
+  Your article is really great!
+  --=====
+  Author: Critic
+  Datetime: 2009-11-01 20:10:54
+  
+  Your article sucks!
+
+See the documentation of <tt>DocStorage::SimpleDocument</tt> and
+<tt>DocStorage::MultiPartDocument</tt> classes for more formal format
+description.
+
+== Installation
+
+  sudo gem install doc_storage --source http://gemcutter.org
+
+== Example Usage
+
+=== Simple Documents
+
+  require "lib/doc_storage"
+  
+  # Create a new document with headers and body
+  document = DocStorage::SimpleDocument.new(
+    {
+      "Title"    => "Finishing the documentation",
+      "Priority" => "urgent"
+    },
+    "We should finish the documentation ASAP."
+  )
+  
+  # Parse a file
+  document = File.open("examples/simple.txt", "r") do |f|
+    DocStorage::SimpleDocument.parse(f)
+  end
+  
+  # Document manipulation
+  document.headers["Tags"] = "example"
+  document.body += "Nulla mi dui, pellentesque et accumsan vitae, mattis et velit."
+  
+  # Save the modified document
+  File.open("examples/simple_modified.txt", "w") do |f|
+    f.write(document)
+  end
+
+=== Multipart Documents
+  require "lib/doc_storage"
+  
+  # Create a new document with two parts
+  document = DocStorage::MultiPartDocument.new([
+    DocStorage::SimpleDocument.new(
+      {
+        "Title"    => "Finishing the documentation",
+        "Priority" => "urgent"
+      },
+      "We should finish the documentation ASAP."
+    ),
+    DocStorage::SimpleDocument.new(
+      {
+        "Title"    => "Finishing the code",
+        "Priority" => "more urgent"
+      },
+      "But we should finish the code first!"
+    ),
+  ])
+  
+  # Parse a file
+  document = File.open("examples/multipart.txt", "r") do |f|
+    DocStorage::MultiPartDocument.parse(f)
+  end
+  
+  # Document manipulation
+  document.parts << DocStorage::SimpleDocument.new(
+    {
+      "Author"   => "Middle man",
+      "Datetime" => "2009-11-01 21:15:33",
+    },
+    "I think your article is neither good nor bad."
+  )
+  
+  # Save the modified document
+  File.open("examples/multipart_modified.txt", "w") do |f|
+    f.write(document)
+  end
+
+== Author
+
+DocStorage was brought to you by David Majda (david@majda.cz[mailto:david@majda.cz], www.majda.cz).

data/Rakefile

@@ -0,0 +1,46 @@
+require "rake/gempackagetask"
+require "rake/rdoctask"
+require "spec/rake/spectask"
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ["--color", "--format", "nested"]
+end
+
+Rake::RDocTask.new do |t|
+  t.main = "README.rdoc"
+  t.rdoc_dir = "doc"
+  t.rdoc_files.add("README.rdoc", "lib/**/*.rb")
+end
+
+specification = Gem::Specification.new do |s|
+  s.name = "doc_storage"
+  s.version = "0.9"
+  s.summary = "Simple Ruby library for manipulating documents containing a " +
+              "text and metadata."
+  s.description = "DocStorage is a simple Ruby library for manipulating " +
+                  "documents containing a text and metadata. These documents " +
+                  "can be used to implement a blog, wiki, or similar " +
+                  "application without a relational database."
+  s.required_ruby_version = ">= 1.8.6"
+
+  s.author = "David Majda"
+  s.email = "david@majda.cz"
+  s.homepage = "http://github.com/dmajda/doc_storage"
+
+  s.files = FileList[
+              "Rakefile",
+              "README.rdoc",
+              "LICENSE",
+              "VERSION",
+              Dir["lib/**/*.rb"],
+              Dir["spec/**/*.rb"],
+              Dir["examples/**/*"]
+            ]
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.rdoc"]
+  s.rdoc_options = ["--main", "README.rdoc"]
+end
+
+Rake::GemPackageTask.new(specification) do |t|
+end

data/VERSION

@@ -0,0 +1 @@
+0.9

data/examples/multipart.rb

@@ -0,0 +1,40 @@
+dir = File.dirname(__FILE__)
+
+require "#{dir}/../lib/doc_storage"
+
+# Create a new document with two parts
+document = DocStorage::MultiPartDocument.new([
+  DocStorage::SimpleDocument.new(
+    {
+      "Title"    => "Finishing the documentation",
+      "Priority" => "urgent"
+    },
+    "We should finish the documentation ASAP."
+  ),
+  DocStorage::SimpleDocument.new(
+    {
+      "Title"    => "Finishing the code",
+      "Priority" => "more urgent"
+    },
+    "But we should finish the code first!"
+  ),
+])
+
+# Parse a file
+document = File.open("#{dir}/multipart.txt", "r") do |f|
+  DocStorage::MultiPartDocument.parse(f)
+end
+
+# Document manipulation
+document.parts << DocStorage::SimpleDocument.new(
+  {
+    "Author"   => "Middle man",
+    "Datetime" => "2009-11-01 21:15:33",
+  },
+  "I think your article is neither good nor bad."
+)
+
+# Save the modified document
+File.open("#{dir}/multipart_modified.txt", "w") do |f|
+  f.write(document)
+end

data/examples/multipart.txt

@@ -0,0 +1,12 @@
+Boundary: =====
+
+--=====
+Author: Fan
+Datetime: 2009-11-01 20:07:15
+
+Your article is really great!
+--=====
+Author: Critic
+Datetime: 2009-11-01 20:10:54
+
+Your article sucks!

data/examples/simple.rb

@@ -0,0 +1,26 @@
+dir = File.dirname(__FILE__)
+
+require "#{dir}/../lib/doc_storage"
+
+# Create a new document with headers and body
+document = DocStorage::SimpleDocument.new(
+  {
+    "Title"    => "Finishing the documentation",
+    "Priority" => "urgent"
+  },
+  "We should finish the documentation ASAP."
+)
+
+# Parse a file
+document = File.open("#{dir}/simple.txt", "r") do |f|
+  DocStorage::SimpleDocument.parse(f)
+end
+
+# Document manipulation
+document.headers["Tags"] = "example"
+document.body += "Nulla mi dui, pellentesque et accumsan vitae, mattis et velit."
+
+# Save the modified document
+File.open("#{dir}/simple_modified.txt", "w") do |f|
+  f.write(document)
+end

data/examples/simple.txt

@@ -0,0 +1,7 @@
+Title: My blog article
+Datetime: 2009-11-01 18:03:27
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc vel lorem
+massa. Sed blandit orci id leo blandit ut fermentum lacus ullamcorper.
+Suspendisse metus sapien, consectetur vitae imperdiet vel, ornare a metus.
+In imperdiet euismod mi, nec volutpat lorem porta id.

data/lib/doc_storage/multi_part_document.rb

@@ -0,0 +1,141 @@
+module DocStorage
+  # The +MultiPartDocument+ class represents a document consisting of several
+  # simple documents (see the +SimpleDocument+ class documentation for a
+  # description), loosely based on the MIME multipart message format. It is
+  # suitable for storing multiple documents containing a text associated with
+  # some metadata (e.g. blog comments, each with an author and a publication
+  # date). The +MultiPartDocument+ class allows to create the document
+  # programatically, parse it from a file, manipulate its structure and save it
+  # to a file.
+  #
+  # == Document Format
+  #
+  # In serialized form, a multipart document looks like this:
+  #
+  #   Boundary: =====
+  #
+  #   --=====
+  #   Author: Fan
+  #   Datetime: 2009-11-01 20:07:15
+  #
+  #   Your article is really great!
+  #   --=====
+  #   Author: Critic
+  #   Datetime: 2009-11-01 20:10:54
+  #
+  #   Your article sucks!
+  #
+  # The document is composed of one or more simple documents, separated by a
+  # _boundary_ --  a line beginning with "--" and containing a predefined
+  # <em>boundary string</em>. The first document is a _prologue_ and it defines
+  # the boundary string (without the "--" prefix) in its "Boundary" header. All
+  # other headers of the prologue are ignored and so is its body. Remaining
+  # documents are the _parts_ of the multipart document. Documents without any
+  # parts are perfectly legal, however the prologue with the boundary definition
+  # must be always present.
+  #
+  # == Example Usage
+  #
+  #   require "lib/doc_storage"
+  #
+  #   # Create a new document with two parts
+  #   document = DocStorage::MultiPartDocument.new([
+  #     DocStorage::SimpleDocument.new(
+  #       {
+  #         "Title"    => "Finishing the documentation",
+  #         "Priority" => "urgent"
+  #       },
+  #       "We should finish the documentation ASAP."
+  #     ),
+  #     DocStorage::SimpleDocument.new(
+  #       {
+  #         "Title"    => "Finishing the code",
+  #         "Priority" => "more urgent"
+  #       },
+  #       "But we should finish the code first!"
+  #     ),
+  #   ])
+  #
+  #   # Parse a file
+  #   document = File.open("examples/multipart.txt", "r") do |f|
+  #     DocStorage::MultiPartDocument.parse(f)
+  #   end
+  #
+  #   # Document manipulation
+  #   document.parts << DocStorage::SimpleDocument.new(
+  #     {
+  #       "Author"   => "Middle man",
+  #       "Datetime" => "2009-11-01 21:15:33",
+  #     },
+  #     "I think your article is neither good nor bad."
+  #   )
+  #
+  #   # Save the modified document
+  #   File.open("examples/multipart_modified.txt", "w") do |f|
+  #     f.write(document)
+  #   end
+  class MultiPartDocument
+    # document parts (+Array+ of <tt>DocStorage::SimpleDocument</tt>)
+    attr_accessor :parts
+
+    class << self
+      private
+        def parse_from_io(io)
+          prologue = SimpleDocument.parse(io, :detect)
+          boundary = prologue.headers["Boundary"]
+
+          parts = []
+          until io.eof?
+            parts << SimpleDocument.parse(io, boundary)
+          end
+
+          MultiPartDocument.new(parts)
+        end
+
+      public
+        # Parses a multipart document from its serialized form and returns a new
+        # +MultiPartDocument+ instance.
+        #
+        # The +source+ can be either an +IO+-like object or a +String+. In the
+        # latter case, it is assumed that the string contains a serialized
+        # document (not a file name).
+        #
+        # If any syntax error occurs, a +SyntaxError+ exception is raised. This
+        # can happen when parsing the prologue or parts and an invalid header is
+        # encountered, the headers are not terminated (no empty line separating
+        # headers and body is parsed before the end of file) or if no "Boundary"
+        # header is found in the prologue.
+        #
+        # See the +MultiPartDocument+ class documentation for a detailed
+        # document format description.
+        def parse(source)
+          parse_from_io(source.is_a?(String) ? StringIO.new(source) : source)
+        end
+    end
+
+    # Creates a new +MultiPartDocument+ with given parts.
+    def initialize(parts)
+      @parts = parts
+    end
+
+    # Tests if two documents are equal, i.e. whether they have the same class
+    # and equal parts (in the <tt>==</tt> sense).
+    def ==(other)
+      other.instance_of?(self.class) && @parts == other.parts
+    end
+
+    # Returns string representation of this document. The result is in format
+    # described in the +MultiPartDocument+ class documentation.
+    def to_s
+      # The boundary is just a random string. We do not check if the boudnary
+      # appears anywhere in the subdocuments, which may lead to malformed
+      # document.  This is of course principially wrong, but the probability of
+      # collision is so small that it does not bother me much.
+      chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
+      boundary = Array.new(64) { chars[rand(chars.length)] }.join("")
+
+      SimpleDocument.new({"Boundary" => boundary}, "").to_s +
+        @parts.map { |part| "--#{boundary}\n#{part.to_s}" }.join("\n")
+    end
+  end
+end

data/lib/doc_storage/simple_document.rb

@@ -0,0 +1,189 @@
+module DocStorage
+  # The +SimpleDocument+ class represents a simple RFC 822-like document,
+  # suitable for storing a text associated with some metadata (e.g. a blog
+  # article with a title and a publication date). The +SimpleDocument+ class
+  # allows to create the document programatically, parse it from a file,
+  # manipulate its structure and save it to a file.
+  #
+  # Each document consist of _headers_ and a _body_. Headers are a dictionary,
+  # mapping string names to string values. Body is a free-form text. The header
+  # names can contain only alphanumeric characters and a hyphen ("-") and they
+  # are case sensitive. The header values can contain any text that does not
+  # begin with whitespace and does not contain a CR or LF character.
+  #
+  # == Document Format
+  #
+  # In serialized form, a simple document looks like this:
+  #
+  #   Title: My blog article
+  #   Datetime: 2009-11-01 18:03:27
+  #
+  #   Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc vel lorem
+  #   massa. Sed blandit orci id leo blandit ut fermentum lacus ullamcorper.
+  #   Suspendisse metus sapien, consectetur vitae imperdiet vel, ornare a metus.
+  #   In imperdiet euismod mi, nec volutpat lorem porta id.
+  #
+  # The headers are first, each on its own line. The header names are separated
+  # from values by a colon (":") and any amount of whitespace. Duplicate headers
+  # are allowed with later value overwriting the earlier one. Otherwise, the
+  # order of the headers does not matter. The body is separated from the headers
+  # by an empty line.
+  #
+  # Documents without any headers are perfectly legal and so are documents with
+  # an empty body. However, the separating line must be always present. This
+  # means that an empty file is not a valid document, but a file containing a
+  # single newline is.
+  #
+  # == Example Usage
+  #
+  #   require "lib/doc_storage"
+  #
+  #   # Create a new document with headers and body
+  #   document = DocStorage::SimpleDocument.new(
+  #     {
+  #       "Title"    => "Finishing the documentation",
+  #       "Priority" => "urgent"
+  #     },
+  #     "We should finish the documentation ASAP."
+  #   )
+  #
+  #   # Parse a file
+  #   document = File.open("examples/simple.txt", "r") do |f|
+  #     DocStorage::SimpleDocument.parse(f)
+  #   end
+  #
+  #   # Document manipulation
+  #   document.headers["Tags"] = "example"
+  #   document.body += "Nulla mi dui, pellentesque et accumsan vitae, mattis et velit."
+  #
+  #   # Save the modified document
+  #   File.open("examples/simple_modified.txt", "w") do |f|
+  #     f.write(document)
+  #   end
+  class SimpleDocument
+    # document headers (+Hash+)
+    attr_accessor :headers
+    # document body (+String+)
+    attr_accessor :body
+
+    class << self
+      private
+        def parse_headers(io, detect_boundary)
+          result = {}
+          headers_terminated = false
+
+          until io.eof?
+            line = io.readline
+            case line
+              when /^([a-zA-Z0-9-]+):\s(.*)\n$/
+                result[$1] = $2
+              when "\n"
+                headers_terminated = true
+                break
+              else
+                raise SyntaxError, "Invalid header: \"#{line.strip}\"."
+            end
+          end
+
+          raise SyntaxError, "Unterminated headers." unless headers_terminated
+          if detect_boundary && !result.has_key?("Boundary")
+            raise SyntaxError, "No boundary defined."
+          end
+
+          result
+        end
+
+        def parse_body(io, boundary)
+          if boundary
+            result = ""
+            until io.eof?
+              line = io.readline
+              if line == "--#{boundary}\n"
+                # Trim last newline from the body as it belongs to the boudnary
+                # logically. This behavior is implemented to allow bodies with
+                # no trailing newline).
+                return result[0..-2]
+              end
+
+              result += line
+            end
+            result
+          else
+            io.read
+          end
+        end
+
+        def parse_from_io(io, boundary)
+          headers = parse_headers(io, boundary == :detect)
+          boundary = headers["Boundary"] if boundary == :detect
+          body = parse_body(io, boundary)
+
+          SimpleDocument.new(headers, body)
+        end
+
+      public
+        # Parses a simple document from its serialized form and returns a new
+        # +SimpleDocument+ instance.
+        #
+        # The +source+ can be either an +IO+-like object or a +String+. In the
+        # latter case, it is assumed that the string contains a serialized
+        # document (not a file name).
+        #
+        # The +boundary+ determines how the end of the document body is detected:
+        #
+        # * If +boundary+ is +nil+, the document is read until the end of file.
+        #
+        # * If +boundary+ is <tt>:detect</tt>, the document is read until the
+        #   end of file or until a line containing only a <em>boundary
+        #   string</em> is read. The boundary string is the value of the
+        #   "Boundary" header prefixed with "--".
+        #
+        # * Otherwise, it is assumed that +boundary+ contains a boundary string
+        #   without the "--" prefix (the "Boundary" header value is ignored for
+        #   the purpose of boundary detection). The document is read until the
+        #   end of file or until a line containing only the boundary string is
+        #   read.
+        #
+        # The +boundary+ parameter is provided mainly for parsing parts of
+        # multipart documents (see the +MultiPartDocument+ class documentation)
+        # and usually should not be used.
+        #
+        # If any syntax error occurs, a +SyntaxError+ exception is raised. This
+        # can happen when an invalid header is encountered, the headers are not
+        # terminated (no empty line separating headers and body is parsed before
+        # the end of file) or if no "Boundary" header is found when detecting a
+        # boundary.
+        #
+        # See the +SimpleDocument+ class documentation for a detailed document
+        # format description.
+        def parse(source, boundary = nil)
+          parse_from_io(
+            source.is_a?(String) ? StringIO.new(source) : source,
+            boundary
+          )
+        end
+    end
+
+    # Creates a new +SimpleDocument+ with given headers and body.
+    def initialize(headers, body)
+      @headers, @body = headers, body
+    end
+
+    # Tests if two documents are equal, i.e. whether they have the same class
+    # and equal headers and body (in the <tt>==</tt> sense).
+    def ==(other)
+      other.instance_of?(self.class) &&
+        @headers == other.headers &&
+        @body == other.body
+    end
+
+    # Returns string representation of this document. The result is in format
+    # described in the +SimpleDocument+ class documentation.
+    def to_s
+      serialized_headers = @headers.keys.sort.inject("") do |acc, key|
+        acc + "#{key}: #{@headers[key]}\n"
+      end
+      serialized_headers + "\n" + @body
+    end
+  end
+end

data/lib/doc_storage/syntax_error.rb

@@ -0,0 +1,5 @@
+module DocStorage
+  # Exception raised when a syntax error occurs in a document during parsing.
+  class SyntaxError < RuntimeError
+  end
+end

data/lib/doc_storage.rb

@@ -0,0 +1,3 @@
+require File.dirname(__FILE__) + "/doc_storage/syntax_error"
+require File.dirname(__FILE__) + "/doc_storage/simple_document"
+require File.dirname(__FILE__) + "/doc_storage/multi_part_document"

data/spec/multi_part_document_spec.rb

@@ -0,0 +1,139 @@
+require File.dirname(__FILE__) + "/../lib/doc_storage"
+
+module DocStorage
+  describe MultiPartDocument do
+    Spec::Matchers.define :parse_as_multi_part_document do |document|
+      match do |string|
+        MultiPartDocument::parse(string) == document
+      end
+    end
+
+    before :each do
+      @document = MultiPartDocument.new([:part1, :part2])
+
+      @document_with_no_parts = MultiPartDocument.new([])
+      @document_with_multiple_parts = MultiPartDocument.new([
+        SimpleDocument.new({"a" => "42", "b" => "43"}, "line1\nline2"),
+        SimpleDocument.new({"c" => "44", "d" => "45"}, "line3\nline4"),
+      ])
+    end
+
+    describe "initialize" do
+      it "sets attributes correctly" do
+        @document.parts.should == [:part1, :part2]
+      end
+    end
+
+    describe "==" do
+      it "returns true when passed the same object" do
+        @document.should == @document
+      end
+
+      it "returns true when passed a MultiPartDocument initialized with the same parameter" do
+        @document.should == MultiPartDocument.new([:part1, :part2])
+      end
+
+      it "returns false when passed some random object" do
+        @document.should_not == Object.new
+      end
+
+      it "returns false when passed a subclass of MultiPartDocument initialized with the same parameter" do
+        class SubclassedMultiPartDocument < MultiPartDocument
+        end
+
+        @document.should_not ==
+          SubclassedMultiPartDocument.new([:part1, :part2])
+      end
+
+      it "returns false when passed a MultiPartDocument initialized with different parameter" do
+        @document.should_not == MultiPartDocument.new([:part3, :part4])
+      end
+    end
+
+    describe "parse" do
+      it "parses document with no parts" do
+        "Boundary: =====\n\n".should parse_as_multi_part_document(
+          @document_with_no_parts
+        )
+      end
+
+      it "parses document with multiple parts" do
+        [
+          "Boundary: =====",
+          "",
+          "--=====",
+          "a: 42",
+          "b: 43",
+          "",
+          "line1",
+          "line2",
+          "--=====",
+          "c: 44",
+          "d: 45",
+          "",
+          "line3",
+          "line4",
+        ].join("\n").should parse_as_multi_part_document(
+          @document_with_multiple_parts
+        )
+      end
+
+      it "does not parse document with no Boundary: header" do
+        lambda {
+          MultiPartDocument.parse("\n\n")
+        }.should raise_error(SyntaxError, "No boundary defined.")
+      end
+
+      it "parses document from IO-like object" do
+        StringIO.open(
+          [
+            "Boundary: =====",
+            "",
+            "--=====",
+            "a: 42",
+            "b: 43",
+            "",
+            "line1",
+            "line2",
+            "--=====",
+            "c: 44",
+            "d: 45",
+            "",
+            "line3",
+            "line4",
+          ].join("\n")
+        ) do |io|
+          MultiPartDocument.parse(io).should == @document_with_multiple_parts
+        end
+      end
+    end
+
+    describe "to_s" do
+      it "serializes document with no parts" do
+        srand 0
+        @document_with_no_parts.to_s.should ==
+          "Boundary: SV1ad7dNjtvYKxgyym6bMNxUyrLznijuZqZfpVasJyXZDttoNGbj5GFk0xJlY3CI\n\n"
+      end
+
+      it "serializes document with multiple parts" do
+        srand 0
+        @document_with_multiple_parts.to_s.should == [
+          "Boundary: SV1ad7dNjtvYKxgyym6bMNxUyrLznijuZqZfpVasJyXZDttoNGbj5GFk0xJlY3CI",
+          "",
+          "--SV1ad7dNjtvYKxgyym6bMNxUyrLznijuZqZfpVasJyXZDttoNGbj5GFk0xJlY3CI",
+          "a: 42",
+          "b: 43",
+          "",
+          "line1",
+          "line2",
+          "--SV1ad7dNjtvYKxgyym6bMNxUyrLznijuZqZfpVasJyXZDttoNGbj5GFk0xJlY3CI",
+          "c: 44",
+          "d: 45",
+          "",
+          "line3",
+          "line4",
+        ].join("\n")
+      end
+    end
+  end
+end

data/spec/simple_document_spec.rb

@@ -0,0 +1,147 @@
+require File.dirname(__FILE__) + "/../lib/doc_storage"
+
+module DocStorage
+  describe SimpleDocument do
+    Spec::Matchers.define :parse_as_document do |document|
+      match do |string|
+        SimpleDocument.parse(string) == document
+      end
+    end
+
+    before :each do
+      @document = SimpleDocument.new({"a" => 42, "b" => 43}, "body")
+
+      @document_without_headers_without_body = SimpleDocument.new({}, "")
+      @document_without_headers_with_body = SimpleDocument.new({}, "line1\nline2")
+      @document_with_headers_without_body = SimpleDocument.new(
+        {"a" => "42", "b" => "43"},
+        ""
+      )
+      @document_with_headers_with_body = SimpleDocument.new(
+        {"a" => "42", "b" => "43"},
+        "line1\nline2"
+      )
+    end
+
+    describe "initialize" do
+      it "sets attributes correctly" do
+        @document.headers.should == {"a" => 42, "b" => 43}
+        @document.body.should == "body"
+      end
+    end
+
+    describe "==" do
+      it "returns true when passed the same object" do
+        @document.should == @document
+      end
+
+      it "returns true when passed a SimpleDocument initialized with the same parameters" do
+        @document.should == SimpleDocument.new({"a" => 42, "b" => 43}, "body")
+      end
+
+      it "returns false when passed some random object" do
+        @document.should_not == Object.new
+      end
+
+      it "returns false when passed a subclass of SimpleDocument initialized with the same parameters" do
+        class SubclassedSimpleDocument < SimpleDocument
+        end
+
+        @document.should_not ==
+          SubclassedSimpleDocument.new({"a" => 42, "b" => 43}, "body")
+      end
+
+      it "returns false when passed a SimpleDocument initialized with different parameters" do
+        @document.should_not == SimpleDocument.new({"a" => 44, "b" => 45}, "body")
+        @document.should_not == SimpleDocument.new({"a" => 42, "b" => 43}, "nobody")
+      end
+    end
+
+    describe "parse" do
+      it "parses document with no headers and no body" do
+        "\n".should parse_as_document(@document_without_headers_without_body)
+      end
+
+      it "parses document with no headers and body" do
+        "\nline1\nline2".should parse_as_document(
+          @document_without_headers_with_body
+        )
+      end
+
+      it "parses document with headers and no body" do
+        "a: 42\nb: 43\n\n".should parse_as_document(
+          @document_with_headers_without_body
+        )
+      end
+
+      it "parses document with headers and body" do
+        "a: 42\nb: 43\n\nline1\nline2".should parse_as_document(
+          @document_with_headers_with_body
+        )
+      end
+
+      it "does not parse document with invalid headers" do
+        lambda {
+          SimpleDocument.parse("bullshit")
+        }.should raise_error(SyntaxError, "Invalid header: \"bullshit\".")
+      end
+
+      it "does not parse document with unterminated headers" do
+        lambda {
+          SimpleDocument.parse("a: 42\nb: 42\n")
+        }.should raise_error(SyntaxError, "Unterminated headers.")
+      end
+
+      it "parses document from IO-like object" do
+        StringIO.open("a: 42\nb: 43\n\nline1\nline2") do |io|
+          SimpleDocument.parse(io).should == @document_with_headers_with_body
+        end
+      end
+
+      it "parses document when detecting a boundary" do
+        SimpleDocument.parse(
+          "a: 42\nb: 43\nBoundary: =====\n\nline1\nline2\n--=====\nbullshit",
+          :detect
+        ).should == SimpleDocument.new(
+          {"a" => "42", "b" => "43", "Boundary" => "====="},
+          "line1\nline2"
+        )
+      end
+
+      it "does not parse document when detecting a boundary and no boundary defined" do
+        lambda {
+          SimpleDocument.parse(
+            "a: 42\nb: 43\n\nline1\nline2\n--=====\nbullshit",
+            :detect
+          )
+        }.should raise_error(SyntaxError, "No boundary defined.")
+      end
+
+      it "parses document when passed a boundary" do
+        SimpleDocument.parse(
+          "a: 42\nb: 43\n\nline1\nline2\n--=====\nbullshit",
+          "====="
+        ).should == @document_with_headers_with_body
+      end
+    end
+
+    describe "to_s" do
+      it "serializes document with no headers and no body" do
+        @document_without_headers_without_body.to_s.should == "\n"
+      end
+
+      it "serializes document with no headers and body" do
+        @document_without_headers_with_body.to_s.should == "\nline1\nline2"
+      end
+
+      it "serializes document with headers and no body" do
+        @document_with_headers_without_body.to_s.should == "a: 42\nb: 43\n\n"
+      end
+
+      it "serializes document with headers and body" do
+        @document_with_headers_with_body.to_s.should ==
+          "a: 42\nb: 43\n\nline1\nline2"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: doc_storage
+version: !ruby/object:Gem::Version 
+  version: "0.9"
+platform: ruby
+authors: 
+- David Majda
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-19 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: DocStorage is a simple Ruby library for manipulating documents containing a text and metadata. These documents can be used to implement a blog, wiki, or similar application without a relational database.
+email: david@majda.cz
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- Rakefile
+- README.rdoc
+- LICENSE
+- VERSION
+- lib/doc_storage.rb
+- lib/doc_storage/multi_part_document.rb
+- lib/doc_storage/simple_document.rb
+- lib/doc_storage/syntax_error.rb
+- spec/simple_document_spec.rb
+- spec/multi_part_document_spec.rb
+- examples/simple.txt
+- examples/multipart.rb
+- examples/simple.rb
+- examples/multipart.txt
+has_rdoc: true
+homepage: http://github.com/dmajda/doc_storage
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.6
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Simple Ruby library for manipulating documents containing a text and metadata.
+test_files: []
+