sparkey 0.0.1 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1d02b7853fe52790fde3dd206f8af7febc4c01f8
+  data.tar.gz: 34f41f81cbf31b608fa6faed0ba9b252c1e4b1b8
+SHA512:
+  metadata.gz: 2719e8fd06e6f6d108f5eab7a856a37fafddfafa712b8daff293315293d458c56709a26e6891b68ffdbefd122affad22b8d6e8a79b498e4bbcece8222591c965
+  data.tar.gz: 81397ce7bf58162b23ad076d2334a1acb63d8064f9cf6bc12da2e71eaa4b3d5ab8fda1c10b84d237437904557c54bd3fee7d529f769694bcb486a647ec0e06a0

data/Rakefile

@@ -1 +1,8 @@
 require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+task default: :test

data/lib/sparkey.rb

@@ -1,5 +1,20 @@
-require "sparkey/version"
+require "ffi"
 
 module Sparkey
-  # Your code goes here...
+  def self.create(filename)
+    Store.create(filename)
+  end
+
+  def self.open(filename)
+    Store.open(filename)
+  end
 end
+
+require "sparkey/native"
+require "sparkey/errors"
+require "sparkey/store"
+require "sparkey/log_writer"
+require "sparkey/log_reader"
+require "sparkey/log_iterator"
+require "sparkey/hash_writer"
+require "sparkey/hash_reader"

data/lib/sparkey/errors.rb

@@ -0,0 +1,11 @@
+class Sparkey::Error < StandardError; end
+
+module Sparkey::Errors
+  def handle_status(status)
+    if status != :success
+      error_message = Sparkey::Native.error_string(status)
+
+      raise Sparkey::Error, error_message
+    end
+  end
+end

data/lib/sparkey/hash_reader.rb

@@ -0,0 +1,49 @@
+class Sparkey::HashReader
+  include Sparkey::Errors
+
+  def open(filename)
+    hash_filename = "#{filename}.spi"
+    log_filename = "#{filename}.spl"
+    ptr = FFI::MemoryPointer.new(:pointer)
+
+    handle_status Sparkey::Native.hash_open(ptr, hash_filename, log_filename)
+
+    @hash_reader_ptr = ptr.get_pointer(0)
+  end
+
+  def close
+    ptr = FFI::MemoryPointer.new(:pointer)
+    ptr.put_pointer(0, @hash_reader_ptr)
+
+    Sparkey::Native.hash_close(ptr)
+  end
+
+  def seek(key)
+    iterator = Sparkey::LogIterator.new(log_reader)
+
+    key_length = key.size
+    key_ptr = FFI::MemoryPointer.new(:uint8, key_length)
+    key_ptr.put_bytes(0, key)
+
+    handle_status Sparkey::Native.hash_get(@hash_reader_ptr, key_ptr, key_length, iterator.ptr)
+
+    iterator
+  end
+
+  def size
+    Sparkey::Native.hash_numentries(@hash_reader_ptr)
+  end
+
+  def log_reader
+    reader_ptr = Sparkey::Native.hash_getreader(@hash_reader_ptr)
+
+    log_reader = Sparkey::LogReader.new
+    log_reader.ptr = reader_ptr
+
+    log_reader
+  end
+
+  def ptr
+    @hash_reader_ptr
+  end
+end

data/lib/sparkey/hash_writer.rb

@@ -0,0 +1,10 @@
+class Sparkey::HashWriter
+  include Sparkey::Errors
+
+  def create(filename)
+    log_filename = "#{filename}.spl"
+    index_filename = "#{filename}.spi"
+
+    handle_status Sparkey::Native.hash_write(index_filename, log_filename, 0)
+  end
+end

data/lib/sparkey/log_iterator.rb

