improvise 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4d23a1bbb23c53484630f7e37c9eaf98aefffef7
+  data.tar.gz: 8017aec4d0fa52f0dcda9a65fc8ea17e1dbb573d
+SHA512:
+  metadata.gz: b9e9f8471cd08b819667c12dcfe45ef24ca94d2ba9f1ec9180cca1d8e3d8f4c83e6071333c2ca01c3a1b9eeaeb368d8a24a864eef9cf566c11c0bdb08121b88f
+  data.tar.gz: b8d199c5a1f6465e713ae5fadc6ec813cf0527ba7027c13758ce00ae6241c9631f42357b59b6aaec652543beae552a99a57cc7dd47ccd89a02acfd27dbc491db

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Sander Kleykens
+
+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.md

@@ -0,0 +1,115 @@
+# Improvise
+Improvise generates random words by learning from existing text.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```
+gem 'improvise'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+Or install it yourself as:
+
+```
+$ gem install improvise
+```
+
+## Usage
+Require the 'improvise' gem:
+
+```ruby
+require 'improvise'
+```
+
+### Learn
+Create a new dictionary with depth 3 and learn from a list of existing words:
+
+```ruby
+dict = Improvise::ForwardDictionary.new(3)
+dict.learn!([
+    'ruby', 
+    'sapphire', 
+    'pearl', 
+    'diamond', 
+    'amethyst', 
+    'topaz', 
+    'emerald'
+])
+```
+
+### Generate
+Generate a 6-letter word:
+
+```ruby
+dict.generate_word(6)
+```
+
+Generate a 7-letter word, starting with 'top':
+
+```ruby
+dict.generate_word(7, 'top')
+```
+
+### Store
+Write a dictionary in Ruby's Marshal format to a file called 'dict.bin':
+
+```ruby
+dict_file = File.open('dict.bin', 'w')
+Improvise::IO::DictionaryWriter.write(dict_file, dict)
+```
+
+Write a dictionary in Ruby's Marshal format, gzipped, to a file called 'dict.bin.gz':
+
+```ruby
+dict_file = File.open('dict.bin.gz', 'w')
+Improvise::IO::DictionaryWriter.write(dict_file, dict, gzip: true)
+```
+
+Write a dictionary in json format, gzipped, to a file called 'dict.json.gz':
+
+```ruby
+dict_file = File.open('dict.json.gz', 'w')
+Improvise::IO::DictionaryWriter.write(dict_file, dict, format: :json, gzip: true)
+```
+
+*Note: writing a dictionary closes the passed IO object.*
+
+### Load
+Restore a dictionary from a file called 'dict.bin' in Ruby's Marshal format:
+
+```ruby
+dict_file = File.open('dict.bin', 'r')
+dict = Improvise::IO::DictionaryReader.read(dict_file)
+```
+
+Restore a dictionary from a file called 'dict.bin.gz' in Ruby's Marshal format, gzipped:
+
+```ruby
+dict_file = File.open('dict.bin.gz', 'r')
+dict = Improvise::IO::DictionaryReader.read(dict_file, gzip: true)
+```
+
+Restore a dictionary from a file called 'dict.json.gz' in json format, gzipped:
+
+```ruby
+dict_file = File.open('dict.json.gz', 'r')
+dict = Improvise::IO::DictionaryReader.read(dict_file, format: :json, gzip: true)
+```
+
+*Note: reading a dictionary closes the passed IO object.*
+
+## Command-line tool
+A command-line interface to the library has been provided under the name 'improvise'. 
+Run `improvise --help` to get a list of available commands.
+
+## Contributing
+1. Fork
+2. Branch (`git checkout -b my-new-feature`)
+3. Commit (`git commit -am 'Added some feature'`)
+4. Push (`git push origin my-new-feature`)
+5. Pull request

data/Rakefile

@@ -0,0 +1,129 @@
+require 'rubygems'
+require 'rake'
+require 'date'
+
+#############################################################################
+#
+# Helper functions
+#
+#############################################################################
+
+def name
+    @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+    line = File.read("lib/#{name}/version.rb")[/^\s*VERSION\s*=\s*.*/]
+    line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def date
+    Date.today.to_s
+end
+
+def gemspec_file
+    "#{name}.gemspec"
+end
+
+def gem_file
+    "#{name}-#{version}.gem"
+end
+
+def replace_header(head, header_name)
+    head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+end
+
+#############################################################################
+#
+# Standard tasks
+#
+#############################################################################
+
+task :default => :spec
+
+require 'rspec/core/rake_task'
+desc 'Tests'
+RSpec::Core::RakeTask.new(:spec) do |test|
+    test.pattern = 'spec/**/*_spec.rb'
+end
+
+RSpec::Core::RakeTask.new(:coverage) do |test|
+    ENV['COVERAGE'] = 'true'
+    Rake::Task[:spec].execute
+end
+
+require 'yard'
+YARD::Rake::YardocTask.new do |yard|
+    yard.files = ['README*', 'lib/**/*.rb']
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+    sh "irb -rubygems -r ./lib/#{name}.rb"
+end
+
+#############################################################################
+#
+# Packaging tasks
+#
+#############################################################################
+
+desc "Create tag v#{version} and build and push #{gem_file} to Rubygems"
+task :release => :build do
+    unless `git branch` =~ /^\* master$/
+        puts "You must be on the master branch to release!"
+        exit!
+    end
+    sh "git commit --allow-empty -a -m 'Release #{version}'"
+    sh "git tag v#{version}"
+    sh "git push origin master"
+    sh "git push origin v#{version}"
+    sh "gem push pkg/#{name}-#{version}.gem"
+end
+
+desc "Build #{gem_file} into the pkg directory"
+task :build => :gemspec do
+    sh "mkdir -p pkg"
+    sh "gem build #{gemspec_file}"
+    sh "mv #{gem_file} pkg"
+end
+
+desc "Generate #{gemspec_file}"
+task :gemspec => :validate do
+    # read spec file and split out manifest section
+    spec = File.read(gemspec_file)
+    head, manifest, tail = spec.split("    # = MANIFEST =\n")
+
+    # replace name version and date
+    replace_header(head, :name)
+    replace_header(head, :version)
+    replace_header(head, :date)
+
+    # determine file list from git ls-files
+    files = `git ls-files`.
+        split("\n").
+        sort.
+        reject { |file| file =~ /^\./ }.
+        reject { |file| file =~ /^(rdoc|pkg)/ }.
+        map { |file| "        #{file}" }.
+        join("\n")
+
+    # piece file back together and write
+    manifest = "    s.files = %w[\n#{files}\n  ]\n"
+    spec = [head, manifest, tail].join("    # = MANIFEST =\n")
+    File.open(gemspec_file, 'w') { |io| io.write(spec) }
+    puts "Updated #{gemspec_file}"
+end
+
+desc "Validate #{gemspec_file}"
+task :validate do
+    libfiles = Dir['lib/*'] - ["lib/#{name}.rb", "lib/#{name}"]
+    unless libfiles.empty?
+        puts "Directory `lib` should only contain a `#{name}.rb` file and `#{name}` dir."
+        exit!
+    end
+    unless Dir['VERSION*'].empty?
+        puts "A `VERSION` file at root level violates Gem best practices."
+        exit!
+    end
+end

