amalgalite 1.1.2-x86-mingw32 → 1.4.0-x86-mingw32

data/spec/text_map_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
+require 'spec_helper'
 require 'amalgalite/type_maps/text_map'
 
 describe Amalgalite::TypeMaps::TextMap do

data/spec/type_map_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
+require 'spec_helper'
 require 'amalgalite/type_map'
 
 describe Amalgalite::TypeMap do

data/spec/version_spec.rb

@@ -1,15 +1,8 @@
-require File.expand_path(File.join(File.dirname(__FILE__),"spec_helper.rb"))
+require 'spec_helper'
 require 'amalgalite/version'
 
-describe "Amalgalite::Version" do
+describe "Amalgalite::VERSION" do
   it "should have a version string" do
-    Amalgalite::Version.to_s.should =~ /\d+\.\d+\.\d+/
-    Amalgalite::VERSION.should =~ /\d+\.\d+\.\d+/
-  end
-  it "should have a version hash" do
-    h = Amalgalite::Version.to_hash
-    [ :major, :minor, :build ].each do |k|
-      h[k].should_not be_nil
-    end
+    expect(Amalgalite::VERSION).to match( /\d+\.\d+\.\d+/ )
   end
 end

data/tasks/custom.rake

@@ -0,0 +1,102 @@
+#-----------------------------------------------------------------------
+# Custom tasks for this project
+#-----------------------------------------------------------------------
+require 'pathname'
+namespace :util do
+  desc "List the sqlite api calls that are not implemented"
+  task :todo do
+
+    not_implementing = %w[
+      sqlite3_exec
+      sqlite3_open
+      sqlite3_os_end
+      sqlite3_os_init
+      sqlite3_malloc
+      sqlite3_realloc
+      sqlite3_free
+      sqlite3_get_table
+      sqlite3_free_table
+      sqlite3_key
+      sqlite3_rekey
+      sqlite3_next_stmt
+      sqlite3_release_memory
+      sqlite3_sleep
+      sqlite3_snprintf
+      sqlite3_vmprintf
+      sqlite3_strnicmp
+      sqlite3_test_control
+      sqlite3_unlock_notify
+      sqlite3_vfs_find
+      sqlite3_vfs_register
+      sqlite3_vfs_unregister
+    ]
+
+    sqlite_h = File.join( *%w[ ext amalgalite c sqlite3.h ] )
+    api_todo = {}
+    IO.readlines( sqlite_h ).each do |line|
+      if line =~ /\ASQLITE_API/ then
+        if line !~ /SQLITE_DEPRECATED/ and line !~ /SQLITE_EXPERIMENTAL/ then
+          if md = line.match( /(sqlite3_[^(\s]+)\(/ ) then
+                                next if not_implementing.include?(md.captures[0])
+                                api_todo[md.captures[0]] = true
+          end
+        end
+      end
+    end
+
+    Dir.glob("ext/amalgalite/c/amalgalite*.c").each do |am_file|
+      IO.readlines( am_file ).each do |am_line|
+        if md = am_line.match( /(sqlite3_[^(\s]+)\(/ ) then
+                                 api_todo.delete( md.captures[0] )
+        end
+      end
+    end
+
+    puts "#{api_todo.keys.size} functions to still implement"
+    puts api_todo.keys.sort.join("\n")
+  end
+
+  desc "Download and integrate a version of sqlite"
+  task :update_sqlite, [:version,:year] do |task, args|
+    version      = args[:version] or abort "A version of SQLite please `rake #{task.name}[version,year]`"
+    version_year = args[:year]    or abort "The Year #{version} was released please `rake #{task.name}[version,year]`"
+
+    require 'uri'
+    require 'open-uri'
+    require 'zip'
+
+    parts = version.split(".")
+    next_version = [ parts.shift.to_s ]
+    parts.each do |p|
+      next_version << "#{"%02d" % p }"
+    end
+    next_version << "00" if next_version.size == 3
+
+    next_version = next_version.join('')
+
+    url = ::URI.parse("http://sqlite.org/#{version_year}/sqlite-amalgamation-#{next_version}.zip")
+    puts "downloading #{url.to_s} ..."
+    file = "tmp/#{File.basename( url.path ) }"
+    FileUtils.mkdir "tmp" unless File.directory?( "tmp" )
+    File.open( file, "wb+") do |f|
+      open(url) do |input|
+        f.write( input.read )
+      end
+    end
+
+    puts "extracting..."
+    upstream_files = %w[ sqlite3.h sqlite3.c sqlite3ext.h ]
+    Zip::ZipInputStream.open( file ) do |io|
+      loop do
+        entry = io.get_next_entry
+        break unless entry
+        bname = File.basename( entry.name )
+        if upstream_files.include?( bname ) then
+          dest_file = File.join( "ext", "amalgalite", "c", bname )
+          puts "updating #{dest_file}"
+          entry.extract( dest_file ) { true }
+        end
+      end
+    end
+  end
+end

data/tasks/default.rake

@@ -0,0 +1,247 @@
+# vim: syntax=ruby
+require 'rake/clean'
+require 'digest'
+#------------------------------------------------------------------------------
+# If you want to Develop on this project just run 'rake develop' and you'll
+# have all you need to get going. If you want to use bundler for development,
+# then run 'rake develop:using_bundler'
+#------------------------------------------------------------------------------
+namespace :develop do
+
+  # Install all the development and runtime dependencies of this gem using the
+  # gemspec.
+  task :default => 'Gemfile' do
+    require 'rubygems/dependency_installer'
+    installer = ::Gem::DependencyInstaller.new
+    puts "Installing bundler..."
+    installer.install 'bundler'
+    sh 'bundle install'
+    puts "\n\nNow run 'rake test'"
+  end
+
+  # Create a Gemfile that just references the gemspec
+  file 'Gemfile' => :gemspec do
+    File.open( "Gemfile", "w+" ) do |f|
+      f.puts "# DO NOT EDIT - This file is automatically generated"
+      f.puts "# Make changes to Manifest.txt and/or Rakefile and regenerate"
+      f.puts 'source "https://rubygems.org/"'
+      f.puts 'gemspec'
+    end
+  end
+end
+desc "Boostrap development"
+task :develop => "develop:default"
+
+#------------------------------------------------------------------------------
+# Minitest - standard TestTask
+#------------------------------------------------------------------------------
+begin
+  require 'rake/testtask'
+  Rake::TestTask.new( :test ) do |t|
+    t.ruby_opts    = %w[ -w -rubygems ]
+    t.libs         = %w[ lib spec test ]
+    t.pattern      = "{test,spec}/**/{test_*,*_spec}.rb"
+  end
+
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new( :spec ) do |t|
+    t.ruby_opts    = %w[ -w ]
+    t.rspec_opts   = %w[ --color --format documentation ]
+  end
+  task :test_requirements
+  task :test => :test_requirements
+  task :default => :test
+rescue LoadError
+  This.task_warning( 'test' )
+end
+
+#------------------------------------------------------------------------------
+# RDoc - standard rdoc rake task, although we must make sure to use a more
+#        recent version of rdoc since it is the one that has 'tomdoc' markup
+#------------------------------------------------------------------------------
+begin
+  gem 'rdoc' # otherwise we get the wrong task from stdlib
+  require 'rdoc/task'
+  RDoc::Task.new do |t|
+    t.markup   = 'tomdoc'
+    t.rdoc_dir = 'doc'
+    t.main     = 'README.md'
+    t.title    = "#{This.name} #{This.version}"
+    t.rdoc_files.include( FileList['*.{rdoc,md,txt}'], FileList['ext/**/*.c'],
+                          FileList['lib/**/*.rb'] )
+  end
+rescue StandardError, LoadError
+  This.task_warning( 'rdoc' )
+end
+
+#------------------------------------------------------------------------------
+# Coverage - optional code coverage, rcov for 1.8 and simplecov for 1.9, so
+#            for the moment only rcov is listed.
+#------------------------------------------------------------------------------
+begin
+  require 'simplecov'
+  desc 'Run tests with code coverage'
+  task :coverage do
+    ENV['COVERAGE'] = 'true'
+    Rake::Task[:test].execute
+  end
+  CLOBBER << 'coverage' if File.directory?( 'coverage' )
+rescue LoadError
+  This.task_warning( 'simplecov' )
+end
+
+#------------------------------------------------------------------------------
+# Manifest - We want an explicit list of thos files that are to be packaged in
+#            the gem. Most of this is from Hoe.
+#------------------------------------------------------------------------------
+namespace 'manifest' do
+  desc "Check the manifest"
+  task :check => :clean do
+    files = FileList["**/*", ".*"].exclude( This.exclude_from_manifest ).to_a.sort
+    files = files.select{ |f| File.file?( f ) }
+
+    tmp = "Manifest.tmp"
+    File.open( tmp, 'w' ) do |f|
+      f.puts files.join("\n")
+    end
+
+    begin
+      sh "diff -du Manifest.txt #{tmp}"
+    ensure
+      rm tmp
+    end
+    puts "Manifest looks good"
+  end
+
+  desc "Generate the manifest"
+  task :generate => :clean do
+    files = %x[ git ls-files ].split("\n").sort
+    files.reject! { |f| f =~ This.exclude_from_manifest }
+    File.open( "Manifest.txt", "w" ) do |f|
+      f.puts files.join("\n")
+    end
+  end
+end
+
+#------------------------------------------------------------------------------
+# Fixme - look for fixmes and report them
+#------------------------------------------------------------------------------
+namespace :fixme do
+  task :default => 'manifest:check' do
+    This.manifest.each do |file|
+      next if file == __FILE__
+      next unless file =~ %r/(txt|rb|md|rdoc|css|html|xml|css)\Z/
+      puts "FIXME: Rename #{file}" if file =~ /fixme/i
+      IO.readlines( file ).each_with_index do |line, idx|
+        prefix = "FIXME: #{file}:#{idx+1}".ljust(42)
+        puts "#{prefix} => #{line.strip}" if line =~ /fixme/i
+      end
+    end
+  end
+
+  def fixme_project_root
+    This.project_path( '../fixme' )
+  end
+
+  def fixme_project_path( subtree )
+    fixme_project_root.join( subtree )
+  end
+
+  def local_fixme_files
+    This.manifest.select { |p| p =~ %r|^tasks/| }
+  end
+
+  def outdated_fixme_files
+    local_fixme_files.select do |local|
+      upstream     = fixme_project_path( local )
+      upstream.exist? &&
+        ( Digest::SHA256.file( local ) != Digest::SHA256.file( upstream ) )
+    end
+  end
+
+  def fixme_up_to_date?
+    outdated_fixme_files.empty?
+  end
+
+  desc "See if the fixme tools are outdated"
+  task :outdated => :release_check do
+    if fixme_up_to_date? then
+      puts "Fixme files are up to date."
+    else
+      outdated_fixme_files.each do |f|
+        puts "#{f} is outdated"
+      end
+    end
+  end
+
+  desc "Update outdated fixme files"
+  task :update => :release_check do
+    if fixme_up_to_date? then
+      puts "Fixme files are already up to date."
+    else
+      puts "Updating fixme files:"
+      outdated_fixme_files.each do |local|
+        upstream = fixme_project_path( local )
+        puts "  * #{local}"
+        FileUtils.cp( upstream, local )
+      end
+      puts "Use your git commands as appropriate."
+    end
+  end
+end
+desc "Look for fixmes and report them"
+task :fixme => "fixme:default"
+
+#------------------------------------------------------------------------------
+# Gem Specification
+#------------------------------------------------------------------------------
+# Really this is only here to support those who use bundler
+desc "Build the #{This.name}.gemspec file"
+task :gemspec do
+  File.open( This.gemspec_file, "wb+" ) do |f|
+    f.puts "# DO NOT EDIT - This file is automatically generated"
+    f.puts "# Make changes to Manifest.txt and/or Rakefile and regenerate"
+    f.write This.platform_gemspec.to_ruby
+  end
+end
+
+# .rbc files from ruby 2.0
+CLOBBER << FileList["**/*.rbc"]
+
+# The standard gem packaging task, everyone has it.
+require 'rubygems/package_task'
+::Gem::PackageTask.new( This.platform_gemspec ) do
+  # nothing
+end
+
+#------------------------------------------------------------------------------
+# Release - the steps we go through to do a final release, this is pulled from
+#           a compbination of mojombo's rakegem, hoe and hoe-git
+#
+# 1) make sure we are on the master branch
+# 2) make sure there are no uncommitted items
+# 3) check the manifest and make sure all looks good
+# 4) build the gem
+# 5) do an empty commit to have the commit message of the version
+# 6) tag that commit as the version
+# 7) push master
+# 8) push the tag
+# 7) pus the gem
+#------------------------------------------------------------------------------
+task :release_check do
+  unless `git branch` =~ /^\* master$/
+    abort "You must be on the master branch to release!"
+  end
+  unless `git status` =~ /^nothing to commit/m
+    abort "Nope, sorry, you have unfinished business"
+  end
+end
+
+desc "Create tag v#{This.version}, build and push #{This.platform_gemspec.full_name} to rubygems.org"
+task :release => [ :release_check, 'manifest:check', :gem ] do
+  sh "git commit --allow-empty -a -m 'Release #{This.version}'"
+  sh "git tag -a -m 'v#{This.version}' v#{This.version}"
+  sh "git push origin master"
+  sh "git push origin v#{This.version}"
+  sh "gem push pkg/#{This.platform_gemspec.full_name}.gem"
+end

data/tasks/extension.rake

@@ -1,212 +1,38 @@
-require 'tasks/config'
-require 'pathname'
+# To be used if the gem has extensions.
+# If this task set is inclueded then you will need to also have
+#
+#   spec.add_development_dependency( 'rake-compiler', '~> 0.8.1' )
+#
+# in your top level rakefile
 begin
-  require 'zip/zipfilesystem'
-rescue
-  abort "rake development_dependencies"
-end
-
-#-----------------------------------------------------------------------
-# Extensions
-#-----------------------------------------------------------------------
-
-if ext_config = Configuration.for_if_exist?('extension') then
-  namespace :ext do  
-    def current_sqlite_version
-      ext = Configuration.for('extension').configs.first
-      path = Pathname.new( ext )
-      h_path = path.dirname.realpath + "sqlite3.h"
-      File.open( h_path ) do |f|
-        f.each_line do |line|
-          if line =~ /\A#define SQLITE_VERSION\s+/ then
-            define ,constant ,value = line.split
-            return value
-          end
-        end
-      end
-    end
-
-    desc "Build the SQLite extension version #{current_sqlite_version}"
-    task :build => :clean do
-      ext_config.configs.each do |extension|
-        path  = Pathname.new(extension)
-        parts = path.split
-        conf  = parts.last
-        Dir.chdir(path.dirname) do |d| 
-          ruby conf.to_s
-          sh "make"
+  require 'rake/extensiontask'
+  require 'rake/javaextensiontask'
 
-          # install into requireable location so specs will run
-          subdir = "amalgalite/#{RUBY_VERSION.sub(/\.\d$/,'')}"
-          dest_dir = Amalgalite::Paths.lib_path( subdir )
-          mkdir_p dest_dir, :verbose => true
-          cp "amalgalite3.#{Config::CONFIG['DLEXT']}", dest_dir, :verbose => true
-        end
-      end
-    end
+  if RUBY_PLATFORM == "java" then
 
-    def myruby
-      require 'rbconfig'
-      x = File.join(
-        RbConfig::CONFIG['bindir'],
-        RbConfig::CONFIG['ruby_install_name']
-      )
-      #puts "myruby = #{x}"
-      return x
+    Rake::JavaExtensionTask.new( This.name) do |ext|
+      ext.ext_dir  = File.join( 'ext', This.name, "java" )
+      ext.lib_dir  = File.join( 'lib', This.name )
+      ext.gem_spec = This.java_gemspec
     end
 
-    def build_win( version = "1.8.7" )
-      ext_config = Configuration.for("extension")
-      rbconfig = ext_config.cross_rbconfig["rbconfig-#{version}"]
-      raise ArgumentError, "No cross compiler for version #{version}, we have #{ext_config.cross_rbconfig.keys.join(",")}" unless rbconfig
-     Amalgalite::GEM_SPEC.extensions.each do |extension|
-        path = Pathname.new(extension)
-        parts = path.split
-        conf = parts.last
-        rvm = File.expand_path( "~/.rvm/bin/rvm" )
-        Dir.chdir(path.dirname) do |d| 
-          if File.exist?( "Makefile" ) then
-            sh "make clean distclean"
-          end
-          cp "#{rbconfig}", "rbconfig.rb"
-          rubylib = ENV['RUBYLIB']
-          ENV['RUBYLIB'] = "."
-          sh %[ #{rvm} #{version} -S extconf.rb #{myruby} ]
-          ENV['RUBYLIB'] = rubylib
-          sh "make"
-        end
-      end
-    end
+  else
 
-    win_builds = []
-    ext_config.cross_rbconfig.keys.each do |v|
-      s = v.split("-").last
-      desc "Build the extension for windows version #{s}"
-      win_bname = "build_win-#{s}"
-      win_builds << win_bname
-      task win_bname => :clean do
-        build_win( s )
-      end
-    end
+    Rake::ExtensionTask.new( This.name ) do |ext|
+      ext.ext_dir   = File.join( 'ext', This.name, "c" )
+      ext.lib_dir   = File.join( 'lib', This.name )
+      ext.gem_spec  = This.ruby_gemspec
 
-    task :clean do
-      ext_config.configs.each do |extension|
-        path  = Pathname.new(extension)
-        parts = path.split
-        conf  = parts.last
-        Dir.chdir(path.dirname) do |d| 
-          if File.exist?( "Makefile" ) then
-            sh "make clean"
-          end
-          rm_f "rbconfig.rb"
-        end
-      end
-    end
-
-    desc "List the sqlite api calls that are not implemented"
-    task :todo do
-
-      not_implementing = %w[
-        sqlite3_exec
-        sqlite3_open
-        sqlite3_os_end
-        sqlite3_os_init
-        sqlite3_malloc
-        sqlite3_realloc
-        sqlite3_free
-        sqlite3_get_table
-        sqlite3_free_table
-        sqlite3_key
-        sqlite3_rekey
-        sqlite3_next_stmt
-        sqlite3_release_memory
-        sqlite3_sleep
-        sqlite3_snprintf
-        sqlite3_vmprintf
-        sqlite3_strnicmp
-        sqlite3_test_control
-        sqlite3_unlock_notify
-        sqlite3_vfs_find
-        sqlite3_vfs_register
-        sqlite3_vfs_unregister
-      ]
-
-      sqlite_h = File.join( *%w[ ext amalgalite sqlite3.h ] )
-      api_todo = {}
-      IO.readlines( sqlite_h ).each do |line|
-        if line =~ /\ASQLITE_API/ then
-          if line !~ /SQLITE_DEPRECATED/ and line !~ /SQLITE_EXPERIMENTAL/ then
-            if md = line.match( /(sqlite3_[^(\s]+)\(/ ) then
-              next if not_implementing.include?(md.captures[0])
-              api_todo[md.captures[0]] = true
-            end
-          end
-        end
-      end
-
-      Dir.glob("ext/amalgalite/amalgalite*.c").each do |am_file|
-        IO.readlines( am_file ).each do |am_line|
-          if md = am_line.match( /(sqlite3_[^(\s]+)\(/ ) then
-            api_todo.delete( md.captures[0] )
-          end
-        end
-      end
-
-      puts "#{api_todo.keys.size} functions to still implement"
-      puts api_todo.keys.sort.join("\n")
-    end
-
-    task :clobber do
-      ext_config.configs.each do |extension|
-        path  = Pathname.new(extension)
-        parts = path.split
-        conf  = parts.last
-        Dir.chdir(path.dirname) do |d| 
-          if File.exist?( "Makefile") then
-            sh "make distclean"
-          end
-          rm_f "rbconfig.rb"
-        end
-      end
-    end
-
-    desc "Download and integrate the next version of sqlite (use VERSION=x.y.z)"
-    task :update_sqlite do
-      require 'uri'
-      require 'net/http'
-      parts = ENV['VERSION'].split(".")
-      next_version = [ parts.shift.to_s ]
-      parts.each do |p|
-        next_version << "#{"%02d" % p }"
-      end
-      next_version << "00" if next_version.size == 3
-
-      next_version = next_version.join('')
-
-      raise "VERSION env variable must be set" unless next_version
-      url = ::URI.parse("http://sqlite.org/sqlite-amalgamation-#{next_version}.zip")
-      puts "downloading #{url.to_s} ..."
-      file = "tmp/#{File.basename( url.path ) }"
-      FileUtils.mkdir "tmp" unless File.directory?( "tmp" )
-      File.open( file, "wb+") do |f|
-        res = Net::HTTP.get_response( url )
-        f.write( res.body )
-      end
-
-      puts "extracting..."
-      upstream_files = %w[ sqlite3.h sqlite3.c sqlite3ext.h ]
-      Zip::ZipInputStream.open( file ) do |io|
-        loop do
-          entry = io.get_next_entry
-          break unless entry
-          bname = File.basename( entry.name )
-          if upstream_files.include?( bname ) then
-            dest_file = File.join( "ext", "amalgalite", bname )
-            puts "updating #{dest_file}"
-            entry.extract( dest_file ) { true }
-          end
-        end
-      end
+      ext.cross_compile  = true               # enable cross compilation (requires cross compile toolchain)
+      ext.cross_platform = 'i386-mingw32'     # forces the Windows platform instead of the default one
+                                              # configure options only for cross compile
     end
   end
+
+  task :test_requirements => :compile
+rescue LoadError
+  This.task_warning( 'extension' )
 end
+
+CLOBBER << FileList["lib/**/*.{jar,so,bundle}"]
+CLOBBER << FileList["lib/#{This.name}/{1.8,1.9,2.0,2.1,2.2}/"]