amalgalite 0.4.2 → 0.5.0

data/ext/sqlite3ext.h

@@ -15,7 +15,7 @@
 ** as extensions by SQLite should #include this file instead of 
 ** sqlite3.h.
 **
-** @(#) $Id: sqlite3ext.h,v 1.24 2008/06/30 15:09:29 danielk1977 Exp $
+** @(#) $Id: sqlite3ext.h,v 1.25 2008/10/12 00:27:54 shane Exp $
 */
 #ifndef _SQLITE3EXT_H_
 #define _SQLITE3EXT_H_
@@ -208,7 +208,9 @@ struct sqlite3_api_routines {
 */
 #ifndef SQLITE_CORE
 #define sqlite3_aggregate_context      sqlite3_api->aggregate_context
+#ifndef SQLITE_OMIT_DEPRECATED
 #define sqlite3_aggregate_count        sqlite3_api->aggregate_count
+#endif
 #define sqlite3_bind_blob              sqlite3_api->bind_blob
 #define sqlite3_bind_double            sqlite3_api->bind_double
 #define sqlite3_bind_int               sqlite3_api->bind_int
@@ -264,14 +266,18 @@ struct sqlite3_api_routines {
 #define sqlite3_errmsg                 sqlite3_api->errmsg
 #define sqlite3_errmsg16               sqlite3_api->errmsg16
 #define sqlite3_exec                   sqlite3_api->exec
+#ifndef SQLITE_OMIT_DEPRECATED
 #define sqlite3_expired                sqlite3_api->expired
+#endif
 #define sqlite3_finalize               sqlite3_api->finalize
 #define sqlite3_free                   sqlite3_api->free
 #define sqlite3_free_table             sqlite3_api->free_table
 #define sqlite3_get_autocommit         sqlite3_api->get_autocommit
 #define sqlite3_get_auxdata            sqlite3_api->get_auxdata
 #define sqlite3_get_table              sqlite3_api->get_table
+#ifndef SQLITE_OMIT_DEPRECATED
 #define sqlite3_global_recover         sqlite3_api->global_recover
+#endif
 #define sqlite3_interrupt              sqlite3_api->interruptx
 #define sqlite3_last_insert_rowid      sqlite3_api->last_insert_rowid
 #define sqlite3_libversion             sqlite3_api->libversion
@@ -309,7 +315,9 @@ struct sqlite3_api_routines {
 #define sqlite3_thread_cleanup         sqlite3_api->thread_cleanup
 #define sqlite3_total_changes          sqlite3_api->total_changes
 #define sqlite3_trace                  sqlite3_api->trace
+#ifndef SQLITE_OMIT_DEPRECATED
 #define sqlite3_transfer_bindings      sqlite3_api->transfer_bindings
+#endif
 #define sqlite3_update_hook            sqlite3_api->update_hook
 #define sqlite3_user_data              sqlite3_api->user_data
 #define sqlite3_value_blob             sqlite3_api->value_blob

data/lib/amalgalite/blob.rb

@@ -11,7 +11,7 @@ module Amalgalite
   #
   # For instance during an insert:
   #
-  #   blob_column = db.schema.tables['blobs'].columsn['data']
+  #   blob_column = db.schema.tables['blobs'].columns['data']
   #   db.execute("INSERT INTO blobs(name, data) VALUES ( $name, $blob )",
   #             { "$name" => "/path/to/file",
   #               "$blob" => Amalgalite::Blob.new( :file => '/path/to/file',

data/lib/amalgalite/core_ext/kernel/require.rb

@@ -1,14 +1,21 @@
 module Kernel
+  # alias the original require away to use later
   alias :amalgalite_original_require :require
+
   #
   # hook into the system 'require' to allow for required text or blobs from an
   # amalgalite database.  
   #
   def require( filename )
-    found = Amalgalite::Requires.require( filename )
-    unless found
-      found = amalgalite_original_require( filename )
+    loaded = amalgalite_original_require( filename )
+  rescue LoadError => load_error
+    if load_error.message =~ /#{Regexp.escape filename}\z/ then
+      loaded = Amalgalite::Requires.require( filename )
+    else
+      raise load_error
     end
-    return found
   end
+
+  private :require
+  private :amalgalite_original_require
 end

data/lib/amalgalite/packer.rb

@@ -0,0 +1,221 @@
+require 'optparse'
+require 'ostruct'
+require 'pathname'
+require 'zlib'
+
+require 'amalgalite'
+module Amalgalite
+  #
+  # Pack items into an amalgalite database.  
+  #
+  class Packer
+    attr_reader :packing_list
+    attr_reader :dbfile
+    attr_reader :options
+
+    class << self
+      def default_options
+        {
+          :table_name        => Requires::Bootstrap::DEFAULT_TABLE,
+          :filename_column   => Requires::Bootstrap::DEFAULT_FILENAME_COLUMN,
+          :contents_column   => Requires::Bootstrap::DEFAULT_CONTENTS_COLUMN,
+          :compressed_column => Requires::Bootstrap::DEFAULT_COMPRESSED_COLUMN,
+          :strip_prefix      => Dir.pwd,
+          :compressed        => false,
+          :verbose           => false,
+        }
+      end
+
+      #
+      # compress data
+      #
+      def gzip( data )
+        zipped = StringIO.new
+        Zlib::GzipWriter.wrap( zipped ) do |io|
+          io.write( data )
+        end
+        return zipped.string
+      end
+
+      # 
+      # uncompress gzip data
+      #
+      def gunzip( data )
+        data = StringIO.new( data )
+        Zlib::GzipReader.new( data ).read
+      end
+
+
+      #
+      # return the files in their dependency order for use for packing into a
+      # database
+      #
+      def amalgalite_require_order
+        @require_order ||= %w[
+          amalgalite.rb
+          amalgalite/blob.rb
+          amalgalite/boolean.rb
+          amalgalite/column.rb
+          amalgalite/statement.rb
+          amalgalite/trace_tap.rb
+          amalgalite/profile_tap.rb
+          amalgalite/type_map.rb
+          amalgalite/type_maps/storage_map.rb
+          amalgalite/type_maps/text_map.rb
+          amalgalite/type_maps/default_map.rb
+          amalgalite/database.rb
+          amalgalite/index.rb
+          amalgalite/paths.rb
+          amalgalite/table.rb
+          amalgalite/view.rb
+          amalgalite/schema.rb
+          amalgalite/version.rb
+          amalgalite/sqlite3/version.rb
+          amalgalite/sqlite3/constants.rb
+          amalgalite/sqlite3/status.rb
+          amalgalite/sqlite3/database/status.rb
+          amalgalite/sqlite3.rb
+          amalgalite/taps/io.rb
+          amalgalite/taps/console.rb
+          amalgalite/taps.rb
+          amalgalite/packer.rb
+          amalgalite/core_ext/kernel/require.rb
+          amalgalite/requires.rb
+        ]
+      end
+    end
+
+    # 
+    # Create a new packer instance with the list of items to pack and all the
+    # options
+    #
+    def initialize(  options = {} )
+      @options = Packer.default_options.merge( options )
+      @dbfile  = @options[:dbfile] || Requires::Bootstrap::DEFAULT_DB
+    end
+
+    # 
+    # The SQL to create the table for storing ruby code
+    #
+    def create_table_sql
+      sql = <<-create
+      CREATE TABLE #{options[:table_name]} (
+      id                   INTEGER PRIMARY KEY AUTOINCREMENT,
+      #{options[:filename_column]}   TEXT UNIQUE,
+      #{options[:compressed_column]} BOOLEAN,
+      #{options[:contents_column]}   BLOB
+      );
+      create
+    end
+
+    #
+    # Make sure that the dbfile exists and has the appropriate schema.  
+    #
+    def check_db( db )
+      if db.schema.tables[ options[:table_name] ] and options[:drop_table] then
+        STDERR.puts "Dropping table #{options[:table_name]}" if options[:verbose]
+        db.execute("DROP TABLE #{options[:table_name]}")
+        db.reload_schema!
+      end
+
+      unless db.schema.tables[ options[:table_name] ]
+        db.execute( create_table_sql )
+        db.reload_schema!
+      end
+
+    end
+
+
+    #
+    # Stores all the .rb files in the list into the given database.  The prefix
+    # is the file system path to remove from the front of the path on each file
+    #
+    # manifest is an array of OpenStructs.  
+    #
+    def pack_files( manifest )
+      db = Amalgalite::Database.new( dbfile )
+      check_db( db )
+      max_width = manifest.collect{ |m| m.require_path.length }.sort.last
+      contents_column = db.schema.tables[ options[:table_name] ].columns[ options[:contents_column] ]
+      db.transaction do |trans|
+        manifest.each do |file_info|
+          msg  = "  -> #{file_info.require_path.ljust( max_width )} : "
+          begin
+            if options[:merge] then
+              trans.execute( "DELETE FROM #{options[:table_name]} WHERE #{options[:filename_column]} = ?", file_info.require_path )
+            end
+
+            trans.prepare("INSERT INTO #{options[:table_name]}(#{options[:filename_column]}, #{options[:compressed_column]}, #{options[:contents_column]}) VALUES( $filename, $compressed, $contents)") do |stmt|
+              contents = IO.readlines( file_info.file_path )
+              if options[:self] then
+                contents.each { |l| l.gsub!( /^(\s*require .*)$/m, "# commented out by #{self.class.name} \\1") }
+              end
+              contents = contents.join
+
+              if options[:compressed] then
+                contents = Packer.gzip( contents )
+              end
+              content_io = StringIO.new( contents )
+              stmt.execute( "$filename"   => file_info.require_path,
+                            "$contents"   => Amalgalite::Blob.new( :io => content_io,
+                                                                   :column => contents_column ),
+                            "$compressed" => options[:compressed] )
+              STDERR.puts "#{msg} stored #{file_info.file_path}" if options[:verbose]
+            end
+          rescue => e
+            STDERR.puts "#{msg} error #{e}"
+          end
+        end
+      end
+    end
+
+    #
+    # given a file, see if it can be found in the ruby load path, if so, return that
+    # full path
+    #
+    def full_path_of( rb_file )
+      $LOAD_PATH.each do |load_path|
+        guess = File.expand_path( File.join( load_path, rb_file ) )
+        return guess if File.exist?( guess )
+      end
+      return nil
+    end
+
+    # 
+    # Make the manifest for packing
+    #
+    def make_manifest( file_list )
+      manifest = []
+      prefix_path = ::Pathname.new( options[:strip_prefix] )
+      file_list.each do |f|
+        file_path = ::Pathname.new( File.expand_path( f ) )
+        m = ::OpenStruct.new
+        # if it is a directory then grab all the .rb files from it
+        if File.directory?( file_path ) then
+          manifest.concat( make_manifest( Dir.glob( File.join( f, "**", "*.rb" ) ) ) )
+          next
+        elsif File.readable?( file_path ) then
+          m.require_path = file_path.relative_path_from( prefix_path )
+          m.file_path    = file_path.realpath.to_s
+        elsif lp = full_path_of( f ) then
+          m.require_path = f
+          m.file_path    = lp
+        else
+          STDERR.puts "Unable to add #{f} to the manifest, cannot find the file on disk"
+          next
+        end
+        m.require_path = m.require_path.to_s[ /\A(.*)\.rb\Z/, 1]
+        manifest << m
+      end
+      return manifest
+    end
+
+    #
+    # Given a list of files pack them into the associated database and table.
+    #
+    def pack( file_list )
+      manifest = make_manifest( file_list )
+      pack_files( manifest )
+    end
+  end
+end

data/lib/amalgalite/requires.rb

@@ -1,77 +1,75 @@
 require 'amalgalite'
+require 'pathname'
+require 'zlib'
+require 'amalgalite/packer'
 
 module Amalgalite
   #
-  # Requires encapsulates requiring itesm from the database
+  # Requires encapsulates requiring items from the database
+  #
   class Requires
     class << self
       def load_path_db_connections
         @load_path_db_connections ||= {}
       end
+
       def load_path
         @load_path ||= []
       end
 
+      #
+      # Allocate a database connection to the given filename
+      #
       def db_connection_to( dbfile_name )
         unless connection = load_path_db_connections[ dbfile_name ] 
-          puts "loading file #{dbfile_name}"
           connection = ::Amalgalite::Database.new( dbfile_name )
           load_path_db_connections[dbfile_name] = connection
         end
         return connection
       end
 
-      def require( filename )
-        load_path.each { |lp| lp.require( filename ) }
+      # 
+      # Setting a class level variable as a flag to know what we are currently
+      # in the middle of requiring
+      #
+      def requiring
+        @requiring ||= []
       end
 
-      #
-      # return the files in their dependency order for use for packing into a
-      # database
-      #
-      def require_order
-        @require_roder ||= %w[
-          amalgalite.rb
-          amalgalite/blob.rb
-          amalgalite/boolean.rb
-          amalgalite/column.rb
-          amalgalite/statement.rb
-          amalgalite/trace_tap.rb
-          amalgalite/profile_tap.rb
-          amalgalite/type_map.rb
-          amalgalite/type_maps/storage_map.rb
-          amalgalite/type_maps/text_map.rb
-          amalgalite/type_maps/default_map.rb
-          amalgalite/database.rb
-          amalgalite/index.rb
-          amalgalite/paths.rb
-          amalgalite/table.rb
-          amalgalite/view.rb
-          amalgalite/schema.rb
-          amalgalite/version.rb
-          amalgalite/sqlite3/version.rb
-          amalgalite/sqlite3/constants.rb
-          amalgalite/sqlite3.rb
-          amalgalite/taps/io.rb
-          amalgalite/taps/console.rb
-          amalgalite/taps.rb
-          amalgalite/core_ext/kernel/require.rb
-          amalgalite/requires.rb
-       ]
-     end
-    end
+      def require( filename )
+        if load_path.empty? then
+          raise ::LoadError, "Amalgalite load path is empty -- #{filename}"
+        elsif $LOADED_FEATURES.include?( filename ) then
+          return false
+        elsif Requires.requiring.include?( filename ) then 
+          return false
+        else
+          Requires.requiring << filename
+          load_path.each do |lp|
+            if lp.require( filename ) then
+              Requires.requiring.delete( filename )
+              return true
+            end
+          end
+          Requires.requiring.delete( filename )
+          raise ::LoadError, "amalgalite has no such file to load -- #{filename}"
+        end
+      end
+   end
 
     attr_reader :dbfile_name
     attr_reader :table_name
     attr_reader :filename_column
     attr_reader :contents_column
+    attr_reader :compressed_column
     attr_reader :db_connection
 
     def initialize( opts = {} )
-      @dbfile_name     = opts[:dbfile_name]     || "lib.db"
-      @table_name      = opts[:table_name]      || "rubylibs"
-      @filename_column = opts[:filename_column] || "filename"
-      @contents_column = opts[:contents_column] || "contents"
+      @dbfile_name       = opts[:dbfile_name]       || Bootstrap::DEFAULT_DB
+      @table_name        = opts[:table_name]        || Bootstrap::DEFAULT_TABLE
+      @filename_column   = opts[:filename_column]   || Bootstrap::DEFAULT_FILENAME_COLUMN
+      @contents_column   = opts[:contents_column]   || Bootstrap::DEFAULT_CONTENTS_COLUMN
+      @compressed_column = opts[:compressed_column] || Bootstrap::DEFAULT_COMPRESSED_COLUMN
       @db_connection   = Requires.db_connection_to( dbfile_name )
       Requires.load_path << self
     end
@@ -80,32 +78,42 @@ module Amalgalite
     # return the sql to find the file contents for a file in this requires
     #
     def sql
-      @sql ||= "SELECT #{filename_column}, #{contents_column} FROM #{table_name} WHERE #{filename_column} = ?"
+      @sql ||= "SELECT #{filename_column}, #{compressed_column}, #{contents_column} FROM #{table_name} WHERE #{filename_column} = ?"
     end
 
     #
-    # require a file in this database table.  This will check and see if the
+    # load a file in this database table.  This will check and see if the
     # file is already required.  If it isn't it will select the contents
     # associated with the row identified by the filename and eval those contents
     # within the context of TOPLEVEL_BINDING.  The filename is then appended to
-    # $".
+    # $LOADED_FEATURES.
     #
     # if the file was required then true is returned, otherwise false 
     #
     def require( filename )
-      if $".include?( filename ) then
+      if $LOADED_FEATURES.include?( filename ) then
         return false
       else
         begin
+          filename = filename.gsub(/\.rb\Z/,'')
           rows = db_connection.execute(sql, filename)
-          row = rows.first
-          eval( row[contents_column].to_s, TOPLEVEL_BINDING)
-          $" << row[filename_column]
+          if rows.size > 0 then
+            row = rows.first
+            contents = row[contents_column].to_s
+            if row[compressed_column] then 
+              contents = ::Amalgalite::Packer.gunzip( contents )
+            end
+
+            eval( contents, TOPLEVEL_BINDING, row[filename_column] )
+            $LOADED_FEATURES << row[filename_column]
+            return true
+          else
+            return false
+          end
         rescue => e
-          raise LoadError, "Failure loading #{filename} from #{dbfile_name} : #{e}"
+          raise ::LoadError, "Failure loading #{filename} from #{dbfile_name} : #{e}"
         end
       end
-      return true
     end
   end
 end