gorm 0.0.2 → 0.0.3

data/bin/gorm

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+require 'gli'
+require 'cog'
+require 'fileutils'
+begin # XXX: Remove this begin/rescue before distributing your app
+require 'gorm'
+rescue LoadError
+  STDERR.puts "In development, you need to use `bundle exec bin/todo` to run your app"
+  STDERR.puts "At install-time, RubyGems will make sure lib, etc. are in the load path"
+  STDERR.puts "Feel free to remove this message from bin/gorm now"
+  exit 64
+end
+
+include GLI::App
+
+program_desc 'A code-Generating Object Relational Mapper for use with Qt and SQLite'
+
+version Gorm::VERSION
+
+desc 'Initialize gorm with a project'
+command :init do |c|
+  c.action do |global_options,options,args|
+    include Cog::Mixins::UsesTemplates
+    unless File.exists? 'Cogfile'
+      FileUtils.cp File.join(Cog::Config.gem_dir, 'Default.cogfile'), 'Cogfile'
+      puts 'Created ./Cogfile'
+    end
+    config = Cog::Config.for_project
+    unless File.exists? config.generator_dir
+      FileUtils.mkdir_p config.generator_dir 
+      puts "Created #{config.generator_dir}"
+    end
+    db_source = File.join(config.generator_dir, 'database.rb')
+    unless File.exists? db_source
+      FileUtils.cp Gorm.template_path('example_database.rb'), db_source
+      puts "Created #{db_source}"
+    end
+    puts "You may want to edit the Cogfile and change app_dir..."
+  end
+end
+
+desc 'Generate source files from the database.rb file'
+command :generate do |c|
+  c.action do |global_options,options,args|
+    config = Cog::Config.for_project
+    db_source = File.join(config.generator_dir, 'database')
+    require db_source
+  end
+end
+
+pre do |global,command,options,args|
+  # Pre logic here
+  # Return true to proceed; false to abourt and not call the
+  # chosen command
+  # Use skips_pre before a command to skip this block
+  # on that command only
+  true
+end
+
+post do |global,command,options,args|
+  # Post logic here
+  # Use skips_post before a command to skip this
+  # block on that command only
+end
+
+on_error do |exception|
+  # Error logic here
+  # return false to skip default error handling
+  true
+end
+
+exit run(ARGV)

data/lib/gorm/schema.rb

@@ -46,6 +46,7 @@ module Gorm
           :use_absolute_path => true,
           :target => "#{@output_path}.#{ext}"
       end
+      @tables.values.each {|t| t.generate! }
     end
     
     # Index of the last migration

data/lib/gorm/table.rb

@@ -1,11 +1,14 @@
 require 'gorm/column'
 require 'active_support/core_ext'
+require 'cog/mixins/uses_templates'
 
 module Gorm
   
   # Represents a table in a Schema.
   class Table
     
+    include Cog::Mixins::UsesTemplates
+    
     # The name of the table in the database
     attr_reader :table_name
     
@@ -16,6 +19,7 @@ module Gorm
       @schema = schema
       @table_name = name.to_s.pluralize.dasherize
       @class_name = name.to_s.singularize.camelize
+      @output_path = File.join schema.output_path, @class_name
       @columns = {}
     end
     
@@ -24,6 +28,15 @@ module Gorm
       @columns.values.sort
     end
 
+    # Generate the ORM source code
+    def generate!
+      [:cpp, :h].each do |ext|
+        stamp Gorm::template_path("table.#{ext}"),
+          :use_absolute_path => true,
+          :target => "#{@output_path}.#{ext}"
+      end
+    end
+    
     # An interface for defining a Table
     module TableDefinitionMethods
       # Define a Column in this table.

data/lib/gorm_version.rb

@@ -1,3 +1,3 @@
 module Gorm
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/templates/example_database.rb