@@ -0,0 +1,81 @@
+class Sparkey::LogIterator
+  include Sparkey::Errors
+
+  def initialize(log_reader, hash_reader = nil)
+    @log_reader = log_reader
+    @hash_reader = hash_reader
+
+    ptr = FFI::MemoryPointer.new(:pointer)
+
+    handle_status Sparkey::Native.logiter_create(ptr, @log_reader.ptr)
+
+    @log_iter_ptr = ptr.get_pointer(0)
+  end
+
+  def next
+    handle_status Sparkey::Native.logiter_next(@log_iter_ptr, @log_reader.ptr)
+  end
+
+  def hash_next
+    handle_status Sparkey::Native.logiter_hashnext(@log_iter_ptr, @hash_reader.ptr)
+  end
+
+  def state
+    Sparkey::Native.logiter_state(@log_iter_ptr)
+  end
+
+  def type
+    Sparkey::Native.logiter_type(@log_iter_ptr)
+  end
+
+  def <=>(iterator)
+    ptr = FFI::MemoryPointer.new(:int, 1)
+
+    handle_status Sparkey::Native.logiter_keycmp(@log_iter_ptr, interator.ptr, @log_reader.ptr, ptr)
+
+    ptr.read_int
+  end
+
+  def active?
+    state == :iter_active
+  end
+
+  def key_length
+    Sparkey::Native.logiter_keylen(@log_iter_ptr)
+  end
+
+  def value_length
+    Sparkey::Native.logiter_valuelen(@log_iter_ptr)
+  end
+
+  def get_key
+    wanted_key_length = key_length
+    key_ptr = FFI::MemoryPointer.new(:uint8, wanted_key_length)
+    actual_key_length_ptr = FFI::MemoryPointer.new(:uint64, 1)
+
+    handle_status Sparkey::Native.logiter_fill_key(@log_iter_ptr, @log_reader.ptr, wanted_key_length, key_ptr, actual_key_length_ptr)
+
+    key_ptr.read_bytes(actual_key_length_ptr.read_uint64)
+  end
+
+  def get_value
+    wanted_value_length = value_length
+    value_ptr = FFI::MemoryPointer.new(:uint8, wanted_value_length)
+    actual_value_length_ptr = FFI::MemoryPointer.new(:uint64, 1)
+
+    handle_status Sparkey::Native.logiter_fill_value(@log_iter_ptr, @log_reader.ptr, wanted_value_length, value_ptr, actual_value_length_ptr)
+
+    value_ptr.read_bytes(actual_value_length_ptr.read_uint64)
+  end
+
+  def close
+    ptr = FFI::MemoryPointer.new(:pointer)
+    ptr.put_pointer(0, @log_iter_ptr)
+
+    Sparkey::Native.logiter_close(ptr)
+  end
+
+  def ptr
+    @log_iter_ptr
+  end
+end

data/lib/sparkey/log_reader.rb

@@ -0,0 +1,35 @@
+class Sparkey::LogReader
+  include Sparkey::Errors
+
+  def open(filename)
+    log_filename = "#{filename}.spl"
+    ptr = FFI::MemoryPointer.new(:pointer)
+
+    handle_status Sparkey::Native.logreader_open(ptr, log_filename)
+
+    @log_reader_ptr = ptr.get_pointer(0)
+  end
+
+  def close
+    ptr = FFI::MemoryPointer.new(:pointer)
+    ptr.put_pointer(0, @log_reader_ptr)
+
+    Sparkey::Native.logreader_close(ptr)
+  end
+
+  def max_key_length
+    Sparkey::Native.logreader_maxkeylen(@log_reader_ptr)
+  end
+
+  def max_value_length
+    Sparkey::Native.logreader_maxvaluelen(@log_reader_ptr)
+  end
+
+  def ptr=(ptr)
+    @log_reader_ptr = ptr
+  end
+
+  def ptr
+    @log_reader_ptr
+  end
+end

data/lib/sparkey/log_writer.rb

@@ -0,0 +1,51 @@
+class Sparkey::LogWriter
+  include Sparkey::Errors
+
+  def create(filename, compression, block_size)
+    ptr = FFI::MemoryPointer.new(:pointer)
+    log_filename = "#{filename}.spl"
+
+    handle_status Sparkey::Native.logwriter_create(ptr, log_filename, compression, block_size)
+
+    @log_writer_ptr = ptr.get_pointer(0)
+  end
+
+  def open(filename)
+    ptr = FFI::MemoryPointer.new(:pointer)
+    log_filename = "#{filename}.spl"
+
+    handle_status Sparkey::Native.logwriter_append(ptr, log_filename)
+    @log_writer_ptr = ptr.get_pointer(0)
+  end
+
+  def put(key, value)
+    key_length = key.bytesize
+    key_ptr = FFI::MemoryPointer.new(:uint8, key_length)
+    key_ptr.put_bytes(0, key)
+
+    value_length = value.bytesize
+    value_ptr = FFI::MemoryPointer.new(:uint8, value_length)
+    value_ptr.put_bytes(0, value)
+
+    handle_status Sparkey::Native.logwriter_put(@log_writer_ptr, key_length, key_ptr, value_length, value_ptr)
+  end
+
+  def delete(key)
+    key_length = key.bytesize
+    key_ptr = FFI::MemoryPointer.new(:uint8, key_length)
+    key_ptr.put_bytes(0, key)
+
+    handle_status Sparkey::Native.logwriter_delete(@log_writer_ptr, key_length, key_ptr)
+  end
+
+  def flush
+    handle_status Sparkey::Native.logwriter_flush(@log_writer_ptr)
+  end
+
+  def close
+    ptr = FFI::MemoryPointer.new(:pointer)
+    ptr.put_pointer(0, @log_writer_ptr)
+
+    Sparkey::Native.logwriter_close(ptr)
+  end
+end

