xml-write-stream 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a14bdeb8c25d97029a82e7afbe8bd8cd0247593a
+  data.tar.gz: 37b5e95c34ad08e90db5a5dd07c07be5ac2db843
+SHA512:
+  metadata.gz: f46bd1fe8b2489370cea9299e3ce94ee08069549bdb3e3a12c9db94b0d47e7222bd67b8b9daf2e4e6e8b8e897623a552defb79b7741ef25c3521095172129205
+  data.tar.gz: 5fa0ad54a777b0db21a3b1fa23887950cded7b05649812511a3c20f1e7108f2802c6d102ec4272af7ceb7775f3458bc1fefed8423a44821f6e890099603ac969

data/Gemfile

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :development, :test do
+  gem 'pry', '~> 0.9.0'
+  gem 'pry-nav'
+  gem 'rake'
+end
+
+group :test do
+  gem 'rspec'
+  gem 'rr'
+end

data/History.txt

@@ -0,0 +1,3 @@
+== 1.0.0
+
+* Birthday!

data/README.md

@@ -0,0 +1,110 @@
+xml-write-stream
+=================
+
+[![Build Status](https://travis-ci.org/camertron/xml-write-stream.svg?branch=master)](http://travis-ci.org/camertron/xml-write-stream)
+
+An easy, streaming way to generate XML.
+
+## Installation
+
+`gem install xml-write-stream`
+
+## Usage
+
+```ruby
+require 'xml-write-stream'
+```
+
+### Examples for the Impatient
+
+There are two types of XML write stream: one that uses blocks and `yield` to write tags, and one that's purely stateful. Here are two examples that produce the same output:
+
+Yielding:
+
+```ruby
+stream = StringIO.new
+XmlWriteStream.from_stream(stream) do |writer|
+  writer.open_tag('foo', bar: 'baz') do |foo_writer|
+    foo_writer.open_tag('no-text')
+    foo_writer.write_text('blarg')
+  end
+end
+```
+
+Stateful:
+
+```ruby
+stream = StringIO.new
+writer = XmlWriteStream.from_stream(stream)
+writer.open_tag('foo', bar: 'baz')
+writer.open_tag('no-text')
+writer.close_tag
+writer.write_text('blarg')
+writer.close  # automatically adds closing tags for all unclosed tags
+```
+
+Output:
+
+```ruby
+stream.string # => <foo bar="baz"><no-text/>blarg</foo>
+```
+
+### Yielding Writers
+
+As far as yielding writers go, the example above contains everything you need. The stream will be automatically closed when the outermost block terminates.
+
+### Stateful Writers
+
+Stateful writers have a number of additional methods:
+
+```ruby
+stream = StringIO.new
+writer = XmlWriteStream.from_stream(stream)
+writer.open_tag('foo')
+
+writer.eos?             # => false, the stream is open and the outermost tag hasn't been closed yet
+
+writer.open_tag         # explicitly close the current tag
+writer.eos?             # => true, the outermost tag has been closed
+
+writer.open_tag('foo')  # => raises XmlWriteStream::EndOfStreamError
+
+writer.closed?          # => false, the stream is still open
+writer.close            # close the stream
+writer.closed?          # => true, the stream has been closed
+```
+
+### Writing to a File
+
+XmlWriteStream also supports streaming to a file via the `open` method:
+
+Yielding:
+
+```ruby
+XmlWriteStream.open('path/to/file.xml') do |writer|
+  writer.open_tag('foo') do |foo_writer|
+    ...
+  end
+end
+```
+
+Stateful:
+
+```ruby
+writer = XmlWriteStream.open('path/to/file.xml')
+writer.open_tag('foo')
+...
+writer.close
+```
+
+## Requirements
+
+No external requirements.
+
+## Running Tests
+
+`bundle exec rake` should do the trick. Alternatively you can run `bundle exec rspec`, which does the same thing.
+
+## Authors
+
+* Cameron C. Dutro: http://github.com/camertron

data/Rakefile

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+require 'rubygems' unless ENV['NO_RUBYGEMS']
+
+require 'bundler'
+require 'rspec/core/rake_task'
+require 'rubygems/package_task'
+
+require './lib/xml-write-stream'
+
+Bundler::GemHelper.install_tasks
+
+task :default => :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = './spec/**/*_spec.rb'
+end

data/lib/xml-write-stream.rb

@@ -0,0 +1,40 @@
+# encoding: UTF-8
+
+require 'xml-write-stream/base'
+require 'xml-write-stream/yielding_writer'
+require 'xml-write-stream/stateful_writer'
+
+class XmlWriteStream
+  class InvalidAttributeKeyError < StandardError; end
+  class InvalidTagNameError < StandardError; end
+  class EndOfStreamError < StandardError; end
+  class NoTopLevelTagError < StandardError; end
+  class InvalidHeaderPositionError < StandardError; end
+
+  DEFAULT_ENCODING = Encoding::UTF_8
+
+  class << self
+    def from_stream(stream, encoding = DEFAULT_ENCODING)
+      stream.set_encoding(encoding)
+
+      if block_given?
+        yield writer = YieldingWriter.new(stream)
+        writer.close
+      else
+        StatefulWriter.new(stream)
+      end
+    end
+
+    def open(file, encoding = DEFAULT_ENCODING)
+      handle = File.open(file, 'w')
+      handle.set_encoding(encoding)
+
+      if block_given?
+        yield writer = YieldingWriter.new(handle)
+        writer.close
+      else
+        StatefulWriter.new(handle)
+      end
+    end
+  end
+end

data/lib/xml-write-stream/base.rb

@@ -0,0 +1,112 @@
+# encoding: UTF-8
+
+class XmlWriteStream
+  class Base
+    DEFAULT_INDENT = 4
+
+    # these are probably fairly incorrect, but good enough for now
+    TAG_NAME_REGEX = /\A[a-zA-Z:_][\w.\-_:]*/
+    ATTRIBUTE_KEY_REGEX = /\A[a-zA-Z_][\w\-_]*/
+
+    TEXT_ESCAPE_CHARS = /["'<>&]/
+    ATTRIBUTE_ESCAPE_CHARS = /["'<>&\n\r\t]/
+
+    TEXT_ESCAPE_HASH = {
+      '"' => '&quot;',
+      "'" => '&apos;',
+      '<' => '&lt;',
+      '>' => '&gt;',
+      '&' => '&amp;'
+    }
+
+    ATTRIBUTE_ESCAPE_HASH = TEXT_ESCAPE_HASH.merge({
+      "\n" => '&#xA;',
+      "\r" => '&#xD;',
+      "\t" => '&#x9;'
+    })
+
+    DEFAULT_HEADER_ATTRIBUTES = {
+      version: '1.0',
+      encoding: 'utf-8'
+    }
+
+    def write_text(text, options = {})
+      escape = options.fetch(:escape, true)
+      stream.write(indent_spaces)
+
+      stream.write(
+        escape ? escape_text(text) : text
+      )
+
+      write_newline
+    end
+
+    def write_header(attributes = {})
+      stream.write('<?xml ')
+
+      write_attributes(
+        DEFAULT_HEADER_ATTRIBUTES.merge(attributes)
+      )
+
+      stream.write('?>')
+      write_newline
+    end
+
+    protected
+
+    def check_tag_name(tag_name)
+      unless tag_name =~ TAG_NAME_REGEX
+        raise InvalidTagNameError, "'#{tag_name}' is not a valid tag"
+      end
+    end
+
+    def check_attributes(attributes)
+      attributes.each_pair do |key, _|
+        unless key =~ ATTRIBUTE_KEY_REGEX
+          raise InvalidAttributeKeyError,
+            "'#{key}' is not a valid attribute key"
+        end
+      end
+    end
+
+    def write_open_tag(tag_name, attributes)
+      stream.write(indent_spaces)
+      stream.write("<#{tag_name}")
+
+      if attributes.size > 0
+        stream.write(' ')
+        write_attributes(attributes)
+      end
+
+      stream.write('>')
+    end
+
+    def write_close_tag(tag_name)
+      stream.write(indent_spaces)
+      stream.write("</#{tag_name}>")
+    end
+
+    def write_attributes(attributes)
+      attributes.each_pair.with_index do |(key, val), idx|
+        if idx > 0
+          stream.write(' ')
+        end
+
+        stream.write("#{key}=\"#{escape_attribute(val)}\"")
+      end
+    end
+
+    def write_newline
+      stream.write("\n")
+    end
+
+    def escape_attribute(attribute)
+      attribute.gsub(ATTRIBUTE_ESCAPE_CHARS, ATTRIBUTE_ESCAPE_HASH)
+    end
+
+    def escape_text(text)
+      text.gsub(TEXT_ESCAPE_CHARS, TEXT_ESCAPE_HASH)
+    end
+  end
+end
+

data/lib/xml-write-stream/stateful_writer.rb

@@ -0,0 +1,87 @@
+# encoding: UTF-8
+
+class XmlWriteStream
+  class StatefulWriter < Base
+    attr_reader :stream, :stack, :closed, :indent, :index
+    alias :closed? :closed
+
+    def initialize(stream, options = {})
+      @stream = stream
+      @stack = []
+      @closed = false
+      @index = 0
+      @indent = options.fetch(:indent, Base::DEFAULT_INDENT)
+    end
+
+    def open_tag(tag_name, attributes = {})
+      check_eos
+      @index += 1
+
+      check_tag_name(tag_name)
+      check_attributes(attributes)
+      write_open_tag(tag_name, attributes)
+      write_newline
+
+      stack.push(tag_name)
+    end
+
+    def write_text(text, options = {})
+      check_eos
+
+      if stack.size == 0
+        raise NoTopLevelTagError
+      end
+
+      super
+    end
+
+    def write_header(attributes = {})
+      if stack.size > 0
+        raise InvalidHeaderPositionError,
+          'header must be the first element written.'
+      end
+
+      super
+    end
+
+    def close_tag(options = {})
+      if in_tag?
+        tag_name = stack.pop
+        write_close_tag(tag_name)
+        write_newline
+      end
+    end
+
+    def flush
+      close_tag until stack.empty?
+      @closed = true
+      nil
+    end
+
+    def close
+      flush
+      stream.close
+      nil
+    end
+
+    def in_tag?
+      stack.size > 0 && !closed?
+    end
+
+    def eos?
+      (stack.size == 0 && index > 0) || closed?
+    end
+
+    protected
+
+    def indent_spaces
+      ' ' * (stack.size * indent)
+    end
+
+    def check_eos
+      if eos?
+        raise EndOfStreamError, 'end of stream.'
+      end
+    end
+  end
+end

data/lib/xml-write-stream/version.rb

@@ -0,0 +1,5 @@
+# encoding: UTF-8
+
+class XmlWriteStream
+  VERSION = "1.0.2"
+end

data/lib/xml-write-stream/yielding_writer.rb

@@ -0,0 +1,65 @@
+# encoding: UTF-8
+
+class XmlWriteStream
+  class YieldingWriter < Base
+    attr_reader :stream, :level, :indent
+
+    def initialize(stream, options = {})
+      @stream = stream
+      @level = 0
+      @indent = options.fetch(:indent, Base::DEFAULT_INDENT)
+    end
+
+    def open_tag(tag_name, attributes = {})
+      check_closed
+      check_tag_name(tag_name)
+      check_attributes(attributes)
+      write_open_tag(tag_name, attributes)
+      write_newline
+
+      @level += 1
+      yield self if block_given?
+      @level -= 1
+      write_close_tag(tag_name)
+      write_newline
+    end
+
+    def write_text(text, options = {})
+      check_closed
+
+      if level == 0
+        raise NoTopLevelTagError
+      end
+
+      super
+    end
+
+    def write_header(attributes = {})
+      if level > 0
+        raise InvalidHeaderPositionError,
+          'header must be the first element written.'
+      end
+
+      super
+    end
+
+    def flush
+    end
+
+    def close
+      stream.close
+    end
+
+    protected
+
+    def check_closed
+      if stream.closed?
+        raise EndOfStreamError, 'end of stream.'
+      end
+    end
+
+    def indent_spaces
+      ' ' * (level * indent)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+# encoding: UTF-8
+
+require 'rspec'
+require 'xml-write-stream'
+require 'pry-nav'
+
+RSpec.configure do |config|
+end

data/spec/stateful_spec.rb

@@ -0,0 +1,192 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+describe XmlWriteStream::YieldingWriter do
+  let(:stream) do
+    StringIO.new.tap do |io|
+      io.set_encoding(Encoding::UTF_8)
+    end
+  end
+
+  let(:stream_writer) do
+    XmlWriteStream::StatefulWriter.new(stream)
+  end
+
+  def utf8(str)
+    str.encode(Encoding::UTF_8)
+  end
+
+  describe '#write_header' do
+    it 'writes the header with default attributes' do
+      stream_writer.write_header
+      stream_writer.close
+
+      expect(stream.string).to eq(
+        utf8("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n")
+      )
+    end
+
+    it 'allows header attributes to be overwritten' do
+      stream_writer.write_header(version: '2.0')
+      stream_writer.close
+
+      expect(stream.string).to eq(
+        utf8("<?xml version=\"2.0\" encoding=\"utf-8\"?>\n")
+      )
+    end
+
+    it 'raises an error if tags have already been written' do
+      stream_writer.open_tag('foo')
+
+      expect do
+        stream_writer.write_header
+      end.to raise_error(XmlWriteStream::InvalidHeaderPositionError)
+    end
+  end
+
+  describe '#open_tag' do
+    it 'writes an opening tag' do
+      stream_writer.open_tag('maytag')
+      stream_writer.close
+
+      expect(stream.string).to eq(
+        utf8("<maytag>\n</maytag>\n")
+      )
+    end
+
+    it 'writes an opening tag with attributes' do
+      stream_writer.open_tag('maytag', type: 'washing_machine')
+      stream_writer.close
+
+      expect(stream.string).to eq(
+        utf8("<maytag type=\"washing_machine\">\n</maytag>\n")
+      )
+    end
+
+    it 'raises an error if one of the attribute keys is invalid' do
+      expect do
+        stream_writer.open_tag('maytag', '0foo' => '')
+      end.to raise_error(XmlWriteStream::InvalidAttributeKeyError)
+    end
+
+    it 'raises an error if the tag name is invalid' do
+      expect do
+        stream_writer.open_tag('9foo')
+      end.to raise_error(XmlWriteStream::InvalidTagNameError)
+    end
+
+    it 'allows digits and colons in the tag name' do
+      stream_writer.open_tag('foo9')
+      stream_writer.open_tag('bar:baz')
+      stream_writer.close
+
+      expect(stream.string).to eq(
+        utf8("<foo9>\n    <bar:baz>\n    </bar:baz>\n</foo9>\n")
+      )
+    end
+
+    it 'raises an error if the stream is already closed' do
+      stream_writer.close
+
+      expect do
+        stream_writer.open_tag('foo')
+      end.to raise_error(XmlWriteStream::EndOfStreamError)
+    end
+  end
+
+  describe '#close_tag' do
+    it 'closes the currently open tag' do
+      stream_writer.open_tag('maytag')
+      stream_writer.close_tag
+
+      expect(stream.string).to eq(
+        utf8("<maytag>\n</maytag>\n")
+      )
+    end
+  end
+
+  describe '#write_text' do
+    it 'writes escaped text by default' do
+      stream_writer.open_tag('places')
+      stream_writer.write_text("Alaska & Hawai'i")
+      stream_writer.close
+
+      expect(stream.string).to eq(
+        utf8("<places>\n    Alaska &amp; Hawai&apos;i\n</places>\n")
+      )
+    end
+
+    it 'writes raw text if asked not to escape' do
+      stream_writer.open_tag('places')
+      stream_writer.write_text("Alaska & Hawai'i", escape: false)
+      stream_writer.close
+
+      expect(stream.string).to eq(
+        utf8("<places>\n    Alaska & Hawai'i\n</places>\n")
+      )
+    end
+
+    it 'raises an error if no tag has been written yet' do
+      expect do
+        stream_writer.write_text('foo')
+      end.to raise_error(XmlWriteStream::NoTopLevelTagError)
+    end
+
+    it 'raises an error if the stream is already closed' do
+      stream_writer.close
+
+      expect do
+        stream_writer.write_text('foo')
+      end.to raise_error(XmlWriteStream::EndOfStreamError)
+    end
+  end
+
+  describe '#flush' do
+    it 'closes all open tags' do
+      stream_writer.open_tag('foo')
+      stream_writer.open_tag('bar')
+      stream_writer.open_tag('baz')
+      stream_writer.flush
+
+      expect(stream.string).to eq(
+        utf8("<foo>\n    <bar>\n        <baz>\n        </baz>\n    </bar>\n</foo>\n")
+      )
+
+      expect(stream).to_not be_closed
+      expect(stream_writer).to be_eos
+    end
+  end
+
+  describe '#close' do
+    it 'closes all open tags and closes the stream' do
+      stream_writer.open_tag('foo')
+      stream_writer.open_tag('bar')
+      stream_writer.open_tag('baz')
+      stream_writer.close
+
+      expect(stream.string).to eq(
+        utf8("<foo>\n    <bar>\n        <baz>\n        </baz>\n    </bar>\n</foo>\n")
+      )
+
+      expect(stream).to be_closed
+      expect(stream_writer).to be_eos
+    end
+  end
+
+  describe '#in_tag?' do
+    it 'returns true if currently writing a tag, false otherwise' do
+      expect(stream_writer).to_not be_in_tag
+      stream_writer.open_tag('foo')
+      expect(stream_writer).to be_in_tag
+    end
+  end
+
+  describe '#eos?' do
+    it 'returns true if the stream is closed, false if it is still open' do
+      expect(stream_writer).to_not be_eos
+      stream_writer.close
+      expect(stream_writer).to be_eos
+    end
+  end
+end

data/spec/xml-write-stream_spec.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+require 'tempfile'
+
+describe XmlWriteStream do
+  let(:yielding_writer) { XmlWriteStream::YieldingWriter }
+  let(:stateful_writer) { XmlWriteStream::StatefulWriter }
+  let(:stream_writer) { XmlWriteStream }
+  let(:tempfile) { Tempfile.new('temp') }
+  let(:stream) { StringIO.new }
+
+  describe '#from_stream' do
+    it 'yields a yielding stream if given a block' do
+      stream_writer.from_stream(stream) do |writer|
+        expect(writer).to be_a(yielding_writer)
+        expect(writer.stream).to equal(stream)
+      end
+    end
+
+    it 'returns a stateful writer if not given a block' do
+      writer = stream_writer.from_stream(stream)
+      expect(writer).to be_a(stateful_writer)
+      expect(writer.stream).to equal(stream)
+    end
+
+    it 'supports specifying a different encoding' do
+      stream_writer.from_stream(stream, Encoding::UTF_16BE) do |writer|
+        writer.open_tag('foo') do |tag_writer|
+          tag_writer.write_text('bar')
+        end
+      end
+
+      expect(stream.string.bytes.to_a).to_not eq(
+        "<foo>\n    bar\n</foo>\n".bytes.to_a
+      )
+
+      expect(stream.string.encode(Encoding::UTF_8).bytes.to_a).to eq(
+        "<foo>\n    bar\n</foo>\n".bytes.to_a
+      )
+    end
+  end
+
+  describe '#open' do
+    it 'opens a file and yields a yielding stream if given a block' do
+      stream_writer.open(tempfile) do |writer|
+        expect(writer).to be_a(yielding_writer)
+        expect(writer.stream.path).to eq(tempfile.path)
+      end
+    end
+
+    it 'opens a file and returns a stateful writer if not given a block' do
+      writer = stream_writer.open(tempfile)
+      expect(writer).to be_a(stateful_writer)
+      expect(writer.stream.path).to eq(tempfile.path)
+    end
+
+    it 'supports specifying a different encoding' do
+      stream_writer.open(tempfile, Encoding::UTF_16BE) do |writer|
+        writer.open_tag('foo') do |tag_writer|
+          tag_writer.write_text('bar')
+        end
+      end
+
+      written = tempfile.read
+      written.force_encoding(Encoding::UTF_16BE)
+
+      expect(written.bytes.to_a).to_not eq(
+        "<foo>\n    bar\n</foo>\n".bytes.to_a
+      )
+
+      expect(written.encode(Encoding::UTF_8).bytes.to_a).to eq(
+        "<foo>\n    bar\n</foo>\n".bytes.to_a
+      )
+    end
+  end
+end

data/spec/yielding_spec.rb

@@ -0,0 +1,147 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+describe XmlWriteStream::YieldingWriter do
+  let(:stream) do
+    StringIO.new.tap do |io|
+      io.set_encoding(Encoding::UTF_8)
+    end
+  end
+
+  let(:stream_writer) do
+    XmlWriteStream::YieldingWriter.new(stream)
+  end
+
+  def utf8(str)
+    str.encode(Encoding::UTF_8)
+  end
+
+  describe '#write_header' do
+    it 'writes the header with default attributes' do
+      stream_writer.write_header
+      stream_writer.close
+
+      expect(stream.string).to eq(
+        utf8("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n")
+      )
+    end
+
+    it 'allows header attributes to be overwritten' do
+      stream_writer.write_header(version: '2.0')
+      stream_writer.close
+
+      expect(stream.string).to eq(
+        utf8("<?xml version=\"2.0\" encoding=\"utf-8\"?>\n")
+      )
+    end
+
+    it 'raises an error if tags have already been written' do
+      expect do
+        stream_writer.open_tag('foo') do |foo|
+          foo.write_header
+        end
+      end.to raise_error(XmlWriteStream::InvalidHeaderPositionError)
+    end
+  end
+
+  describe '#open_tag' do
+    it 'writes an opening tag' do
+      stream_writer.open_tag('maytag')
+      expect(stream.string).to eq(
+        utf8("<maytag>\n</maytag>\n")
+      )
+    end
+
+    it 'yields the writer and allows nesting' do
+      stream_writer.open_tag('maytag') do |maytag|
+        expect(maytag).to be_a(XmlWriteStream::YieldingWriter)
+        maytag.open_tag('machine')
+      end
+
+      expect(stream.string).to eq(
+        utf8("<maytag>\n    <machine>\n    </machine>\n</maytag>\n")
+      )
+    end
+
+    it 'writes an opening tag with attributes' do
+      stream_writer.open_tag('maytag', { type: 'washing_machine' })
+      expect(stream.string).to eq(
+        utf8("<maytag type=\"washing_machine\">\n</maytag>\n")
+      )
+    end
+
+    it 'raises an error if one of the attribute keys is invalid' do
+      expect do
+        stream_writer.open_tag('maytag', '0foo' => '')
+      end.to raise_error(XmlWriteStream::InvalidAttributeKeyError)
+    end
+
+    it 'raises an error if the tag name is invalid' do
+      expect do
+        stream_writer.open_tag('9foo') {}
+      end.to raise_error(XmlWriteStream::InvalidTagNameError)
+    end
+
+    it 'allows digits and colons in the tag name' do
+      stream_writer.open_tag('foo9') do |foo|
+        foo.open_tag('bar:baz')
+      end
+
+      expect(stream.string).to eq(
+        utf8("<foo9>\n    <bar:baz>\n    </bar:baz>\n</foo9>\n")
+      )
+    end
+
+    it 'raises an error if the stream is already closed' do
+      stream_writer.close
+
+      expect do
+        stream_writer.open_tag('foo')
+      end.to raise_error(XmlWriteStream::EndOfStreamError)
+    end
+  end
+
+  describe '#write_text' do
+    it 'writes escaped text by default' do
+      stream_writer.open_tag('places') do |places|
+        places.write_text("Alaska & Hawai'i")
+      end
+
+      expect(stream.string).to eq(
+        utf8("<places>\n    Alaska &amp; Hawai&apos;i\n</places>\n")
+      )
+    end
+
+    it 'writes raw text if asked not to escape' do
+      stream_writer.open_tag('places') do |places|
+        places.write_text("Alaska & Hawai'i", escape: false)
+      end
+
+      expect(stream.string).to eq(
+        utf8("<places>\n    Alaska & Hawai'i\n</places>\n")
+      )
+    end
+
+    it 'raises an error if no tag has been written yet' do
+      expect do
+        stream_writer.write_text('foo')
+      end.to raise_error(XmlWriteStream::NoTopLevelTagError)
+    end
+
+    it 'raises an error if the stream is already closed' do
+      stream_writer.close
+
+      expect do
+        stream_writer.write_text('foo')
+      end.to raise_error(XmlWriteStream::EndOfStreamError)
+    end
+  end
+
+  describe '#close' do
+    it 'closes the stream' do
+      stream_writer.close
+      expect(stream).to be_closed
+    end
+  end
+end

data/xml-write-stream.gemspec

@@ -0,0 +1,18 @@
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'xml-write-stream/version'
+
+Gem::Specification.new do |s|
+  s.name     = "xml-write-stream"
+  s.version  = ::XmlWriteStream::VERSION
+  s.authors  = ["Cameron Dutro"]
+  s.email    = ["camertron@gmail.com"]
+  s.homepage = "http://github.com/camertron"
+
+  s.description = s.summary = "An easy, streaming way to generate XML."
+
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+
+  s.require_path = 'lib'
+  s.files = Dir["{lib,spec}/**/*", "Gemfile", "History.txt", "README.md", "Rakefile", "xml-write-stream.gemspec"]
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: xml-write-stream
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+platform: ruby
+authors:
+- Cameron Dutro
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-05-26 00:00:00.000000000 Z
+dependencies: []
+description: An easy, streaming way to generate XML.
+email:
+- camertron@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/xml-write-stream.rb
+- lib/xml-write-stream/base.rb
+- lib/xml-write-stream/stateful_writer.rb
+- lib/xml-write-stream/version.rb
+- lib/xml-write-stream/yielding_writer.rb
+- spec/spec_helper.rb
+- spec/stateful_spec.rb
+- spec/xml-write-stream_spec.rb
+- spec/yielding_spec.rb
+- Gemfile
+- History.txt
+- README.md
+- Rakefile
+- xml-write-stream.gemspec
+homepage: http://github.com/camertron
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.1.9
+signing_key:
+specification_version: 4
+summary: An easy, streaming way to generate XML.
+test_files: []