data/bin/improvise

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+
+require 'gli'
+require 'json'
+require 'zlib'
+require 'improvise'
+
+include GLI::App
+
+program_desc 'Improvise generates random words by learning from existing text.'
+version Improvise::VERSION
+
+flag [:f, :format], :desc => 'The format of the dictionary (marshal or json)', :default_value => :marshal, :must_match => [ :marshal, :json ]
+switch [:g, :gzip], :desc => 'Indicates if the dictionary is in gzip format', :negatable => false
+
+desc 'Create or update a dictionary based on an input file'
+arg_name 'input dictionary'
+command :learn do |c|
+    c.flag [:d, :depth], :desc => 'The depth to use when building the dictionary', :default_value => 2, :type => Integer
+
+    c.action do |global_options, options, args|
+        if args.length < 1
+            help_now!('Input argument missing.')
+        elsif args.length < 2
+            help_now!('Dictionary argument missing.')
+        end
+
+        input_filename = args[0]
+        dictionary_filename = args[1]
+        depth = options[:depth]
+        format = global_options[:format]
+        gzip = global_options[:gzip]
+
+        input_file = File.open(input_filename, 'r')
+        words = input_file.read.split(/\W+/)
+        input_file.close()
+
+        if File.exists?(dictionary_filename)
+            dictionary = Improvise::IO::DictionaryReader.read(File.open(dictionary_filename, 'r'), format: format, gzip: gzip)
+        else
+            dictionary = Improvise::ForwardDictionary.new(depth)
+        end
+
+        dictionary.learn!(words)
+        Improvise::IO::DictionaryWriter.write(File.open(dictionary_filename, 'w'), dictionary, format: format, gzip: gzip)
+    end
+end
+
+desc 'Generate random words based on a dictionary'
+arg_name 'dictionary length'
+command :generate do |c|
+    c.flag [:w, :words], :desc => 'The number of words to generate', :default_value => 1, :type => Integer
+    c.flag [:r, :root], :desc => 'Root of the generated word', :type => String
+
+    c.action do |global_options, options, args|
+        if args.length < 1
+            help_now!('Dictionary argument missing.')
+        elsif args.length < 2
+            help_now!('Length argument missing.')
+        end
+
+        dictionary_filename = args[0]
+        words = options[:words]
+        root = options[:root]
+        format = global_options[:format]
+        gzip = global_options[:gzip]
+
+        begin
+            length = Integer(args[1])
+        rescue ArgumentError
+            exit_now!('Length argument is not an integer.')
+        end
+
+        dictionary = Improvise::IO::DictionaryReader.read(File.open(dictionary_filename, 'r'), format: format, gzip: gzip)
+        words.times { puts dictionary.generate_word(length, root) }
+    end
+end
+
+exit run(ARGV)