data/lib/sparkey/native.rb

@@ -0,0 +1,98 @@
+module Sparkey::Native
+  extend FFI::Library
+
+  ffi_lib ["libsparkey"]
+
+  RETURN_CODE = enum :success, 0,
+                     :internal_error, -1,
+
+                     :file_not_found, -100,
+                     :permission_denied, -101,
+                     :too_many_open_files, -102,
+                     :file_too_large, -103,
+                     :file_already_exists, -104,
+                     :file_busy, -105,
+                     :file_is_directory, -106,
+                     :file_size_exceeded, -107,
+                     :file_closed, -108,
+                     :out_of_disk, -109,
+                     :unexpected_eof, -110,
+                     :mmap_failed, -111,
+
+                     :wrong_log_magic_number, -200,
+                     :wrong_log_major_version, -201,
+                     :unsupported_log_minor_version, -202,
+                     :log_too_small, -203,
+                     :log_closed, -204,
+                     :log_iterator_inactive, -205,
+                     :log_iterator_mismatch, -206,
+                     :log_iterator_closed, -207,
+                     :log_header_corrupt, -208,
+                     :invalid_compression_block_size, -209,
+                     :invalid_compression_type, -210,
+
+                     :wrong_hash_magic_number, -300,
+                     :wrong_hash_major_version, -301,
+                     :unsupported_hash_minor_version, -302,
+                     :hash_too_small, -303,
+                     :hash_closed, -304,
+                     :file_identifier_mismatch, -305,
+                     :hash_header_corrupt, -306,
+                     :hash_size_invalid, -307
+
+  COMPRESSION_TYPE = enum :compression_none,
+                          :compression_snappy
+
+  ENTRY_TYPE = enum :entry_put,
+                    :entry_delete
+
+  ITER_STATE = enum :iter_new,
+                    :iter_active,
+                    :iter_closed,
+                    :iter_invalid
+
+
+  attach_function :logwriter_create, :sparkey_logwriter_create, [:pointer, :string, COMPRESSION_TYPE, :int], RETURN_CODE
+  attach_function :logwriter_append, :sparkey_logwriter_append, [:pointer, :string], RETURN_CODE
+
+  attach_function :logwriter_put, :sparkey_logwriter_put, [:pointer, :uint64, :pointer, :uint64, :pointer], RETURN_CODE
+  attach_function :logwriter_delete, :sparkey_logwriter_delete, [:pointer, :uint64, :pointer], RETURN_CODE
+
+  attach_function :logwriter_flush, :sparkey_logwriter_flush, [:pointer], RETURN_CODE
+  attach_function :logwriter_close, :sparkey_logwriter_close, [:pointer], RETURN_CODE
+
+  attach_function :logreader_open, :sparkey_logreader_open, [:pointer, :string], RETURN_CODE
+  attach_function :logreader_close, :sparkey_logreader_close, [:pointer], :void
+  attach_function :logreader_maxkeylen, :sparkey_logreader_maxkeylen, [:pointer], :uint64
+  attach_function :logreader_maxvaluelen, :sparkey_logreader_maxvaluelen, [:pointer], :uint64
+
+  attach_function :logiter_create, :sparkey_logiter_create, [:pointer, :pointer], RETURN_CODE
+  attach_function :logiter_close, :sparkey_logiter_close, [:pointer], :void
+  attach_function :logiter_seek, :sparkey_logiter_seek, [:pointer, :pointer, :uint64], RETURN_CODE
+  attach_function :logiter_skip, :sparkey_logiter_skip, [:pointer, :pointer, :int], RETURN_CODE
+  attach_function :logiter_next, :sparkey_logiter_next, [:pointer, :pointer], RETURN_CODE
+  attach_function :logiter_reset, :sparkey_logiter_reset, [:pointer, :pointer], RETURN_CODE
+  attach_function :logiter_keychunk, :sparkey_logiter_keychunk, [:pointer, :pointer, :uint64, :pointer, :pointer], RETURN_CODE
+  attach_function :logiter_valuechunk, :sparkey_logiter_valuechunk, [:pointer, :pointer, :uint64, :pointer, :pointer], RETURN_CODE
+  attach_function :logiter_fill_key, :sparkey_logiter_fill_key, [:pointer, :pointer, :uint64, :pointer, :pointer], RETURN_CODE
+  attach_function :logiter_fill_value, :sparkey_logiter_fill_value, [:pointer, :pointer, :uint64, :pointer, :pointer], RETURN_CODE
+  attach_function :logiter_keycmp, :sparkey_logiter_keycmp, [:pointer, :pointer, :pointer, :pointer], RETURN_CODE
+  attach_function :logiter_state, :sparkey_logiter_state, [:pointer], ITER_STATE
+  attach_function :logiter_type, :sparkey_logiter_type, [:pointer], ENTRY_TYPE
+  attach_function :logiter_keylen, :sparkey_logiter_keylen, [:pointer], :uint64
+  attach_function :logiter_valuelen, :sparkey_logiter_valuelen, [:pointer], :uint64
+  attach_function :logiter_hashnext, :sparkey_logiter_hashnext, [:pointer, :pointer], RETURN_CODE
+  attach_function :logiter_close, :sparkey_logiter_close, [:pointer], :void
+
+  attach_function :hash_write, :sparkey_hash_write, [:pointer, :string, :int], RETURN_CODE
+  attach_function :hash_open, :sparkey_hash_open, [:pointer, :string, :string], RETURN_CODE
+  attach_function :hash_getreader, :sparkey_hash_getreader, [:pointer], :pointer
+  attach_function :hash_close, :sparkey_hash_close, [:pointer], :void
+  attach_function :hash_get, :sparkey_hash_get, [:pointer, :pointer, :uint64, :pointer], RETURN_CODE
+  attach_function :hash_numentries, :sparkey_hash_numentries, [:pointer], :uint64
+  attach_function :hash_numcollisions, :sparkey_hash_numcollisions, [:pointer], :uint64
+
+  attach_function :create_log_filename, :sparkey_create_log_filename, [:string], :string
+
+  attach_function :error_string, :sparkey_errstring, [RETURN_CODE], :string
+end

