sqlite3_hash 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 07d1d1ce69db0d02ce3b805a4b052fe98054ee30
+  data.tar.gz: 8938ff1f168af62aa921688214839c4b9b789859
+SHA512:
+  metadata.gz: 02b0ed65f1a3ef07cd6bd32152099e626d52b68cb1b8054f5337ce4b2f4b3b8b45d25d94ba816e5adfd5cfad6df7335725206cc792737753a2469d46d1c04eda
+  data.tar.gz: 9a9d574781ffce90a30b93eee82a05a8f60b7b089f8ea00952a3401b7798d465abf195c2fccecacaf3136ee87355dfc1164cc9614351479a634fe465aabb550e

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sqlite3_hash.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 David Ljung Madison Stellar
+
+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,83 @@
+# Sqlite3Hash
+
+A persistent simple Hash backed by sqlite3
+
+Contains (almost) the same features/API as the Ruby 2.0.0 Hash object
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sqlite3_hash'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sqlite3_hash
+
+## Usage
+
+SQLite3Hash is a persistent simple Hash backed by sqlite3.
+
+You can use it like a Hash object, but all data is stored in SQLite3,
+which can be re-used over multiple instantiations of ruby.
+
+Example case:
+
+    require 'sqlite3_hash'
+    
+    shash = SQLite3Hash.new('tmpfile.db')
+    shash['int'] = 42
+    shash[:sym] = { a: 12, b: 32 }
+    shash[99.1] = [1,[10,20],3]  
+    shash = nil
+
+    # Some point later..  or even in another ruby instance:
+    shash = SQLite3Hash.new('tmpfile.db')
+    shash['int']   # => 42
+    shash.to_s     # => {"int"=>42, :sym=>{:a=>12, :b=>32}, 99.1=>[1, [10, 20], 3]}
+
+Handles values of String, Fixnum, Float, and anything that can be Marshalled
+
+Keys are anything that can be Marshalled.
+
+This means, for example, that you *cannot* store Procs in an SQLite3Hash
+
+Contains all the Hash class methods from 2.0.0 except:
+
+1. No deprecated methods
+2. Methods not implemented:  rehash, compare_by_identity, SQLite3Hash[]
+3. Methods that are supposed to return a hash do so (instead of returning an SQLite3Hash), for example 'to_h'
+4. try_convert also requires db and other parameters as per SQLite3Hash.new
+5. Uses the value of an object instead of the object as a key
+
+For example:
+
+    a = [ "a", "b" ]
+    h = { a => 100 }
+    sh = SQLite3Hash('tmp.db')
+    a[0] = 'z'
+    h	 # => {["z", "b"]=>100}
+    sh  # => {["a", "b"]=>100}
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/daveola/sqlite3_hash.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rspec/core/rake_task'
+require "bundler/gem_tasks"
+
+## Default directory to look in is `/specs`
+## Run with `rake spec`
+#RSpec::Core::RakeTask.new(:spec) do |task|
+#	#task.rspec_opts = ['--color', '--format', 'documentation']
+#end
+
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sqlite3_hash"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/sqlite3_hash.rb