@@ -0,0 +1,12 @@
+require 'gorm'
+
+Gorm.schema 'MyApp/Database', :namespace => 'MyApp' do |s|
+
+  s.migration do |m|
+    m.create_table :widgets do |t|
+      t.string :name
+      t.integer :size
+    end
+  end
+
+end

data/templates/schema.cpp.erb

@@ -0,0 +1,124 @@
+<%= generated_warning %> 
+
+#include "<%= output_path %>.h"
+#include "Bump/Bump.h"
+#include <QFile>
+#include <QtSql>
+
+using namespace <%= namespace %>;
+
+const QString DATABASE_FILENAME = "<%= namespace %>.sqlite";
+
+<%= class_name %>::<%= class_name %>(QObject *parent) :
+    QObject(parent)
+{
+}
+
+<%= class_name %>::~<%= class_name %>()
+{
+}
+
+bool <%= class_name %>::open()
+{
+    _qDatabase = QSqlDatabase::addDatabase("QSQLITE");
+    _qDatabase.setDatabaseName(sandboxPath(DATABASE_FILENAME));
+    return _qDatabase.open() && updateSchema();
+}
+
+bool <%= class_name %>::close()
+{
+    _qDatabase.close();
+    return true;
+}
+
+bool <%= class_name %>::erase()
+{
+    _qDatabase.close();
+    return QFile::remove(sandboxPath(DATABASE_FILENAME));
+}
+
+bool <%= class_name %>::updateSchema()
+{
+    int nextVersion;
+    int version = currentSchemaVersion();
+    while (version < APP_SCHEMA_VERSION)
+    {
+        if (!applyIncrementalMigration(version + 1))
+        {
+            qCritical() << "Could not apply incremental migration" << QString::number(version + 1)
+                        << _qDatabase.lastError();
+            return false;
+        }
+        nextVersion = currentSchemaVersion();
+        if (nextVersion <= version)
+        {
+            qCritical() << "Incremental migration failed to increment the database schema number";
+            return false;
+        }
+        version = nextVersion;
+    }
+    return true;
+}
+
+int <%= class_name %>::currentSchemaVersion() const
+{
+    Q_ASSERT(_qDatabase.isOpen() && _qDatabase.isValid());
+    if (_qDatabase.tables().count() == 0) return -1;
+    QSqlQuery query;
+    if (!query.exec("SELECT schema_version FROM meta WHERE id = 1") || !query.next())
+    {
+        qCritical() << "Unable to determine the current database schema version. The database is corrupt.";
+        abort();
+    }
+    return query.value(0).toInt();
+}
+
+bool <%= class_name %>::applyIncrementalMigration(int migrationVersion)
+{
+    switch(migrationVersion)
+    {
+<% migrations.each do |m| %>
+    case <%= m.index %>: return <%= m.method_call %>;
+<% end %>
+    default:
+        qCritical() << "No such schema migration version" << QString::number(migrationVersion);
+        return false;
+    }
+}
+
+<% migrations.each do |m| %>
+<%= m.method_stub :qualify => true %> 
+{
+    QSqlQuery query;
+    _qDatabase.transaction();
+    // TODO: migration body
+    query.exec("UPDATE meta SET schema_version = <%= m.index %> WHERE id = 1");
+    return _qDatabase.commit();
+}
+<% end %>
+
+// bool <%= class_name %>::applyMigration0()
+// {
+//     QSqlQuery query;
+//     _qDatabase.transaction();
+//     query.exec("CREATE TABLE meta (id INTEGER PRIMARY KEY, schema_version INTEGER)");
+//     query.exec("INSERT INTO meta VALUES (1, 1);");
+//     return _qDatabase.commit();
+// }
+// 
+// bool <%= class_name %>::applyMigration1()
+// {
+//     QSqlQuery query;
+//     _qDatabase.transaction();
+//     query.exec("CREATE TABLE file_types (id INTEGER PRIMARY KEY, name VARCHAR(256))");
+//     query.exec("CREATE TABLE file_type_recognizers (id INTEGER PRIMARY KEY, file_type_id INTEGER, extension VARCHAR(16), path_pattern TEXT)");
+//     query.exec("CREATE TABLE matchers (id INTEGER PRIMARY KEY, file_type_id INTEGER, pattern TEXT)");
+//     query.exec("INSERT INTO file_types VALUES (NULL, 'Bump Log')");
+//     int fileTypeId = query.lastInsertId().toInt();
+//     query.prepare("INSERT INTO matchers VALUES (NULL, ?, ?)");
+//     query.bindValue(0, fileTypeId);
+//     query.bindValue(1, "(?P<year>\\d{4})-(?P<month>\\d{2})-(?P<day>\\d{2})");
+//     query.exec();
+//     query.exec("UPDATE meta SET schema_version = 2 WHERE id = 1");
+//     return _qDatabase.commit();
+// }