data/lib/sparkey/store.rb

@@ -0,0 +1,108 @@
+class Sparkey::Store
+  attr_accessor :filename, :log_writer, :log_reader,
+    :hash_writer, :hash_reader
+
+  def self.create(filename, compression_type = :compression_none, block_size = 1000)
+    store = new(filename)
+
+    store.log_writer = Sparkey::LogWriter.new
+    store.log_writer.create(filename, compression_type, block_size)
+
+    store.log_reader = Sparkey::LogReader.new
+    store.log_reader.open(filename)
+
+    store.hash_writer = Sparkey::HashWriter.new
+    store.hash_writer.create(filename)
+
+    store.hash_reader = Sparkey::HashReader.new
+    store.hash_reader.open(filename)
+
+    store
+  end
+
+  def self.open(filename)
+    store = new(filename)
+
+    store.log_writer = Sparkey::LogWriter.new
+    store.log_writer.open(filename)
+
+    store.log_reader = Sparkey::LogReader.new
+    store.log_reader.open(filename)
+
+    store.hash_writer = Sparkey::HashWriter.new
+    store.hash_writer.create(filename)
+
+    store.hash_reader = Sparkey::HashReader.new
+    store.hash_reader.open(filename)
+
+    store
+  end
+
+  def initialize(filename)
+    @filename = filename
+  end
+
+  def close
+    log_writer.close
+    log_reader.close
+    hash_reader.close
+  end
+
+  def size
+    hash_reader.size
+  end
+
+  def get(key)
+    iterator = hash_reader.seek(key)
+
+    iterator.get_value
+  end
+
+  def each_from_hash
+    log_reader = hash_reader.log_reader
+    iterator = Sparkey::LogIterator.new(log_reader, hash_reader)
+
+    loop do
+      iterator.hash_next
+
+      break unless iterator.active?
+
+      yield iterator.get_key, iterator.get_value
+    end
+
+    iterator.close
+  end
+  alias_method :each, :each_from_hash
+
+  def each_from_log
+    iterator = Sparkey::LogIterator.new(log_reader)
+
+    loop do
+      iterator.next
+
+      break unless iterator.active?
+
+      yield iterator.get_key, iterator.get_value
+    end
+
+    iterator.close
+  end
+
+  def put(key, value)
+    log_writer.put(key, value)
+  end
+
+  def delete(key)
+    log_writer.delete(key)
+  end
+
+  def flush
+    yield self if block_given?
+
+    log_writer.flush
+
+    # Reset the hash headers
+    hash_writer.create(filename)
+    hash_reader.open(filename)
+  end
+end