@@ -0,0 +1,367 @@
+require "sqlite3_hash/version"
+
+# Filename:	sqlite3hash.rb
+# Author:	David Ljung Madison <DaveSource.com>
+# See License:	http://MarginalHacks.com/License/
+# Description:	An sqlite3 backed simple hash in ruby
+#
+# Handles values of String, Fixnum, Float, and anything that can be Marshalled
+# Keys are anything that can be Marshalled
+# This means, for example, that you cannot store Procs in an SQLite3Hash
+#
+# Contains all the Hash class methods from 2.0.0 except:
+# 1) No deprecated methods
+# 2) Methods not implemented:  rehash, compare_by_identity, SQLite3Hash[]
+# 3) Methods that are supposed to return a hash do so (instead of
+#    returning an SQLite3Hash), for example 'to_h'
+# 4) try_convert also requires db and other parameters as per SQLite3Hash.new
+# 5) Uses the value of an object instead of the object as a key, i.e.:
+#    a = [ "a", "b" ]
+#    h = { a => 100 }
+#    sh = SQLite3Hash('tmp.db')
+#    a[0] = 'z'
+#    h	 # => {["z", "b"]=>100}
+#    sh  # => {["a", "b"]=>100}
+
+require 'sqlite3'
+
+class SQLite3Hash
+	class MissingDBPath < StandardError
+		def initialize(msg="Need to specify DB path for SQLite3Hash") super; end
+	end
+
+	# new(db)
+	# new(db, default_obj)
+	# new(db, hash)
+	# new(db, default_obj, table_name)
+	# new(db, hash, table_name)
+	#   All of the above with block specified (default_proc)
+	def initialize(db=nil, init=nil, table='sqlite3hash', &default_proc)
+		raise SQLite3Hash::MissingDBPath unless db
+		@db = db
+
+		@sqldb = SQLite3::Database.open(@db)
+
+		# Handle args
+		@default = (init.class==Hash) ? nil : init
+		@default_proc = block_given? ? default_proc : nil
+
+		# Safely quote table
+		@table = table
+		@table = table.gsub( /'/, "''" )
+
+		createTable
+
+		# Init from hash
+		init.each { |k,v| set(k,v) } if init.class==Hash
+	end
+
+	# Like 'new' but we call try_convert
+	def SQLite3Hash.try_convert(incoming, *args)
+		shash = SQLite3Hash.new(*args)
+		return shash unless incoming
+		h = Hash.try_convert(incoming)
+		return shash unless h
+		h.each { |k,v| shash[k]=v }
+		shash
+	end
+
+	def [](key)
+		return nil unless @sqldb
+		row = @sqldb.get_first_row( "select * from '#{@table}' where key = ?", Marshal.dump(key))
+		row ? (row2value(row)) : default(key)
+	end
+	alias :get :[]
+	alias :read :[]
+	def default(key=nil)
+		(key && @default_proc) ? @default_proc.call(self,key) : @default
+	end
+	def default=(v)
+		@default = v
+	end
+	def default_proc
+		@default_proc
+	end
+	def assoc(key)
+		has_key?(key) ? [key,get(key)] : nil
+	end
+	def rassoc(value)
+		key = key(value)
+		key ? [key,value] : nil
+	end
+
+	def []=(key,value)
+		return unless @sqldb
+		# Unlike a Hash, can't store with key nil, we could use quoting to change this if needed
+		return unless key
+
+		rows = {
+			'valueString' => nil,
+			'valueSymbol' => nil,
+			'valueFixnum' => nil,
+			'valueFloat' => nil,
+			'valueMarshal' => nil,
+		}
+		rowname,value = rowValue(value)
+		rows[rowname] = value
+		keys = ['key']
+		# Key is always marshalled - it can be many types and needs to be a unique index
+		values = [Marshal.dump(key)]
+		rows.each { |k,v|
+			keys.push(k)
+			values.push(v)
+		}
+		@sqldb.execute("insert or replace into '#{@table}'(#{keys.join(',')}) VALUES(#{(['?']*values.size).join(',')})",*values)
+	end
+	alias :set :[]=
+	alias :write :[]=
+	alias :hsh :[]=
+	alias :store :[]=
+
+	def fetch(key,default = nil)
+		v = get(key)
+		return v if v
+		return default if default
+		return yield(key) if block_given?
+		return raise KeyError
+	end
+
+	def each
+		return Enumerator.new { |y| rows { |row| y.yield(Marshal.load(row[0]),row2value(row)) } } unless block_given?
+		rows { |row| yield(Marshal.load(row[0]),row2value(row)) }
+	end
+	alias :each_pair :each
+
+	def each_key
+		return Enumerator.new { |y| rows { |row| y.yield(Marshal.load(row[0])) } } unless block_given?
+		rows { |row| yield(Marshal.load(row[0])) }
+	end
+	def each_value
+		return Enumerator.new { |y| rows { |row| y.yield(row2value(row)) } } unless block_given?
+		rows { |row| yield(row2value(row)) }
+	end
+	def keys
+		rows.map { |row| Marshal.load(row[0]) }
+	end
+	def values
+		rows.map { |row| row2value(row) }
+	end
+	# Values for a given set of keys
+	def values_at(*keys)
+		keys.map { |key| get(key) }
+	end
+
+	def flatten(level=1)
+		arr = []
+		each { |k,v| arr.push([k,v]) }
+		arr.flatten(level)
+	end
+
+	def size
+		got = @sqldb.get_first_row("select count(*) from '#{@table}'")
+		return got && got.class==Array ? got[0] : nil
+	end
+	alias :length :size
+	def empty?
+		size==0 ? true : false
+	end
+
+	def del(key)
+#puts "delete key #{key}"
+		return unless @sqldb
+		@sqldb.execute("delete from '#{@table}' where key = ?",Marshal.dump(key))
+	end
+	alias :delete :del
+	def keep_if
+		return Enumerator.new { |y|
+			each { |k,v| delete(k) unless y.yield(k,v) }
+			self
+		} unless block_given?
+		each { |k,v| delete(k) unless yield(k,v) }
+		return self
+	end
+	def delete_if
+		return Enumerator.new { |y|
+			each { |k,v| delete(k) if y.yield(k,v) }
+			self
+		} unless block_given?
+		each { |k,v| delete(k) if yield(k,v) }
+		return self
+	end
+	def reject
+		hash = Hash.new
+		each { |k,v| hash[k] = v unless yield(k,v) }
+		return hash
+	end
+	def reject!
+		changes = 0
+		en = Enumerator.new { |y|
+			each { |k,v|
+				next unless y.yield(k,v)
+				delete(k)
+				changes += 1
+			}
+			changes==0 ? nil : self
+		}
+		return en unless block_given?
+		en.each { |k,v| yield(k,v) }
+	end
+	def select
+		hash = Hash.new
+		each { |k,v| hash[k] = v if yield(k,v) }
+		return hash
+	end
+	def select!
+		changes = 0
+		en = Enumerator.new { |y|
+			each { |k,v|
+				next if y.yield(k,v)
+				delete(k)
+				changes += 1
+			}
+			changes==0 ? nil : self
+		}
+		return en unless block_given?
+		en.each { |k,v| yield(k,v) }
+	end
+
+	def clear(replaceHash = nil)
+		@sqldb.execute("drop table '#{@table}'")
+		createTable(replaceHash)
+	end
+	alias :replace :clear
+
+	def has_key?(k)
+		@sqldb.get_first_row( "select * from '#{@table}' where key = ?", Marshal.dump(k)) ? true : false
+	end
+	alias :include? :has_key?
+	alias :key? :has_key?
+	alias :member? :has_key?
+
+	def index(value)
+		rowname,value = rowValue(value)
+		row = @sqldb.get_first_row( "select * from '#{@table}' where #{rowname} = ?", value)
+		row ? Marshal.load(row[0]) : nil
+	end
+	alias :key :index
+	def has_value?(v)
+		index(v) ? true : false
+	end
+	alias :value? :has_value?
+
+	def shift
+		row = @sqldb.get_first_row("select * from '#{@table}'")
+# TODO - what if we have a default_proc and we shift out?
+		return default(nil) unless row
+		key = Marshal.load(row[0])
+		value = row2value(row)
+		delete(key)
+		[key,value]
+	end
+
+	def to_h
+		h = Hash.new
+		return h unless @sqldb
+		each { |k,v| h[k] = v }
+		h
+	end
+	alias :to_hash :to_h
+	def ==(otherHash)
+		to_hash.==(otherHash)
+	end
+	alias :eql? :==
+	def hash
+		to_hash.hash
+	end
+	def invert
+		to_hash.invert
+	end
+	def merge(otherHash,&block)
+		to_hash.merge(otherHash,&block)
+	end
+	def merge!(otherHash)
+		if block_given?
+			otherHash.each { |key,newval|
+				oldval = get(key)
+				set(key,oldval ? yield(key,oldval,newval) : newval)
+			}
+		else
+			otherHash.each { |k,v| set(k,v) }
+		end
+	end
+	alias :update :merge!
+	def replace(otherHash)
+		clear
+		merge!(otherHash)
+	end
+
+	def to_a
+		a = Array.new
+		return a unless @sqldb
+		each { |k,v| a.push([k,v]) }
+		a
+	end
+	def sort
+		to_a.sort
+	end
+
+	def inspect
+		inspect = "SQLite3Hash[#{@db}:#{@table}]"
+		return "#<#{inspect} - no database connection>" unless @sqldb
+		return "#<#{inspect} #{to_hash.inspect}>"
+	end
+	def to_s
+		to_hash.to_s
+	end
+
+	# For debug
+	def dumpTable
+		h = Hash.new
+		return puts "NO CONNECTION" unless @sqldb
+		@sqldb.execute("select * from '#{@table}'") { |row|
+			row[0] = Marshal.load(row[0])
+			p row
+		}
+		h
+	end
+
+	# Not implemented
+	def rehash
+		raise NotImplementedError
+	end
+	def compare_by_identity
+		raise NotImplementedError
+	end
+	def compare_by_identity?
+		false
+	end
+	def self.[](*a)
+		raise NotImplementedError
+	end
+
+
+	private
+		def rows
+			return @sqldb.execute("select * from '#{@table}'") unless block_given?
+			@sqldb.execute("select * from '#{@table}'") { |row|
+				yield row
+			}
+		end
+		def rowValue(value)
+			c = value.class
+			return ["value#{c.to_s}",value] if c==Fixnum || c==String || c==Float
+			return ["value#{c.to_s}",value.to_s] if c==Symbol
+			return ["valueMarshal",Marshal.dump(value)]
+		end
+		def row2value(row)
+			row[1] || row[2] || row[3] || (row[4] ? row[4].to_sym : Marshal.load(row[5]))
+		end
+
+		def createTable(h=Hash.new)
+			# Check if table exists
+			return if @sqldb.get_first_value( %{select name from sqlite_master where name = :name}, {:name => @table} )
+			@sqldb.execute("create table '#{@table}' (key TEXT not null unique, valueString TEXTS, valueFixnum INTEGER, valueFloat REAL, valueSymbol TEXTS, valueMarshal TEXTS)")
+			h.each { |k,v| set(k,v) } if h
+		end
+end
+

data/lib/sqlite3_hash/version.rb

@@ -0,0 +1,3 @@
+module Sqlite3Hash
+  VERSION = "1.0.0"
+end

data/sqlite3_hash.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sqlite3_hash/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sqlite3_hash"
+  spec.version       = Sqlite3Hash::VERSION
+  spec.authors       = ["David Ljung Madison Stellar"]
+  spec.email         = ["http://Contact.MarginalHacks.com/"]
+
+  spec.summary       = %q{A persistent simple Hash backed by sqlite3}
+  spec.description   = %q{A persistent simple Hash backed by sqlite3\n\nContains (almost) the same features/API as the Ruby 2.0.0 Hash object}
+  spec.homepage      = "http://MarginalHacks.com/"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    #spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  #spec.add_development_dependency "true", "~> "
+  spec.add_development_dependency "rspec"
+  spec.add_dependency "sqlite3"
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: sqlite3_hash
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- David Ljung Madison Stellar
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-01-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: 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: A persistent simple Hash backed by sqlite3\n\nContains (almost) the same
+  features/API as the Ruby 2.0.0 Hash object
+email:
+- http://Contact.MarginalHacks.com/
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/sqlite3_hash.rb
+- lib/sqlite3_hash/version.rb
+- sqlite3_hash.gemspec
+homepage: http://MarginalHacks.com/
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A persistent simple Hash backed by sqlite3
+test_files: []