data/templates/schema.h.erb

@@ -0,0 +1,76 @@
+<%= generated_warning %> 
+
+<%= include_guard_begin include_guard_name %> 
+
+#include <QObject>
+#include <QString>
+#include <QSqlDatabase>
+
+<%= namespace_begin namespace %> 
+
+
+class <%= class_name %> : public QObject
+{
+    Q_OBJECT
+    QSqlDatabase _qDatabase;
+
+    /** The schema version required by this release of the app. */
+    static const int APP_SCHEMA_VERSION = <%= app_schema_version %>;
+
+public:
+
+    explicit <%= class_name %>(QObject *parent = 0);
+    virtual ~<%= class_name %>();
+
+    /** Open the database. */
+    bool open();
+    
+    /** Close the database. */
+    bool close();
+    
+    /** Erase the database. */
+    bool erase();
+
+private:
+
+    /**
+      Apply the given incremental migration.
+      @param migrationVersion An integer indicating which migration to apply.
+        A migration version of 1 applies the migration which takes the database
+        from schema version 0 to 1. A migration version of 2 takes it from 1 to
+        2, and so on.
+      @returns @c false if the migration could not be applied.
+      */
+    bool applyIncrementalMigration(int migrationVersion);
+
+    /**
+      The schema version of the current database.
+      Schema versions start at 0 and increase at integer intervals. Schema
+      version -1 has a special meaning: the database is empty. Schema version
+      0 installs a meta table for keeping track of the current database schema.
+      Schema version 1 is the schema used by the first release of the app,
+      version 2 by the second release, and so on.
+      @returns The schema version.
+      */
+    int currentSchemaVersion() const;
+
+    /**
+      Update the database schema if necessary.
+      @returns @c false if the update failed.
+      */
+    bool updateSchema();
+
+private: // Schema Migrations
+<% migrations.each do |m| %>
+    <%= m.method_stub %>;
+<% end %>
+
+signals:
+    
+public slots:
+    
+};
+
+
+<%= namespace_end namespace %> 
+<%= include_guard_end %> 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: gorm
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Kevin Tonon
@@ -45,16 +45,52 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: aruba
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: gli
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 2
+        - 4
+        - 1
+        version: 2.4.1
+  type: :runtime
+  version_requirements: *id004
 description: 
 email: kevin@betweenconcepts.com
-executables: []
-
+executables: 
+- gorm
 extensions: []
 
 extra_rdoc_files: []
 
 files: 
+- bin/gorm
 - LICENSE
+- templates/example_database.rb
+- templates/schema.cpp.erb
+- templates/schema.h.erb
+- templates/table.cpp.erb
+- templates/table.h.erb
 - lib/gorm/column.rb
 - lib/gorm/migration.rb
 - lib/gorm/schema.rb
@@ -96,6 +132,6 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: A code-Generating Object Relational Mapper.
+summary: A code-Generating Object Relational Mapper for use with Qt and SQLite.
 test_files: []