data/lib/sparkey/testing.rb

@@ -0,0 +1,15 @@
+require "securerandom"
+
+module Sparkey::Testing
+  def random_filename
+    "test-#{SecureRandom.hex(16)}"
+  end
+
+  def delete(filename)
+    log_file = "#{filename}.spl"
+    index_file = "#{filename}.spi"
+
+    File.delete(log_file)   if File.exists?(log_file)
+    File.delete(index_file) if File.exists?(index_file)
+  end
+end

data/sparkey.gemspec

@@ -1,23 +1,23 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'sparkey/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "sparkey"
-  spec.version       = Sparkey::VERSION
+  spec.version       = "1.0.0"
   spec.authors       = ["Adam Tanner"]
   spec.email         = ["adam@adamtanner.org"]
-  spec.description   = %q{Ruby FFI bindings for Spotify's Sparkey}
-  spec.summary       = %q{Ruby FFI bindings for Spotify's Sparkey}
-  spec.homepage      = ""
+  spec.description   = %{ Ruby FFI bindings for Spotify's Sparkey }
+  spec.summary       = %{ Ruby FFI bindings for Spotify's Sparkey }
+  spec.homepage      = "https://github.com/adamtanner/sparkey"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.test_files    = spec.files.grep(%r{^spec/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "ffi"
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
 end

data/spec/sparkey_spec.rb

@@ -0,0 +1,38 @@
+require "minitest/autorun"
+require "sparkey"
+require "sparkey/testing"
+
+describe Sparkey do
+  include Sparkey::Testing
+
+  before { @filename = random_filename }
+  after  { delete(@filename) }
+
+  it "functions as a key value store" do
+    sparkey = Sparkey::Store.create(@filename, :compression_snappy, 1000)
+    sparkey.put("first", "Michael")
+    sparkey.put("second", "Adam")
+    sparkey.put("third", "Tanner")
+    sparkey.close
+
+    sparkey = Sparkey::Store.open(@filename)
+
+    sparkey.size.must_equal 3
+
+    sparkey.get("first").must_equal("Michael")
+    sparkey.delete("second")
+    sparkey.flush
+
+    sparkey.size.must_equal 2
+
+    hash = Hash.new
+    sparkey.each do |key, value|
+      hash[key] = value
+    end
+
+    hash.must_equal(
+      "first" => "Michael",
+      "third" => "Tanner"
+    )
+  end
+end

metadata

@@ -1,20 +1,32 @@
 --- !ruby/object:Gem::Specification
 name: sparkey
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 1.0.0
 platform: ruby
 authors:
 - Adam Tanner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-02 00:00:00.000000000 Z
+date: 2013-11-17 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -22,7 +34,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -30,20 +41,18 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Ruby FFI bindings for Spotify's Sparkey
+description: ' Ruby FFI bindings for Spotify''s Sparkey '
 email:
 - adam@adamtanner.org
 executables: []
@@ -53,41 +62,43 @@ files:
 - .gitignore
 - Gemfile
 - LICENSE
-- LICENSE.txt
 - README.md
 - Rakefile
 - lib/sparkey.rb
-- lib/sparkey/version.rb
+- lib/sparkey/errors.rb
+- lib/sparkey/hash_reader.rb
+- lib/sparkey/hash_writer.rb
+- lib/sparkey/log_iterator.rb
+- lib/sparkey/log_reader.rb
+- lib/sparkey/log_writer.rb
+- lib/sparkey/native.rb
+- lib/sparkey/store.rb
+- lib/sparkey/testing.rb
 - sparkey.gemspec
-homepage: ''
+- spec/sparkey_spec.rb
+homepage: https://github.com/adamtanner/sparkey
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 71288456881923243
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 71288456881923243
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Ruby FFI bindings for Spotify's Sparkey
-test_files: []
+test_files:
+- spec/sparkey_spec.rb

data/LICENSE.txt

@@ -1,22 +0,0 @@
-Copyright (c) 2013 Adam Tanner
-
-MIT License
-
-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/lib/sparkey/version.rb

@@ -1,3 +0,0 @@
-module Sparkey
-  VERSION = "0.0.1"
-end