sqlite_magic 0.0.1

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  # - "1.8.7"
+  - "1.9.2"
+  - "1.9.3"
+  - jruby-18mode # JRuby in 1.8 mode
+  - jruby-19mode # JRuby in 1.9 mode
+  # - rbx-18mode
+  - rbx-19mode
+# uncomment this line if your project needs to run something other than `rake`:
+script: bundle exec rspec spec

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Chris Taggart
+
+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,32 @@
+# SqliteMagic
+[![Build Status](https://travis-ci.org/openc/sqlite_magic.png)](https://travis-ci.org/openc/sqlite_magic)
+Experimental abstraction and refactoring of sqlite utility methods from 
+scraperwiki-ruby gem
+Note: Not all functionality has yet been duplicated, and this may not work for
+you. Developed and tested on Ruby 1.9.3
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sqlite_magic', :git => 'git@github.com:openc/sqlite_magic.git'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sqlite_magic
+
+## Usage
+
+TODO: Write usage instructions here
+
+## 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 @@
+require "bundler/gem_tasks"

data/lib/sqlite_magic.rb

@@ -0,0 +1,168 @@
+require 'sqlite_magic/version'
+require 'sqlite3'
+
+module SqliteMagic
+
+  extend self
+
+  class Error            < StandardError;end
+  class DatabaseError    < Error;end
+  class NoSuchTable      < Error;end
+
+  class Connection
+    attr_reader :database
+    def initialize(db_loc='sqlite.db')
+      @database = SQLite3::Database.new(db_loc)
+    end
+
+    def add_columns(tbl_name, col_names)
+      existing_cols = database.table_info(tbl_name).map{ |c| c['name'] }
+      missing_cols = col_names.map(&:to_s) - existing_cols
+      missing_cols.each do |col_name|
+        database.execute("ALTER TABLE #{tbl_name} ADD COLUMN #{col_name}")
+      end
+    end
+
+    def close
+      database.close
+    end
+
+    def commit
+      database.commit
+    end
+
+    def create_table(tbl_name, col_names, unique_keys=nil)
+      puts "Now creating new table: #{tbl_name}" if verbose?
+      query = unique_keys ? "CREATE TABLE #{tbl_name} (#{col_names.join(',')}, UNIQUE (#{unique_keys.join(',')}))" :
+                            "CREATE TABLE #{tbl_name} (#{col_names.join(',')})"
+      database.execute query
+    end
+
+    def execute(query,data=nil)
+      raw_response = data ? database.execute2(query, data) : database.execute2(query)
+      keys = raw_response.shift # get the keys
+      raw_response.map{|e| Hash[keys.zip(e)] }
+    end
+
+    # This is an (expensive) convenience method to insert a row (for given unique keys), or if the row already exists
+    #
+    def insert_or_update(uniq_keys, values_hash, tbl_name='ocdata')
+      field_names_as_symbol_string = values_hash.keys.map{ |k| ":#{k}" }.join(',') # need to appear as symbols
+
+      sql_statement = "INSERT INTO #{tbl_name} (#{values_hash.keys.join(',')}) VALUES (#{field_names_as_symbol_string})"
+      database.execute(sql_statement, values_hash)
+    rescue SQLite3::ConstraintException => e
+      unique_key_constraint = uniq_keys.map { |k| "#{k}=:#{k}" }.join(' AND ')
+      update_keys = (values_hash.keys - uniq_keys).map { |k| "#{k}=:#{k}" }.join(', ')
+      sql_statement = "UPDATE #{tbl_name} SET #{update_keys} WHERE #{unique_key_constraint}"
+      database.execute sql_statement, values_hash
+    rescue SQLite3::SQLException => e
+      puts "Exception (#{e.inspect}) raised: #{sql_statement}" if verbose?
+      # defer to save_data, which can handle missing tables, columns etc
+      save_data(uniq_keys, values_hash, tbl_name)
+    end
+
+    # #save data into the database
+    def save_data(uniq_keys, values_array, tbl_name)
+      values_array = [values_array].flatten(1) # coerce to an array
+      all_field_names = values_array.map(&:keys).flatten.uniq
+      all_field_names_as_string = all_field_names.join(',')
+      all_field_names_as_symbol_string = all_field_names.map{ |k| ":#{k}" }.join(',') # need to appear as symbols
+      begin
+        values_array.each do |values_hash|
+          # mustn't use nil value in unique value due to fact that SQLite considers NULL values to be different from
+          # each other in UNIQUE indexes. See http://www.sqlite.org/lang_createindex.html
+          raise DatabaseError.new("Data has nil value for unique key. Unique keys are #{uniq_keys}. Offending data: #{values_hash.inspect}") unless uniq_keys.all?{ |k| values_hash[k] }
+          sql_query =  "INSERT OR REPLACE INTO #{tbl_name} (#{all_field_names_as_string}) VALUES (#{all_field_names_as_symbol_string})"
+          database.execute(sql_query, values_hash)
+        end
+      rescue SQLite3::SQLException => e
+        puts "Exception (#{e.inspect}) raised" if verbose?
+        case e.message
+        when /no such table/
+          create_table(tbl_name, all_field_names, uniq_keys)
+          retry
+        when /has no column/
+          add_columns(tbl_name, all_field_names)
+          retry
+        else
+          raise e
+        end
+      end
+    end
+
+    # Convenience method that returns true if VERBOSE environmental variable set (at the moment whatever it is set to)
+    def verbose?
+      ENV['VERBOSE']
+    end
+
+    # def buildinitialtable(data)
+    #   raise "buildinitialtable: no swdatakeys" unless @swdatakeys.length == 0
+    #   coldef = self.newcolumns(data)
+    #   raise "buildinitialtable: no coldef" unless coldef.length > 0
+    #   # coldef = coldef[:1]  # just put one column in; the rest could be altered -- to prove it's good
+    #   scoldef = coldef.map { |col| format("`%s` %s", col[0], col[1]) }.join(",")
+    #   @db.execute(format("create table main.`%s` (%s)", @swdatatblname, scoldef))
+    # end
+    # def addnewcolumn(k, vt)
+    #   @db.execute(format("alter table main.`%s` add column `%s` %s", @swdatatblname, k, vt))
+    # end
+    # Internal function to check a row of data, convert to right format
+    # def ScraperWiki._convdata(unique_keys, scraper_data)
+    #     if unique_keys
+    #         for key in unique_keys
+    #             if !key.kind_of?(String) and !key.kind_of?(Symbol)
+    #                 raise 'unique_keys must each be a string or a symbol, this one is not: ' + key
+    #             end
+    #             if !scraper_data.include?(key) and !scraper_data.include?(key.to_sym)
+    #                 raise 'unique_keys must be a subset of data, this one is not: ' + key
+    #             end
+    #             if scraper_data[key] == nil and scraper_data[key.to_sym] == nil
+    #                 raise 'unique_key value should not be nil, this one is nil: ' + key
+    #             end
+    #         end
+    #     end
+    #
+    #     jdata = { }
+    #     scraper_data.each_pair do |key, value|
+    #         raise 'key must not have blank name' if not key
+    #
+    #         key = key.to_s if key.kind_of?(Symbol)
+    #         raise 'key must be string or symbol type: ' + key if key.class != String
+    #         raise 'key must be simple text: ' + key if !/[a-zA-Z0-9_\- ]+$/.match(key)
+    #
+    #         # convert formats
+    #         if value.kind_of?(Date)
+    #             value = value.iso8601
+    #         end
+    #         if value.kind_of?(Time)
+    #           # debugger
+    #             value = value.utc.iso8601
+    #             raise "internal error, timezone came out as non-UTC while converting to SQLite format" unless value.match(/([+-]00:00|Z)$/)
+    #             value.gsub!(/([+-]00:00|Z)$/, '')
+    #         end
+    #         if ![Fixnum, Float, String, TrueClass, FalseClass, NilClass].include?(value.class)
+    #             value = value.to_s
+    #         end
+    #
+    #         jdata[key] = value
+    #     end
+    #     return jdata
+    # end
+  end
+
+
+  # When deciding on the location of the SQLite databases we need to set the directory relative to the directory
+  # of the file/app that includes the gem, not the gem itself.
+  # Doing it this way, and setting a class variable feels ugly, but this appears to be difficult in Ruby, esp as the
+  # file may ultimately be called by another process, e.g. the main OpenCorporates app or the console, whose main
+  # directory is unrelated to where the databases are stored (which means we can't use Dir.pwd etc). The only time
+  # we know about the directory is when the module is called to extend the file, and we capture that in the
+  # @app_directory class variable
+  # def self.extended(obj)
+  #   path, = caller[0].partition(":")
+  #   @@app_directory = File.dirname(path)
+  # end
+
+end
+

data/lib/sqlite_magic/version.rb

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

data/spec/lib/sqlite_magic_spec.rb

@@ -0,0 +1,335 @@
+require_relative '../spec_helper'
+require 'sqlite_magic'
+
+describe SqliteMagic do
+  it "should define SqliteMagicError exception as subclass of StandardError" do
+    SqliteMagic::Error.superclass.should be StandardError
+  end
+
+  it "should define DatabaseError exception as subclass of Error" do
+    SqliteMagic::DatabaseError.superclass.should be SqliteMagic::Error
+  end
+
+  it "should define InvalidDataError exception as subclass of Error" do
+    SqliteMagic::NoSuchTable.superclass.should be SqliteMagic::Error
+  end
+
+  describe SqliteMagic::Connection do
+    before do
+      @dummy_db = stub('dummy_sqlite3_database')
+      SQLite3::Database.stub(:new).and_return(@dummy_db)
+      @connection = SqliteMagic::Connection.new
+    end
+
+    describe "initialisation" do
+      it "should return a type of connection" do
+        connection = SqliteMagic::Connection.new
+        connection.should be_kind_of SqliteMagic::Connection
+      end
+
+      it "should open up a Sqlite3 database with default name" do
+        SQLite3::Database.should_receive(:new).with('sqlite.db').and_return(@dummy_db)
+        connection = SqliteMagic::Connection.new
+      end
+
+      it "should use given db_name when setting up Sqlite3" do
+        SQLite3::Database.should_receive(:new).with('path/to/mynew.db').and_return(@dummy_db)
+        connection = SqliteMagic::Connection.new('path/to/mynew.db')
+      end
+
+      it "should store Sqlite3 database in @database instance variable" do
+        connection = SqliteMagic::Connection.new
+        connection.instance_variable_get(:@database).should == @dummy_db
+      end
+    end
+
+    it "should have #database accessor" do
+      SqliteMagic::Connection.new.database.should == @dummy_db
+    end
+
+    describe "#execute" do
+      before do
+        response_data = [['heading 1', 'heading 2', 'heading 3'],
+                         ['some val 1', 'some val 2', 'some val 3'],
+                         ['another val 1', 'another val 2', 'another val 3']]
+        @dummy_db.stub(:execute2).and_return(response_data)
+      end
+
+      it "should use #execute2 to run query on database" do
+        @dummy_db.should_receive(:execute2).with('some query',[:foo])
+
+        @connection.execute('some query',[:foo])
+      end
+
+      it "should return array of hashes" do
+        result = @connection.execute('some query',[:foo])
+        result.should be_kind_of Array
+        result.first.should be_kind_of Hash
+        result.size.should == 2
+      end
+
+      it "should use map results to hash with headings as keys" do
+        result = @connection.execute('some query',[:foo])
+        result.first['heading 1'].should == 'some val 1'
+      end
+
+      context 'and only headings returned' do
+        it "should return empty array" do
+          @dummy_db.stub(:execute2).and_return([['foo1','foo2']])
+          @connection.execute('some query',[:foo]).should == []
+        end
+      end
+
+      context 'and nil passed as second argument' do
+        it "should not pass bind vars to #execute2" do
+          @dummy_db.should_receive(:execute2).with('some query')
+
+          @connection.execute('some query',nil)
+        end
+      end
+    end
+
+    describe '#save_data' do
+      before do
+        @connection = SqliteMagic::Connection.new
+        @data = [{:foo => 'bar', :foo2 => 'bar2', :foo3 => 'bar3'},
+                 {:foo2 => 'baz2', :foo3 => 'baz3', :foo4 => 'baz4'}]
+        @unique_keys = [:foo2,:foo3]
+        @expected_query_1 = "INSERT OR REPLACE INTO foo_table (foo,foo2,foo3,foo4) VALUES (:foo,:foo2,:foo3,:foo4)"
+        @expected_query_2 = "INSERT OR REPLACE INTO foo_table (foo,foo2,foo3,foo4) VALUES (:foo,:foo2,:foo3,:foo4)"
+      end
+
+      it 'should insert each data hash using all given field names' do
+        @dummy_db.should_receive(:execute).with(@expected_query_1, @data[0])
+        @dummy_db.should_receive(:execute).with(@expected_query_2, @data[1])
+
+        @connection.save_data(@unique_keys, @data, 'foo_table')
+      end
+
+      context 'and datum is a single hash' do
+        it 'should save the hash' do
+          @expected_query_1 = "INSERT OR REPLACE INTO foo_table (foo,foo2,foo3) VALUES (:foo,:foo2,:foo3)"
+          @dummy_db.should_receive(:execute).with(@expected_query_1, @data.first)
+          @connection.save_data(@unique_keys, @data.first, 'foo_table')
+        end
+      end
+
+      context 'and table does not exist' do
+        before do
+          @dummy_db.stub(:execute) # default
+          # raise just once
+          @dummy_db.should_receive(:execute).with(@expected_query_1, @data[0]).
+                    and_raise(SQLite3::SQLException.new("no such table: foo_table") )
+        end
+
+        it 'should create table using all field names and unique keys' do
+          @connection.should_receive(:create_table).with('foo_table', [:foo,:foo2,:foo3, :foo4], @unique_keys)
+          @connection.save_data(@unique_keys, @data, 'foo_table')
+        end
+
+        it 'should insert data' do
+          @connection.stub(:create_table)
+          @dummy_db.should_receive(:execute).with(@expected_query_2, @data[1])
+
+          @connection.save_data(@unique_keys, @data, 'foo_table')
+        end
+      end
+
+      context 'and some columns do not exist' do
+        before do
+          @dummy_db.stub(:execute) # default
+          # raise just once
+          @dummy_db.should_receive(:execute).with(@expected_query_1, @data[0]).
+                    and_raise(SQLite3::SQLException.new("table mynewtable has no column named foo") )
+        end
+
+        it 'should create missing fields using all field names and unique keys' do
+          @connection.should_receive(:add_columns).with('foo_table', [:foo,:foo2,:foo3, :foo4])
+          @connection.save_data(@unique_keys, @data, 'foo_table')
+        end
+
+        it 'should insert data' do
+          @connection.stub(:add_columns)
+          @dummy_db.should_receive(:execute).with(@expected_query_2, @data[1])
+
+          @connection.save_data(@unique_keys, @data, 'foo_table')
+        end
+      end
+
+      context 'and some other error is raised' do
+        before do
+          @dummy_db.stub(:execute) # default
+          # raise just once
+          @dummy_db.should_receive(:execute).with(@expected_query_1, @data[0]).
+                    and_raise(SQLite3::SQLException.new("something else has gone wrong") )
+        end
+
+        it 'should raise error' do
+          lambda { @connection.save_data(@unique_keys, @data, 'foo_table') }.should raise_error(SQLite3::SQLException)
+          @connection.save_data(@unique_keys, @data, 'foo_table')
+        end
+      end
+
+      context 'and data for unique keys is nil' do
+        it 'should raise DatabaseError' do
+          @data.first[:foo2] = nil
+          lambda { @connection.save_data(@unique_keys, @data, 'foo_table') }.should raise_error(SqliteMagic::DatabaseError, /unique key.*foo2/)
+        end
+      end
+    end
+
+    describe '#create_table' do
+      it 'should create default table using given field names' do
+        expected_query = "CREATE TABLE some_table (foo,bar,baz)"
+        @dummy_db.should_receive(:execute).with(expected_query)
+        @connection.create_table(:some_table, [:foo,:bar,:baz])
+      end
+
+      context 'and unique keys are given' do
+        it 'should add constraint for given keys' do
+          expected_query = "CREATE TABLE some_table (foo,bar,baz, UNIQUE (foo,baz))"
+          @dummy_db.should_receive(:execute).with(expected_query)
+          @connection.create_table(:some_table, [:foo,:bar,:baz], [:foo,:baz])
+        end
+      end
+    end
+
+    describe "add_columns" do
+      before do
+        @table_info = [{"cid"=>0, "name"=>"bar", "type"=>"", "notnull"=>0, "dflt_value"=>nil, "pk"=>0},
+                       {"cid"=>1, "name"=>"rssd_id", "type"=>"", "notnull"=>0, "dflt_value"=>nil, "pk"=>0}]
+      end
+
+      it 'should get table info' do
+        @dummy_db.stub(:execute)
+        @dummy_db.should_receive(:table_info).with(:foo_table).and_return(@table_info)
+        @connection.add_columns(:foo_table, [:foo,:bar,:baz])
+      end
+
+      it 'should add columns that arent there already' do
+        @dummy_db.stub(:table_info).and_return(@table_info)
+        @dummy_db.should_receive(:execute).with('ALTER TABLE foo_table ADD COLUMN foo')
+        @dummy_db.should_receive(:execute).with('ALTER TABLE foo_table ADD COLUMN baz')
+        @connection.add_columns(:foo_table, [:foo,:bar,:baz])
+      end
+    end
+
+    describe '#insert_or_update' do
+      before do
+        @datum = {:foo => 'bar', :foo2 => 'bar2', :foo3 => 'bar3', :foo4 => 'bar4'}
+        @unique_keys = [:foo2,:foo3]
+        @expected_query = "INSERT INTO foo_table (foo,foo2,foo3,foo4) VALUES (:foo,:foo2,:foo3,:foo4)"
+      end
+
+      it 'should insert data' do
+        @dummy_db.should_receive(:execute).with(@expected_query, @datum)
+        @connection.insert_or_update(@unique_keys, @datum, 'foo_table')
+      end
+
+      it 'should not update data' do
+        @dummy_db.should_not_receive(:execute).with(/UPDATE/, anything)
+        @connection.insert_or_update(@unique_keys, @datum, 'foo_table')
+      end
+
+      context 'and no table name given' do
+        before do
+          @expected_query = "INSERT INTO ocdata (foo,foo2,foo3,foo4) VALUES (:foo,:foo2,:foo3,:foo4)"
+        end
+
+        it 'should use ocdata table by default' do
+          @dummy_db.should_receive(:execute).with(@expected_query, @datum)
+          @connection.insert_or_update(@unique_keys, @datum)
+        end
+      end
+
+      context 'and data already exists' do
+        before do
+          @dummy_db.should_receive(:execute).with(/INSERT/, anything).and_raise(SQLite3::ConstraintException.new('constraint failed'))
+          @expected_update_query = "UPDATE foo_table SET foo=:foo, foo4=:foo4 WHERE foo2=:foo2 AND foo3=:foo3"
+        end
+
+        it 'should update given columns dependent on unique keys' do
+          @dummy_db.should_receive(:execute).with(@expected_update_query, @datum)
+          @connection.insert_or_update(@unique_keys, @datum, 'foo_table')
+        end
+        context 'and no table name given' do
+          before do
+            @expected_update_query = "UPDATE ocdata SET foo=:foo, foo4=:foo4 WHERE foo2=:foo2 AND foo3=:foo3"
+          end
+
+          it 'should use ocdata table by default' do
+            @dummy_db.should_receive(:execute).with(@expected_update_query, @datum)
+            @connection.insert_or_update(@unique_keys, @datum)
+          end
+        end
+
+      end
+
+      context 'and SQLite3::SQLException raised' do
+        before do
+          @dummy_db.stub(:execute) # default
+          # raise just once
+          @dummy_db.should_receive(:execute).
+                    and_raise(SQLite3::SQLException )
+        end
+
+        it 'should defer to save_data' do
+          @connection.stub(:create_table)
+          @connection.should_receive(:save_data).with(@unique_keys, @datum, 'foo_table')
+
+          @connection.insert_or_update(@unique_keys, @datum, 'foo_table')
+        end
+      end
+    end
+
+    describe '#verbose?' do
+      it 'should return false if ENV["VERBOSE"] not set' do
+        @connection.verbose?.should be_false
+      end
+
+      it 'should return false if ENV["VERBOSE"] set' do
+        ENV["VERBOSE"] = 'foo'
+        @connection.verbose?.should be_true
+        ENV["VERBOSE"] = nil # reset
+      end
+    end
+
+    describe '#close' do
+      it 'should close database' do
+        @dummy_db.should_receive(:close)
+        @connection.close
+      end
+    end
+
+    describe '#commit' do
+      it 'should send commit to database' do
+        @dummy_db.should_receive(:commit)
+        @connection.commit
+      end
+    end
+  end
+
+  # before do
+  #   @dummy_db = stub('database_connection')
+  #   SqliteMagic.stub(:database).and_return(@dummy_db)
+  # end
+
+
+  # describe '#database_file' do
+  #   it 'should return file based on class and in db directory in working directory' do
+  #     expected_file = File.expand_path(File.join(File.dirname(__FILE__),'..','db','foobot.db'))
+  #     File.expand_path(SqliteMagic.database_file).should == expected_file
+  #   end
+  # end
+
+  # end
+  #
+  # describe '#unlock_database' do
+  #   it "should start and end transaction on database" do
+  #     @dummy_db.should_receive(:execute).with('BEGIN TRANSACTION; END;')
+  #     SqliteMagic.unlock_database
+  #   end
+  # end
+  #
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rspec/autorun'
+# require 'debugger'
+
+RSpec.configure do |config|
+end

data/sqlite_magic.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sqlite_magic/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sqlite_magic"
+  spec.version       = SqliteMagic::VERSION
+  spec.authors       = ["Chris Taggart"]
+  spec.email         = ["info@opencorporates.com"]
+  spec.description   = %q{Sprinkles some magic onto Sqlite3 gem. Sort of extracted from Scraperwiki gem}
+  spec.summary       = %q{Sprinkles some magic onto Sqlite3 gem}
+  spec.homepage      = ""
+  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_dependency "sqlite3"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification 
+name: sqlite_magic
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Chris Taggart
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-07-03 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: Sprinkles some magic onto Sqlite3 gem. Sort of extracted from Scraperwiki gem
+email: 
+- info@opencorporates.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sqlite_magic.rb
+- lib/sqlite_magic/version.rb
+- spec/.DS_Store
+- spec/lib/sqlite_magic_spec.rb
+- spec/spec_helper.rb
+- sqlite_magic.gemspec
+has_rdoc: true
+homepage: ""
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Sprinkles some magic onto Sqlite3 gem
+test_files: 
+- spec/.DS_Store
+- spec/lib/sqlite_magic_spec.rb
+- spec/spec_helper.rb