data/improvise.gemspec

@@ -0,0 +1,65 @@
+require 'improvise/version'
+
+Gem::Specification.new do |s|
+    s.specification_version = 2 if s.respond_to? :specification_version=
+    s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+    s.rubygems_version = '1.3.5'
+
+    s.name = 'improvise'
+    s.version = Improvise::VERSION
+    s.platform = Gem::Platform::RUBY
+    s.date = '2014-05-20'
+    s.authors = ['Sander Kleykens']
+    s.email = ['sander@kleykens.com']
+    s.homepage = 'http://github.com/SanderKleykens/improvise'
+    s.license = 'MIT'
+    s.summary = 'Generate random words.'
+    s.description = 'Improvise generates random words by learning from existing text.'
+
+    s.require_paths = %w[lib]
+
+    s.executables = ['improvise']
+
+    s.rdoc_options = ['--charset=UTF-8']
+    s.extra_rdoc_files = ['LICENSE', 'README.md']
+
+    s.add_dependency('gli', '~> 2.10')
+    s.add_dependency('json', '~> 1.8')
+    s.add_dependency('pickup', '>= 0.0.9', '< 1.0')
+    s.add_dependency('rubytree', '>= 0.9.3', '< 1.0')
+
+    s.add_development_dependency('rake', '~> 10.3')
+    s.add_development_dependency('rspec', '~> 2.0')
+    s.add_development_dependency('simplecov', '~> 0.8')
+    s.add_development_dependency('yard', '~> 0.8')
+
+    ## Leave this section as-is. It is automatically generated from the
+    ## contents of the Git repository via the gemspec task. DO NOT REMOVE
+    ## THE MANIFEST COMMENTS, they are used as delimiters by the task.
+    # = MANIFEST =
+    s.files = %w[
+        Gemfile
+        LICENSE
+        README.md
+        Rakefile
+        bin/improvise
+        improvise.gemspec
+        lib/improvise.rb
+        lib/improvise/dictionary.rb
+        lib/improvise/dictionarytree.rb
+        lib/improvise/forwarddictionary.rb
+        lib/improvise/io/dictionaryreader.rb
+        lib/improvise/io/dictionarywriter.rb
+        lib/improvise/io/io.rb
+        lib/improvise/version.rb
+        spec/improvise/dictionary_spec.rb
+        spec/improvise/dictionarytree_spec.rb
+        spec/improvise/forwarddictionary_spec.rb
+        spec/improvise/io/dictionaryreader_spec.rb
+        spec/improvise/io/dictionarywriter_spec.rb
+        spec/spec_helper.rb
+  ]
+    # = MANIFEST =
+
+    s.test_files = s.files.select { |path| path =~ /^spec\/*_spec.*\.rb/ }
+end

data/lib/improvise/dictionary.rb

@@ -0,0 +1,29 @@
+require 'json'
+require 'improvise/dictionarytree'
+
+module Improvise
+    class Dictionary
+        attr_reader :depth
+
+        def initialize(depth=2, tree=nil)
+            @depth = depth
+            @tree = tree || DictionaryTree.new
+        end
+
+        def as_json(opts = {})
+            {
+                JSON.create_id => self.class.name,
+                'depth' => @depth,
+                'tree' => @tree.as_json
+            }
+        end
+
+        def to_json(*a)
+            as_json.to_json(*a)
+        end
+
+        def self.json_create(json_hash)
+            new(json_hash['depth'], json_hash['tree'])
+        end
+    end
+end

data/lib/improvise/dictionarytree.rb

@@ -0,0 +1,70 @@
+require 'json'
+require 'tree'
+require 'pickup'
+
+module Improvise
+    class DictionaryTree
+        def initialize(root=nil)
+            @root = root || Tree::TreeNode.new('root')
+        end
+
+        def add_entry!(prefix, suffix)
+            prefix_node = DictionaryTree.add_node!(@root, prefix)
+            prefix_node.content += 1
+
+            suffix_node = DictionaryTree.add_node!(prefix_node, suffix)
+            suffix_node.content += 1
+        end
+
+        def random_prefix
+            DictionaryTree.new_pickup(@root).pick
+        end
+
+        def random_suffix(prefix)
+            if prefix.nil?
+                return nil
+            end
+
+            node = @root[prefix]
+
+            if node.nil?
+                return nil
+            else
+                return DictionaryTree.new_pickup(node).pick
+            end
+        end
+
+        def as_json(opts = {})
+            {
+                JSON.create_id => self.class.name,
+                'root' => @root.as_json
+            }
+        end
+
+        def to_json(*a)
+            as_json.to_json(*a)
+        end
+
+        def self.json_create(json_hash)
+            new(json_hash['root'])
+        end
+
+        private
+        def self.add_node!(root, key)
+            node = root[key]
+
+            if node.nil?
+                node = Tree::TreeNode.new(key, 0)
+                root << node
+            end
+
+            node
+        end
+
+        def self.new_pickup(node)
+            key_func = Proc.new { |item| item.name }
+            weight_func = Proc.new { |item| item.content }
+            Pickup.new(node.children, key_func: key_func, weight_func: weight_func)
+        end
+    end
+end

data/lib/improvise/forwarddictionary.rb

@@ -0,0 +1,35 @@
+require 'improvise/dictionary'
+
+module Improvise
+    class ForwardDictionary < Dictionary
+        def initialize(depth=2, tree=nil)
+            super(depth, tree)
+        end
+
+        def generate_word(length, root=nil)
+            word = root || @tree.random_prefix
+            word = word.slice(0..(length - 1))
+
+            while word.length < length do
+                suffix = @tree.random_suffix(word[[-@depth, 0].max..-1])
+                word += suffix || @tree.random_prefix
+                word = word.slice(0..(length - 1))
+            end
+
+            word
+        end
+
+        def learn!(words)
+            [*words].each do |word|
+                @tree.add_entry!('', word.slice(0..(@depth - 1)))
+
+                word.split('').each_cons(@depth + 1) do |characters|
+                    prefix = characters[0..-2].join('')
+                    suffix = characters[-1]
+
+                    @tree.add_entry!(prefix, suffix)
+                end
+            end
+        end
+    end
+end

data/lib/improvise/io/dictionaryreader.rb

@@ -0,0 +1,38 @@
+require 'json'
+require 'zlib'
+
+module Improvise
+    module IO
+        class DictionaryReader
+            attr_accessor :format, :gzip
+
+            def initialize(opts={})
+                @format = opts[:format] || :marshal
+                @gzip = opts[:gzip] || false
+            end
+
+            def read(io)
+                input = nil
+
+                if @gzip
+                    gz = Zlib::GzipReader.new(io)
+                    input = gz.read
+                    gz.close
+                else
+                    input = io.read
+                    io.close
+                end
+
+                if @format == :json
+                    return JSON.load(input)
+                else
+                    return Marshal.load(input)
+                end
+            end
+
+            def self.read(io, opts={})
+                DictionaryReader.new(opts).read(io)
+            end
+        end
+    end
+end

data/lib/improvise/io/dictionarywriter.rb

@@ -0,0 +1,38 @@
+require 'json'
+require 'zlib'
+
+module Improvise
+    module IO
+        class DictionaryWriter
+            attr_accessor :format, :gzip
+
+            def initialize(opts={})
+                @format = opts[:format] || :marshal
+                @gzip = opts[:gzip] || false
+            end
+
+            def write(io, dictionary)
+                dictionary_serialized = nil
+
+                if @format == :json
+                    dictionary_serialized = dictionary.to_json
+                else
+                    dictionary_serialized = Marshal.dump(dictionary)
+                end
+
+                if @gzip
+                    gz = Zlib::GzipWriter.new(io)
+                    gz.write(dictionary_serialized)
+                    gz.close
+                else
+                    io.write(dictionary_serialized)
+                    io.close
+                end
+            end
+
+            def self.write(io, dictionary, opts={})
+                DictionaryWriter.new(opts).write(io, dictionary)
+            end
+        end
+    end
+end

data/lib/improvise/io/io.rb

@@ -0,0 +1,2 @@
+require 'improvise/io/dictionaryreader'
+require 'improvise/io/dictionarywriter'

data/lib/improvise/version.rb

@@ -0,0 +1,3 @@
+module Improvise
+    VERSION = '0.1.0'
+end

data/lib/improvise.rb

@@ -0,0 +1,3 @@
+require 'improvise/version'
+require 'improvise/forwarddictionary'
+require 'improvise/io/io'

data/spec/improvise/dictionary_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Improvise::Dictionary do
+    before do
+        @dict1 = Improvise::Dictionary.new(1)
+        @dict2 = Improvise::Dictionary.new
+    end
+
+    it "should have depth 1" do
+        expect(@dict1.depth).to eq(1)
+    end
+
+    it "should have depth 2" do
+        expect(@dict2.depth).to eq(2)
+    end
+end

data/spec/improvise/dictionarytree_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Improvise::DictionaryTree do
+    PREFIX = 'te'
+    SUFFIX = 's'
+
+    before do
+        @empty_tree = Improvise::DictionaryTree.new
+    end
+
+    it "should return nil as random prefix if the tree is empty" do
+        expect(@empty_tree.random_prefix).to eq(nil)
+    end
+
+    it "should return nil as random suffix if the prefix hasn't been found" do
+        expect(@empty_tree.random_suffix('test')).to eq(nil)
+    end
+
+    it "should return nil as random suffix if the prefix is nil" do
+        expect(@empty_tree.random_suffix(nil)).to eq(nil)
+    end
+
+    it "should return '#{PREFIX}'" do
+        tree = Improvise::DictionaryTree.new
+        tree.add_entry!(PREFIX, SUFFIX)
+
+        expect(tree.random_prefix).to eq(PREFIX)
+    end
+
+    it "should return '#{SUFFIX}'" do
+        tree = Improvise::DictionaryTree.new
+        tree.add_entry!(PREFIX, SUFFIX)
+        tree.add_entry!('aa', 's')
+
+        expect(tree.random_suffix(PREFIX)).to eq(SUFFIX)
+    end
+end

data/spec/improvise/forwarddictionary_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Improvise::ForwardDictionary do
+    before do
+        @dict1 = Improvise::ForwardDictionary.new(1)
+        @dict2 = Improvise::ForwardDictionary.new
+    end
+
+    it "should have depth 1" do
+        expect(@dict1.depth).to eq(1)
+    end
+
+    it "should have depth 2" do
+        expect(@dict2.depth).to eq(2)
+    end
+
+    it "should generate 'te' using depth 1" do
+        @dict1.learn!('te')
+        expect(@dict1.generate_word(2, 't')).to eq('te')
+    end
+
+    it "should generate 'te' using depth 2" do
+        @dict2.learn!('te')
+        expect(@dict2.generate_word(2)).to eq('te')
+    end
+
+    it "should generate 'tes' using depth 2" do
+        @dict2.learn!('tes')
+        expect(@dict2.generate_word(3, 'te')).to eq('tes')
+    end
+end

data/spec/improvise/io/dictionaryreader_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'stringio'
+
+describe Improvise::IO::DictionaryReader do
+    before do
+        json = '{
+                  "json_class": "Improvise::ForwardDictionary",
+                  "depth": 2,
+                  "tree": {
+                    "json_class": "Improvise::DictionaryTree",
+                    "root": {
+                      "name": "root",
+                      "content": null,
+                      "json_class": "Tree::TreeNode",
+                      "children": [
+                        {
+                          "name": "",
+                          "content": 1,
+                          "json_class": "Tree::TreeNode",
+                          "children": [
+                            {
+                              "name": "te",
+                              "content": 1,
+                              "json_class": "Tree::TreeNode"
+                            }
+                          ]
+                        },
+                        {
+                          "name": "te",
+                          "content": 1,
+                          "json_class": "Tree::TreeNode",
+                          "children": [
+                            {
+                              "name": "s",
+                              "content": 1,
+                              "json_class": "Tree::TreeNode"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  }
+                }'
+
+        @json_buffer = StringIO.new(json)
+        @json_reader = Improvise::IO::DictionaryReader.new(format: :json)
+    end
+
+    it "should read json input correctly" do
+        dict = @json_reader.read(@json_buffer)
+        expect(dict).to be_a(Improvise::ForwardDictionary)
+        expect(dict.depth).to eq(2)
+        expect(dict.generate_word(3)).to eq('tes')
+    end
+
+    it "should read json input correctly (class method)" do
+        dict = Improvise::IO::DictionaryReader.read(@json_buffer, format: :json)
+        expect(dict).to be_a(Improvise::ForwardDictionary)
+        expect(dict.depth).to eq(2)
+        expect(dict.generate_word(3)).to eq('tes')
+    end
+end

data/spec/improvise/io/dictionarywriter_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'stringio'
+
+describe Improvise::IO::DictionaryWriter do
+    before do
+        @dict = Improvise::ForwardDictionary.new(1)
+        @dict.learn!('tes')
+
+        @JSON = '{"json_class":"Improvise::ForwardDictionary","depth":1,"tree":{"json_class":"Improvise::DictionaryTree","root":{"name":"root","content":null,"json_class":"Tree::TreeNode","children":[{"name":"","content":1,"json_class":"Tree::TreeNode","children":[{"name":"t","content":1,"json_class":"Tree::TreeNode"}]},{"name":"t","content":1,"json_class":"Tree::TreeNode","children":[{"name":"e","content":1,"json_class":"Tree::TreeNode"}]},{"name":"e","content":1,"json_class":"Tree::TreeNode","children":[{"name":"s","content":1,"json_class":"Tree::TreeNode"}]}]}}}'
+        @buffer = StringIO.new
+
+        @json_writer = Improvise::IO::DictionaryWriter.new(format: :json)
+        @json_gzip_writer = Improvise::IO::DictionaryWriter.new(format: :json, gzip: true)
+        @marshal_writer = Improvise::IO::DictionaryWriter.new
+        @marshal_gzip_writer = Improvise::IO::DictionaryWriter.new(gzip: true)
+    end
+
+    it "should write in json format correctly" do
+        @json_writer.write(@buffer, @dict)
+        expect(@buffer.string).to eq(@JSON)
+        expect(@buffer.closed?).to be true
+    end
+
+    it "should write in json format correctly (class method)" do
+        Improvise::IO::DictionaryWriter.write(@buffer, @dict, format: :json)
+        expect(@buffer.string).to eq(@JSON)
+        expect(@buffer.closed?).to be true
+    end
+
+    it "should write in marshal format" do
+        @marshal_writer.write(@buffer, @dict)
+        expect(@buffer.size).to be > 0
+        expect(@buffer.closed?).to be true
+    end
+
+    it "should write in marshal format (class method)" do
+        Improvise::IO::DictionaryWriter.write(@buffer, @dict)
+        expect(@buffer.size).to be > 0
+        expect(@buffer.closed?).to be true
+    end
+
+    it "should write in gzipped json format" do
+        @json_gzip_writer.write(@buffer, @dict)
+        expect(@buffer.size).to be > 0
+        expect(@buffer.closed?).to be true
+    end
+
+    it "should write in gzipped json format (class method)" do
+        Improvise::IO::DictionaryWriter.write(@buffer, @dict, format: :json, gzip: true)
+        expect(@buffer.size).to be > 0
+        expect(@buffer.closed?).to be true
+    end
+
+    it "should write in gzipped marshal format" do
+        @marshal_gzip_writer.write(@buffer, @dict)
+        expect(@buffer.size).to be > 0
+        expect(@buffer.closed?).to be true
+    end
+
+    it "should write in gzipped marshal format (class method)" do
+        Improvise::IO::DictionaryWriter.write(@buffer, @dict, gzip: true)
+        expect(@buffer.size).to be > 0
+        expect(@buffer.closed?).to be true
+    end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+if ENV['COVERAGE']
+    require 'simplecov'
+
+    SimpleCov.start do 
+        add_filter('spec')
+
+        add_group('Library', 'lib')
+    end
+end
+
+require 'rspec'
+require 'improvise'

metadata

@@ -0,0 +1,193 @@
+--- !ruby/object:Gem::Specification
+name: improvise
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sander Kleykens
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: pickup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.9
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.9
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubytree
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: Improvise generates random words by learning from existing text.
+email:
+- sander@kleykens.com
+executables:
+- improvise
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/improvise
+- improvise.gemspec
+- lib/improvise.rb
+- lib/improvise/dictionary.rb
+- lib/improvise/dictionarytree.rb
+- lib/improvise/forwarddictionary.rb
+- lib/improvise/io/dictionaryreader.rb
+- lib/improvise/io/dictionarywriter.rb
+- lib/improvise/io/io.rb
+- lib/improvise/version.rb
+- spec/improvise/dictionary_spec.rb
+- spec/improvise/dictionarytree_spec.rb
+- spec/improvise/forwarddictionary_spec.rb
+- spec/improvise/io/dictionaryreader_spec.rb
+- spec/improvise/io/dictionarywriter_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/SanderKleykens/improvise
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset=UTF-8"
+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.2.2
+signing_key: 
+specification_version: 2
+summary: Generate random words.
+test_files: []
+has_rdoc: