nosequel 1.0.0.pre.alpha.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fc76411b87eef119504bbf126033ff7809ed3f88
+  data.tar.gz: 1004767c7e3a39f7b0b62a904ead2b3aa4c22dca
+SHA512:
+  metadata.gz: ec9c5d986287a91f05c8c7f856e544c1a3c107b317c704a480d405b5f3ec499443a818cd664ad97326ed830e2b5b55a1335756ba05fc7b5a9ea96c3f9a5d10ee
+  data.tar.gz: 108f4a439489346f2dc1bf5f34c0211e2408e92d57f971e5968f7d9bdf19384cb32c8ec6e65826c307b47b31882dfe45cffec29994407af677721f4a7a1556b2

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+*.db
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p247

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in nosequel.gemspec
+gemspec
+
+group :test do
+  gem 'rake'
+  gem 'minitest', '~> 4.2.0'
+  gem 'minitest-reporters'
+  gem 'sqlite3'
+end
+
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Donovan C. Young
+
+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/README.md

@@ -0,0 +1,96 @@
+NoSequel
+========
+What is it?
+-----------
+NoSequel provides a simple, pure ruby, key/value data storage container using a persistent database powered by the Sequel O/RM system by Sharon Rosner and Jeremy Evans.
+
+How do I use it?
+------------------
+Glad you asked!
+
+### Install it
+
+Add this line to your application's Gemfile:
+
+    gem 'nosequel'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nosequel
+
+#### Register it
+```ruby
+require 'nosequel'
+
+# Here, our app is using a table named ':my_store', but this could be anything
+# that's meaningful to you.  It doesn't matter if this table already exists.
+# If it does, any data stored will be available in the container.
+# If not, it will be created on the fly.  Neato!
+container = NoSequel.register(:my_store)
+```
+
+This sets up a `container` which acts as your primary data store.  Then, all you need to do is...
+
+#### Use it
+```ruby
+container[:some_key] = "Some value I care about"
+```
+
+That's all there is to it, easy peasy ~~Japanesey~~! *[appologies to my East Asian friends, I mean no offense]*
+
+Once registered, your container is a simple, persistent, HASH-like storage system. Use it to store any object you want to persist between runs of you ruby code.  Yup! That's right! You can store just about any Object in your container for later retrieval between runs, or even from another program altogether -- the registration name is the key.
+
+If the value you're storing isn't already a String, we'll serialize it before saving and deserialize it upon retrieval.  Cool, huh?
+
+Behind the scenes, we're actually writing your data to a database (specifically, in a table named `my_store` in our example).  We (and by _we_, I mean Sequel) only read and write to the database when we absolutely have to, so it keeps disk access down to a minimum.  It's also thread-safe, so... YAY!
+
+#### Configure it
+The defaults (`sqlite`) are going to work pretty well for most people, but hey, if you want to change the database options, go for it!
+
+##### Here's how...
+Send in a hash with the options you would like to change along with your call to #register.  Yup, that's it.
+
+|  Item  | Description  | Default Value  |
+|:------:|:-------------|:---------------|
+| db_type | The database type (sqlite, mysql, postgres, etc.) -- see [Sequel Gem](http://sequel.rubyforge.org/rdoc-adapters/index.html) for complete options. | sqlite |
+| db_name | The name of the database (or file, depending on type) | data.db |
+| db_user | The database user[:password] to use. | none |
+| db_host | The database host[:port] to use. | localhost |
+
+##### Like This...
+```ruby
+container = NoSequel.register(
+    :my_plugin,
+    db_name: 'mydb',
+    db_type: 'mysql',
+    db_user: 'myname',
+    db_host: 'localhost'
+)
+```
+
+### Notes
+***Hey, you should probably know that we're under development, so this information may or may not be lying to you, however the core public interface should be relatively stable.***
+
+Since NoSequel relies on [Sequel](https://github.com/jeremyevans/sequel) to provide the back-end database support, it **only** supports what they do.  Our goal is to keep this gem lightweight, so if you want to use some fancy new (or anciently old) database model that they don't (yet) support, 'tuff noogies -- go whine to them.  :-)
+
+
+Other Stuff you might want to know
+----------------------------------
+### Who's Involved with this?
+- [Donovan C. Young](https://github.com/dyoung522)
+
+### Help (I need somebody)!
+You can email me directly via dyoung522 at gmail.com or find me lurking somewhere on irc.freenode.net (as dyoung522)
+
+### How can I help?
+If you wish NoSequel could act in a particular way, or had some cool new feature it's missing, by all means, [let me know!](mailto:dyoung522@gmail.com), or better yet...
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+
+task :default => 'test'
+
+desc 'Run all Minitest tests'
+task :test do
+    ruby 'test/all_tests.rb'
+end

data/lib/nosequel.rb

@@ -0,0 +1,73 @@
+# The idea is to add a NoSQL interface for the Sequel OR/M
+#
+# Author::    Donovan C. Young  (mailto:dyoung522@gmail.com)
+# Copyright:: Copyright (c) 2013 Donovan C. Young
+# License::   MIT
+#
+# :include:LICENSE.txt
+
+require 'nosequel/version'
+require 'nosequel/configuration'
+require 'nosequel/container'
+
+# Module methods
+module NoSequel
+
+  # Creates or Retrieves and returns a container object
+  #
+  # == Parameters:
+  # === Required:
+  # table::
+  #   A string or symbol referencing the table name to use
+  #
+  # === Optional:
+  # db_type::
+  #   The database type (defaults to sqlite3)
+  #
+  # db_name::
+  #   The database name (or file) to use
+  #
+  # db_user::
+  #   The database user (along with optional :password, if necessary)
+  #
+  # db_host::
+  #   The database host (defaults to localhost)
+  #
+  # == Returns:
+  # A NoSequel::Container object
+  #
+  def self.register( table, config = {} )
+    # Create the Sequel connection
+    #Container.new(@sequel, table)
+    @config = Configuration.new(config)
+    @sequel = @config.sequel
+    Container.new( @sequel, table )
+  end
+
+  # Permanently deletes table from the underlying database
+  #
+  def self.drop( table )
+    raise RuntimeError, 'You must call register first' unless @sequel
+    # Drop the table
+    @sequel.drop_table( table.to_sym ) if exists?(table)
+  end
+
+  # Drops the database table and deletes the local file (if it exists)
+  #
+  def self.drop!( table )
+    drop( table )
+
+    # Remove the file (if any)
+    File.unlink(@config.db_name) if File.exists?(@config.db_name)
+  end
+
+  # Tests if a table already exists in the database
+  # == Returns:
+  # true or false
+  #
+  def self.exists?( table )
+    raise RuntimeError, 'You must call register first' unless @sequel
+    @sequel.table_exists?( table.to_sym )
+  end
+
+end

data/lib/nosequel/configuration.rb

@@ -0,0 +1,69 @@
+require 'sequel'
+
+# NoSequel::Configuration class
+module NoSequel
+  class Configuration
+    attr_accessor :db_type , :db_name, :db_user, :db_host
+
+    # NoSequel::Configuration constructor
+    #
+    # == Returns:
+    # A Configuration object which holds the user supplied config along with class defaults.
+    #
+    def initialize( opts = {} )
+      config = default_config.merge(opts)
+      config.each do |key, value|
+        self.send("#{key}=", value) if self.respond_to?(key)
+      end
+    end
+
+    # Create and return an active Sequel object
+    # == Returns:
+    # A Sequel Object
+    #
+    def sequel
+      Sequel.connect( sequel_url )
+    end
+
+    private
+
+    # Converts the object into a textual string that can be sent to sequel
+    #
+    # == Returns:
+    # A string representing the object in a sequel-connect string format
+    #
+    def sequel_url
+
+      return '' unless db_type
+
+      # Start our connection string
+      connect_string = db_type + '://'
+
+      # Add user:password if supplied
+      unless db_user.nil?
+        connect_string += db_user
+
+        # Add either a @ or / depending on if a host was provided too
+        connect_string += db_host ? '@' : '/'
+
+        # Add host:port if supplied
+        connect_string += db_host + '/' if db_host
+      end
+
+      connect_string + db_name
+    end
+
+    #
+    # Reasonable defaults for the Object
+    #
+    def default_config
+      {
+          db_type: 'sqlite',    # Any database connector supported by the Sequel gem
+          db_name: 'data.db',   # The name of the database (or file) to use
+          db_user: nil,         # The database user and optional password (user:password)
+          db_host: 'localhost'  # The database host and options port (host:port)
+      }
+    end
+
+  end
+end

data/lib/nosequel/container.rb

@@ -0,0 +1,112 @@
+require 'yaml'
+
+# NoSequel::Container class
+module NoSequel
+  class Container
+
+    # NoSequel::Container constructor
+    # called via NoSequel.register(:table)
+    # == Parameters:
+    # db::
+    #   Sequel object
+    # table::
+    #   The Sequel database table
+    #
+    # == Returns:
+    # A valid Container object
+    #
+    def initialize(db, table)
+
+      unless db.table_exists?(table.to_sym)
+        db.create_table table do
+          primary_key :id
+          String      :key
+          String      :value
+        end
+        db.add_index table, :key
+        db.add_index table, :value
+      end
+
+      @sequel = db
+      @db     = db[table]
+    end
+
+    # Public Atributes
+    # db::
+    #   NoSequel data object
+    # sequel::
+    #   Underlying Sequel database object
+    #
+    attr_reader :db, :sequel
+
+    # Assigns the <value> to a given <:key>
+    #
+    def []=(key, value)
+      obj = value.is_a?(String) ? value : YAML::dump(value)
+      if exists?(key) # column already exists
+        data(key).update(value: obj)
+      else
+        db.insert(key: key.to_s, value: obj)
+      end
+    end
+
+    # Returns the value stored in :key, or nil of the data wasn't found.
+    #
+    def [](key)
+      exists?(key) ? YAML::load(value(key)) : nil
+    end
+
+    # Deletes :key from the nosequel container
+    #
+    def delete(key)
+      if exists?(key)
+        value = value(key)
+        data(key).delete
+      end
+      value
+    end
+    alias_method :remove, :delete
+
+    # Checks if a given key exists in the container
+    #
+    def has_key?(key)
+      data(validate_key(key)).count == 1 ? true : false
+    end
+    alias_method :exist?, :has_key?
+    alias_method :exists?, :has_key?
+
+    private
+
+    # Handle all other Hash methods
+    #
+    def method_missing(meth, *args, &block)
+      db.to_hash(:key, :value).send(meth, *args, &block)
+    end
+
+    # Make sure we respond to all Hash methods
+    #
+    def respond_to?(meth)
+      db.to_hash(:key, :value).respond_to?(meth)
+    end
+
+    # Returns a single record which matches key
+    def data(key)
+      db.where(key: validate_key(key).to_s)
+    end
+
+    # Returns the value of a given key
+    def value(key)
+      data(key).get(:value)
+    end
+
+    # Make sure the key is valid
+    def validate_key(key)
+      unless key.is_a?(Symbol) || key.is_a?(String)
+        raise ArgumentError, 'Key must be a string or symbol'
+      end
+      key
+    end
+
+  end
+
+end

data/lib/nosequel/version.rb

@@ -0,0 +1,3 @@
+module NoSequel
+  VERSION = '1.0.0-alpha.1'
+end

data/nosequel.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'nosequel/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "nosequel"
+  spec.version       = NoSequel::VERSION
+  spec.authors       = ["Donovan C. Young"]
+  spec.email         = ["dyoung522@gmail.com"]
+  spec.description   = "Simple NoSQL-like storage methods for Sequel O/RM"
+  spec.summary       = "Provides a NoSQL-like interface for data storage, backed by Sequel"
+  spec.homepage      = "http://github.com/dyoung522/nosequel"
+  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.require_paths = ["lib"]
+
+  spec.add_development_dependency 'bundler'
+
+  spec.add_dependency 'sequel', '~> 4.1.0'
+  spec.add_dependency 'sqlite3' # default storage engine
+end

data/test/all_tests.rb

@@ -0,0 +1,4 @@
+# Run all tests in the tests directory (and any subdirectories)
+require_relative 'test_helper.rb'
+Dir.glob('./test/tests/**/*.rb').each { |file| require file}
+

data/test/test_helper.rb

@@ -0,0 +1,26 @@
+require 'nosequel'
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'minitest/reporters'
+
+if ENV['RUBYMINE_TESTUNIT_REPORTER']
+  MiniTest::Reporters.use! MiniTest::Reporters::RubyMineReporter
+else
+  #MiniTest::Reporters.use! MiniTest::Reporters::DefaultReporter.new
+  #MiniTest::Reporters.use! MiniTest::Reporters::ProgressReporter.new
+  MiniTest::Reporters.use! MiniTest::Reporters::SpecReporter.new
+end
+
+module TestSetup
+  def setup
+    @table = :test
+    @data = NoSequel.register(@table, db_type: 'sqlite', db_name: 'test.db')
+
+    (1..4).each { |i| @data["test#{i}"] = "value#{i}" }
+  end
+
+  def teardown
+    NoSequel.drop!(@table)
+  end
+end
+

data/test/tests/config.rb

@@ -0,0 +1,34 @@
+require_relative '../test_helper'
+
+class TestConfigurationMethods < Minitest::Unit::TestCase
+
+  def test_drop_method_raises_error_before_register
+    out, err = capture_io do
+      assert_raises(RuntimeError) { NoSequel.drop!(:test) }
+    end
+    assert_match err, 'must call register'
+  end
+
+  def test_exists_method_raises_error_before_register
+    out, err = capture_io do
+      assert_raises(RuntimeError) { NoSequel.exists?(:test) }
+    end
+    assert_match err, 'must call register'
+  end
+
+  # We're testing a private method to be sure it's returning a valid response.
+  # If you're reading this, please note that this is a private method and
+  # therefore should generally *not* be called directly in your code.
+  # You probably want object.sequel if you need direct access to sequel calls.
+  def test_private_sequel_url_returns_a_valid_response
+    ( db_name, db_type, db_user, db_host ) = %w(testing mysql test)
+    config = NoSequel::Configuration.new(
+        db_type: db_type,
+        db_name: db_name,
+        db_user: db_user,
+        db_host: db_host
+    )
+    assert_equal "#{db_type}://#{db_user}/#{db_name}", config.send(:sequel_url)
+  end
+
+end

data/test/tests/data.rb

@@ -0,0 +1,35 @@
+require_relative '../test_helper'
+
+class TestDataMethods < Minitest::Unit::TestCase
+  include TestSetup
+
+  def test_column_should_exist
+    assert @data.has_key?(:test1), "@data[:test1] should exist"
+  end
+
+  def test_retrieve_column_value
+    assert_equal 'value1', @data[:test1], "@data[:test1] should return 'value1'"
+  end
+
+  def test_add_a_key_value_pair
+    @data[:newkey] = 'new key value'
+    assert_equal 'new key value', @data[:newkey], "We should be able to set a new key/value pair at will"
+  end
+
+  def test_update_an_existing_key_value_pair
+    @data[:test1] = 'new value'
+    assert_equal 'new value', @data[:test1], "We should be able to add a new value to an existing key"
+  end
+
+  def test_delete_key
+    out = @data.delete(:test1)
+    refute @data.has_key?(:test1)
+    assert_equal 'value1', out
+  end
+
+  def test_data_persists_between_calls
+    @data = nil
+    newdata = NoSequel.register(:test, db_type: 'sqlite', db_name: 'test.db')
+    assert_equal 'value1', newdata[:test1], "Data should persist between NoSequel calls"
+  end
+end

data/test/tests/query.rb

@@ -0,0 +1,40 @@
+require_relative '../test_helper'
+
+class TestQueryMethods < Minitest::Unit::TestCase
+  include TestSetup
+
+  def test_data_responds_to_Hash_methods
+    assert_respond_to @data, :keys
+    assert_respond_to @data, :values
+  end
+
+  def test_keys_method_returns_an_array_of_keys
+    assert_equal %w( test1 test2 test3 test4 ), @data.keys
+  end
+
+  def test_array_method_returns_an_array_of_values
+    assert_equal %w( value1 value2 value3 value4 ), @data.values
+  end
+
+  def test_data_handles_next
+    enum = @data.each
+
+    assert_equal %w(test1 value1), enum.next
+    assert_equal %w(test2 value2), enum.next
+    assert_equal %w(test3 value3), enum.next
+    assert_equal %w(test4 value4), enum.next
+
+    assert_raises(StopIteration) { enum.next }
+  end
+
+  def test_data_handles_map
+    assert_equal %w(VALUE1 VALUE2 VALUE3 VALUE4), @data.map { |k,v| v.upcase }
+  end
+
+  def test_data_doesnt_respond_to_bogus_methods
+    refute_respond_to @data, :foo
+    assert_raises(NoMethodError) { @data.foo }
+  end
+
+end
+

data/test/tests/register.rb

@@ -0,0 +1,22 @@
+require_relative '../test_helper'
+
+class TestRegister < Minitest::Unit::TestCase
+  include TestSetup
+
+  def test_exists
+    assert NoSequel.exists?(@table), "table '#{@table}' should exist"
+  end
+
+  def test_remove_table_after_drop
+    NoSequel.register(:drop_test)
+    assert NoSequel.exists?(:drop_test), "table 'drop_test' should now exist"
+
+    NoSequel.drop!(:drop_test)
+    refute NoSequel.exists?(:drop_test), "table 'drop_test' should no longer exist"
+  end
+
+  def test_nontexistant_table_should_not_exist
+    refute NoSequel.exists?(:bogus_table), "table :bogus_table should not exist"
+  end
+
+end

data/test/tests/write.rb

@@ -0,0 +1,21 @@
+require_relative '../test_helper'
+
+class TestWriteMethods < Minitest::Unit::TestCase
+  include TestSetup
+
+  Tester = Struct.new(:data)
+
+  def test_non_string_key_raises_error
+    assert_raises(ArgumentError) { @data[Tester] = 'invalid' }
+  end
+
+  def test_serialize_objects_before_write
+    @data[:test_object] = Tester.new()
+    assert_instance_of Tester, @data[:test_object]
+  end
+
+  def test_deserialize_objects_before_read
+    @data[:test_object] = Tester.new('hi there')
+    assert_equal 'hi there', @data[:test_object].data
+  end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: nosequel
+version: !ruby/object:Gem::Version
+  version: 1.0.0.pre.alpha.1
+platform: ruby
+authors:
+- Donovan C. Young
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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'
+description: Simple NoSQL-like storage methods for Sequel O/RM
+email:
+- dyoung522@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/nosequel.rb
+- lib/nosequel/configuration.rb
+- lib/nosequel/container.rb
+- lib/nosequel/version.rb
+- nosequel.gemspec
+- test/all_tests.rb
+- test/test_helper.rb
+- test/tests/config.rb
+- test/tests/data.rb
+- test/tests/query.rb
+- test/tests/register.rb
+- test/tests/write.rb
+homepage: http://github.com/dyoung522/nosequel
+licenses:
+- MIT
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.9
+signing_key: 
+specification_version: 4
+summary: Provides a NoSQL-like interface for data storage, backed by Sequel
+test_files:
+- test/all_tests.rb
+- test/test_helper.rb
+- test/tests/config.rb
+- test/tests/data.rb
+- test/tests/query.rb
+- test/tests/register.rb
+- test/tests/write.rb
+has_rdoc: