unqlite 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NDBhZTE1YWRhMTE2ZDA5ZmFkY2IxNjdhNTk3MDFmZDFhNzFjNWZkNw==
+  data.tar.gz: !binary |-
+    MWVjY2FhZmIwNzAyNjIwNjY1YTc2ODY1ZTliMjY5MWRmNmJiYTM1Mg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YzliODY1OWNlOThlNmU4YWUxZjAzYmY4YWIxYzdmZGVjNzI4YTc1ZDM2MDJl
+    ZjE4MDUzMWNkOTUzYTFlM2U3YmEwZjdlNTYwZWY0MzQxYThiNWM1Mzg3ZThl
+    Mjg0ZGNjZTdhZjczN2M3ZDBiZTNmNDlhNzljYTJiNjZmYmZlNjI=
+  data.tar.gz: !binary |-
+    MjUxYzhhZTZiNzkwYzgyNzY0ZjM3NDRkMDg1NjE4OTIwZTM4Mjc5NmIyOTcw
+    ODllMWZjODlmOTVkZTI4ZjA1NzhmMTY5YzRkNDEyMTUyYzM3ZjlhNGM1NzQ1
+    MWQ1ZDk3MzBkZTg5NWE2ZjI3ZTMxODAyNmFlNmZiZmQwYTY1YWQ=

data/.autotest

@@ -0,0 +1,9 @@
+Autotest.add_hook :initialize do |at|
+  at.add_mapping(/ext\/.*\.c/) do |f, _|
+    at.files_matching(/(lib|ext)\/test_.*rb$/)
+  end
+end
+
+Autotest.add_hook :run_command do |at|
+  system "bundle exec rake clean compile"
+end

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Daniel Teixeira
+
+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,38 @@
+# UnQLite for Ruby
+
+[UnQLite](http://www.unqlite.org/) interface for ruby programs.
+
+Note: This is an alpha version and many features are missing! But,
+I would love to merge some pull-requests to make it better (:
+
+## Installation
+
+You have to install UnQLite into your system and compile it as a shared library. Unfortunately, 
+UnQLite doesn't have a Makefile (or something like that) to automate that step. If you are on
+linux, you can check [this gist](https://gist.github.com/danieltdt/5693070) and compile it using gcc.
+
+After installing UnQLite, add this line to your application's Gemfile:
+
+    gem 'unqlite'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install unqlite
+
+## Usage
+
+    db = UnQLite::Database.new(":mem:")
+    db.store("key", "wabba")
+    db.fetch("key") # => "wabba"
+
+## Contributing
+
+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 new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require 'rake/extensiontask'
+
+Rake::ExtensionTask.new('unqlite_native') do |ext|
+  ext.ext_dir = 'ext/unqlite'
+  ext.lib_dir = 'lib/unqlite'
+end

data/ext/unqlite/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+abort "unqlite.h is missing. Please, install unqlite." unless find_header 'unqlite.h'
+abort "unqlite is missing. Please, install unqlite" unless find_library 'unqlite', 'unqlite_open'
+
+create_makefile('unqlite/unqlite_native')

data/ext/unqlite/unqlite.c

@@ -0,0 +1,11 @@
+#include <unqlite_ruby.h>
+
+VALUE mUnQLite;
+
+void Init_unqlite_native()
+{
+  mUnQLite = rb_define_module("UnQLite");
+
+  Init_unqlite_database();
+  Init_unqlite_codes();
+}

data/ext/unqlite/unqlite_codes.c

@@ -0,0 +1,36 @@
+#include <unqlite_codes.h>
+
+VALUE mUnQLiteCodes;
+
+void Init_unqlite_codes()
+{
+#if 0
+  VALUE mUnqlite = rb_define_module("UnQLite");
+#endif
+
+  mUnQLiteCodes = rb_define_module_under(mUnQLite, "Codes");
+  rb_define_const(mUnQLiteCodes, "OK",              INT2FIX(UNQLITE_OK));
+  rb_define_const(mUnQLiteCodes, "NOMEM",           INT2FIX(UNQLITE_NOMEM));
+  rb_define_const(mUnQLiteCodes, "ABORT",           INT2FIX(UNQLITE_ABORT));
+  rb_define_const(mUnQLiteCodes, "IOERR",           INT2FIX(UNQLITE_IOERR));
+  rb_define_const(mUnQLiteCodes, "CORRUPT",         INT2FIX(UNQLITE_CORRUPT));
+  rb_define_const(mUnQLiteCodes, "LOCKED",          INT2FIX(UNQLITE_LOCKED));
+  rb_define_const(mUnQLiteCodes, "BUSY",            INT2FIX(UNQLITE_BUSY));
+  rb_define_const(mUnQLiteCodes, "DONE",            INT2FIX(UNQLITE_DONE));
+  rb_define_const(mUnQLiteCodes, "PERM",            INT2FIX(UNQLITE_PERM));
+  rb_define_const(mUnQLiteCodes, "NOTIMPLEMENTED",  INT2FIX(UNQLITE_NOTIMPLEMENTED));
+  rb_define_const(mUnQLiteCodes, "NOTFOUND",        INT2FIX(UNQLITE_NOTFOUND));
+  rb_define_const(mUnQLiteCodes, "NOOP",            INT2FIX(UNQLITE_NOOP));
+  rb_define_const(mUnQLiteCodes, "INVALID",         INT2FIX(UNQLITE_INVALID));
+  rb_define_const(mUnQLiteCodes, "EOF",             INT2FIX(UNQLITE_EOF));
+  rb_define_const(mUnQLiteCodes, "UNKNOWN",         INT2FIX(UNQLITE_UNKNOWN));
+  rb_define_const(mUnQLiteCodes, "LIMIT",           INT2FIX(UNQLITE_LIMIT));
+  rb_define_const(mUnQLiteCodes, "EXISTS",          INT2FIX(UNQLITE_EXISTS));
+  rb_define_const(mUnQLiteCodes, "EMPTY",           INT2FIX(UNQLITE_EMPTY));
+  rb_define_const(mUnQLiteCodes, "COMPILE_ERR",     INT2FIX(UNQLITE_COMPILE_ERR));
+  rb_define_const(mUnQLiteCodes, "VM_ERR",          INT2FIX(UNQLITE_VM_ERR));
+  rb_define_const(mUnQLiteCodes, "FULL",            INT2FIX(UNQLITE_FULL));
+  rb_define_const(mUnQLiteCodes, "CANTOPEN",        INT2FIX(UNQLITE_CANTOPEN));
+  rb_define_const(mUnQLiteCodes, "READ_ONLY",       INT2FIX(UNQLITE_READ_ONLY));
+  rb_define_const(mUnQLiteCodes, "LOCKERR",         INT2FIX(UNQLITE_LOCKERR));
+}

data/ext/unqlite/unqlite_codes.h

@@ -0,0 +1,10 @@
+#ifndef UNQLITE_RUBY_CODES
+#define UNQLITE_RUBY_CODES
+
+#include <unqlite_ruby.h>
+
+extern VALUE mUnQLiteCodes;
+
+void Init_unqlite_codes();
+
+#endif

data/ext/unqlite/unqlite_database.c

@@ -0,0 +1,130 @@
+#include <unqlite_database.h>
+
+VALUE cUnQLiteDatabase;
+
+static void deallocate(void *ctx)
+{
+  unqliteRubyPtr c = (unqliteRubyPtr) ctx;
+  unqlite *pDb = c->pDb;
+
+  if (pDb) unqlite_close(pDb);
+  xfree(c);
+}
+
+static VALUE allocate(VALUE klass)
+{
+  unqliteRubyPtr ctx = malloc(sizeof(unqliteRuby));
+  ctx->pDb = NULL;
+
+  return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
+}
+
+static VALUE initialize(VALUE self, VALUE rb_string)
+{
+  void *c_string;
+  int rc;
+  unqliteRubyPtr ctx;
+
+  // Ensure the given argument is a ruby string
+  Check_Type(rb_string, T_STRING);
+
+  // Get class context
+  Data_Get_Struct(self, unqliteRuby, ctx);
+
+  // Transform Ruby string into C string
+  c_string = calloc(RSTRING_LEN(rb_string), sizeof(char));
+  memcpy(c_string, StringValuePtr(rb_string), RSTRING_LEN(rb_string));
+
+  // Open database
+  // TODO: Always opening as a memory database. It should be a parameter.
+  rc = unqlite_open(&ctx->pDb, c_string, UNQLITE_OPEN_IN_MEMORY);
+
+  // Verify if is everything ok
+  if( rc != UNQLITE_OK ){
+    // TODO: Return error code with a better message raising a UnQLite exception.
+    rb_raise(rb_eRuntimeError, "Couldn't open database");
+
+    return self;
+  }
+
+  return self;
+}
+
+static VALUE unqlite_database_store(VALUE self, VALUE key, VALUE value)
+{
+  void *c_key;
+  void *c_value;
+  int rc;
+  unqliteRubyPtr ctx;
+
+  // Ensure the given argument is a ruby string
+  Check_Type(key, T_STRING);
+  Check_Type(value, T_STRING);
+
+  // Get class context
+  Data_Get_Struct(self, unqliteRuby, ctx);
+
+  // Transform Ruby string into C string
+  c_key = calloc(RSTRING_LEN(key), sizeof(char));
+  memcpy(c_key, StringValuePtr(key), RSTRING_LEN(key));
+
+  c_value = calloc(RSTRING_LEN(value), sizeof(char));
+  memcpy(c_value, StringValuePtr(value), RSTRING_LEN(value));
+
+  rc = unqlite_kv_store(ctx->pDb, c_key, -1, c_value, sizeof(c_value));
+
+  if( rc != UNQLITE_OK ) {
+    if( rc != UNQLITE_BUSY && rc != UNQLITE_NOTIMPLEMENTED ) {
+      unqlite_rollback(ctx->pDb);
+    }
+  }
+
+  return INT2FIX(rc);
+}
+
+static VALUE unqlite_database_fetch(VALUE self, VALUE collection_name)
+{
+  void *c_collection_name;
+  void *fetched_data;
+  unqlite_int64 n_bytes;
+  int rc;
+  unqliteRubyPtr ctx;
+
+  // Ensure the given argument is a ruby string
+  Check_Type(collection_name, T_STRING);
+
+  // Get class context
+  Data_Get_Struct(self, unqliteRuby, ctx);
+
+  // Transform Ruby string into C string
+  c_collection_name = calloc(RSTRING_LEN(collection_name), sizeof(char));
+  memcpy(c_collection_name, StringValuePtr(collection_name), RSTRING_LEN(collection_name));
+
+  rc = unqlite_kv_fetch(ctx->pDb, c_collection_name, -1, NULL, &n_bytes);
+  if( rc != UNQLITE_OK ) { return INT2FIX(rc); }
+
+  fetched_data = (char *)malloc(n_bytes);
+  if( fetched_data == NULL ) { return INT2FIX(UNQLITE_EMPTY); }
+
+  rc = unqlite_kv_fetch(ctx->pDb, c_collection_name, -1, fetched_data, &n_bytes);
+  if( rc == UNQLITE_OK ) { return rb_str_new2((char *)fetched_data); }
+
+  return INT2FIX(rc);
+}
+
+void Init_unqlite_database()
+{
+#if 0
+  VALUE mUnqlite = rb_define_module("UnQLite");
+#endif
+
+  /* defining UnQLite::Database class and appending its methods */
+  cUnQLiteDatabase = rb_define_class_under(mUnQLite, "Database", rb_cObject);
+
+  rb_define_alloc_func(cUnQLiteDatabase, allocate);
+
+  rb_define_method(cUnQLiteDatabase, "store", unqlite_database_store, 2);
+  rb_define_method(cUnQLiteDatabase, "fetch", unqlite_database_fetch, 1);
+
+  rb_define_method(cUnQLiteDatabase, "initialize", initialize, 1);
+}

data/ext/unqlite/unqlite_database.h

@@ -0,0 +1,17 @@
+#ifndef UNQLITE_RUBY_DATABASE
+#define UNQLITE_RUBY_DATABASE
+
+#include <unqlite_ruby.h>
+
+struct _unqliteRuby {
+  unqlite *pDb;
+};
+
+typedef struct _unqliteRuby unqliteRuby;
+typedef unqliteRuby * unqliteRubyPtr;
+
+extern VALUE cUnQLiteDatabase;
+
+void Init_unqlite_database();
+
+#endif

data/ext/unqlite/unqlite_ruby.h

@@ -0,0 +1,12 @@
+#ifndef UNQLITE_RUBY
+#define UNQLITE_RUBY
+
+#include <ruby.h>
+#include <unqlite.h>
+
+#include <unqlite_database.h>
+#include <unqlite_codes.h>
+
+extern VALUE mUnQLite;
+
+#endif

data/lib/unqlite.rb

@@ -0,0 +1,6 @@
+require 'unqlite/unqlite_native'
+require "unqlite/version"
+
+module UnQLite
+  # Your code goes here...
+end

data/lib/unqlite/version.rb

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

data/test/helper.rb

@@ -0,0 +1,3 @@
+require 'unqlite'
+require 'minitest/autorun'
+

data/test/test_database.rb

@@ -0,0 +1,21 @@
+require 'helper'
+
+module UnQLite
+  class TestDatabase < Minitest::Test
+    attr_reader :db
+
+    def setup
+      @db = UnQLite::Database.new(":mem:")
+    end
+
+    def test_store
+      assert_equal UnQLite::Codes::OK, @db.store("key", "stored content")
+    end
+
+    def test_fetch
+      @db.store("key", "wabba")
+
+      assert_equal "wabba", @db.fetch("key")
+    end
+  end
+end

data/unqlite.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'unqlite/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "unqlite"
+  spec.version       = UnQLite::VERSION
+  spec.authors       = ["Daniel Teixeira"]
+  spec.email         = ["daniel.t.dt@gmail.com"]
+  spec.description   = %q{UnQLite lib for ruby, using C extension.}
+  spec.summary       = %q{UnQLite for ruby (using C extension)}
+  spec.homepage      = "https://github.com/danieltdt/unqlite-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.extensions    = ['ext/unqlite/extconf.rb']
+  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", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "ZenTest"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "minitest", "~> 5.0.3"
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: unqlite
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Daniel Teixeira
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: ZenTest
+  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: rake-compiler
+  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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.0.3
+description: UnQLite lib for ruby, using C extension.
+email:
+- daniel.t.dt@gmail.com
+executables: []
+extensions:
+- ext/unqlite/extconf.rb
+extra_rdoc_files: []
+files:
+- .autotest
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/unqlite/extconf.rb
+- ext/unqlite/unqlite.c
+- ext/unqlite/unqlite_codes.c
+- ext/unqlite/unqlite_codes.h
+- ext/unqlite/unqlite_database.c
+- ext/unqlite/unqlite_database.h
+- ext/unqlite/unqlite_ruby.h
+- lib/unqlite.rb
+- lib/unqlite/version.rb
+- test/helper.rb
+- test/test_database.rb
+- unqlite.gemspec
+homepage: https://github.com/danieltdt/unqlite-ruby
+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.0.3
+signing_key: 
+specification_version: 4
+summary: UnQLite for ruby (using C extension)
+test_files:
+- test/helper.rb
+- test/test_database.rb