swiss_db 0.7.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 01e1d0c198065533e68a2417d669ce374b79ab3a
-  data.tar.gz: 42a742da3ffcd437106c950b4ead8d38cc0b1d1e
+  metadata.gz: a0fbc5f3c7344ef55064c2696beba8f4da742aba
+  data.tar.gz: 6f70e3f8bbb7bc480d048a2732a95ea15d89c4c3
 SHA512:
-  metadata.gz: e8bfce38d280954975035fcf532ff8092d6bfe4b0438723aa00affdf251064bc607bb3c9e01e0cda5a590e8d98ad18344ab4ac3e7bdc441f7852ba3b85351c1f
-  data.tar.gz: 59edfad052f96f049c52534e7f5d2ccdee6ef87000aa6b8d5e0d65886f1596152eafb17a68089225565f1cf7ffdd45debd14405922c90434996fe08fe6fb79af
+  metadata.gz: 3593083bc7e8fb6ac6a51bc98586d664d45839629c4694817ebcc2a3c158e3ea2b51c5a0a6c4f1846e0d947ba4ffcf67a07ae1dc8ab578bfbead3f93910ba369
+  data.tar.gz: a2be9798ef4500dc4e6ba2aeafeeceef33f4077a0f5e1eb7842d5f5b0f286179db532816f1dee2c6b102cefcc8357c0c2c68c0eaf9814367e9cd021fbe9de78e

data/README.md

@@ -1,8 +1,14 @@
-[![endorse](https://api.coderwall.com/jsilverMDX/endorsecount.png)](https://coderwall.com/jsilverMDX)
+If you'd like to support the continued development of SwissDB, please check out our Gratipay: https://gratipay.com/swissdb/
 
 # SwissDb
 
-RubyMotion Android ActiveRecord-like ORM for SQLite
+This is SwissDb, a RubyMotion Android ActiveRecord-like ORM for SQLite.
+
+SwissDb 1.0 is working and stable as of RubyMotion 4.11.
+
+## Example
+
+See: https://github.com/KCErb/swissdb_debug
 
 ## Installation
 
@@ -22,12 +28,28 @@ Or install it yourself as:
 
 ## Usage
 
+Usage is the same as ActiveRecord and CoreDataQuery.
+
+```ruby
+Car.create(is_red: true, mileage: (rand * 100_000).floor)
+car = Car.first
+car.is_red = true
+car.save
+mp Car.all.to_a
+car = Car.last
+car.update_attribute('is_red', false)
+
+```
+
+
 # Schemas
 
-Schemas are the exact same from CoreDataQuery and go in the same place. (schemas/)
+Schemas go in the project root under `schemas/`. You can stash multiple schema files here for your own records (`schema1.rb`, `schema2.rb`, etc.) but the schema your app actually uses must be named `schema.rb`.
+
+We're attempting to support both Core Data Query and Active Record type specifications like `datetime` `integer32` and `integer`. In SQLite there are only a few types anyways so that `integer32` and `integer` get created the same.
 
 ```ruby
-schema "0001" do
+schema version: 1 do
 
     entity "Car" do
       boolean   :is_red
@@ -46,14 +68,18 @@ schema "0001" do
 end
 ```
 
-Schema name (the "0001") does nothing.
+### Schema Version and Migrations
+
+You must specify a version with your schema. This integer (which must start at 1) is stored internally to the SQLite database and is used to determine if migrations need to be run.
+
+Migrating your database is not yet supported by SwissDB but is the next thing on the To-Do list.
 
 # Models
 
 Models are as such:
 
 ```ruby
-class Model < SwissModel
+class Model < SwissDB::SwissModel
 
   set_class_name "Model" # there are currently no hacks to automatically get this. sorry.
   set_primary_key "primary_key_name" # if not set, will default to "id"
@@ -61,9 +87,9 @@ class Model < SwissModel
 end
 ```
 
-# Set the context
+# Setup SwissDB
 
-Set the context in your bluepotion_application.rb.
+Since SwissDB needs to use your app's context you need to help it get setup like so:
 
 ```ruby
 class BluePotionApplication < PMApplication
@@ -71,7 +97,7 @@ class BluePotionApplication < PMApplication
   home_screen HomeScreen
 
   def on_create
-    DataStore.context = self
+    SwissDB.setup(self)
   end
 end
 ```
@@ -82,10 +108,15 @@ end
   Model.first.name
   Model.all.last.name
   Model.all.count
+  Model.find_by_<column>("some value") # dynamic finders
+  Model.create(hash_values) # returns created model
   m = Model.first
-  m.name = "Sam"
-  m.save # will persist the data
+  m.name = "Sam" # changed values will persist in the model instance
+  m.save # will persist the data to the database
   m.update_attribute("name", "chucky")
+  m = Model.new
+  m.thing = "stuff"
+  m.save # upsert, (insert if doesn't exist, and update if does)
 ```
 
 
@@ -101,10 +132,10 @@ As of 0.7.1 all returned objects are SwissModel instances. Model methods will no
 
 * detect class names of models for tableize
 
-KNOWN LIMITATION: This ORM compiles in the database name and the database version as a constant. Unfortunately I don't know of a way around this yet. This means no DB migrations yet by doing the simple version bump that is supported by Android. If we get a way to configure these from outside the gem, it will open up possibilities such as multiple schemas and migrations. To get around this simply delete your local database when you need to migrate. You can delete the app from the simulator/device (probably) or use my convenience command:
+KNOWN LIMITATION: No DB migrations yet by doing the simple version bump that is supported by Android. To get around this simply delete your local database when you need to migrate. You can delete the app from the simulator/device (probably) or use this convenience command:
 
 ```ruby
-   DataStore.drop_db #=> true if the DB was dropped, false if not
+   SwissDB::DataStore.drop_db #=> true if the DB was dropped, false if not
 ```
 
 ## Contributors
@@ -124,4 +155,3 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/jsilve
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-

data/lib/schema_tools/schema_builder.rb

@@ -0,0 +1,122 @@
+# load code for `tableize` here since this file is called outside of RubyMotion
+require 'motion-support/inflector/methods'
+require 'motion-support/inflector/inflections'
+require 'motion-support/array'
+require 'motion-support/string'
+require 'motion-support/default_inflections'
+
+module SchemaTools
+  class SchemaBuilder
+
+    def self.build_schema(app)
+      schema_filename = File.join(app.project_dir, 'schemas/schema.rb')
+      dsl = new
+      dsl.instance_eval(File.read(schema_filename))
+      return dsl.schema_hash, dsl.version
+    end
+
+    attr_accessor :schema_hash, :version
+
+    def schema(opts={}, &block)
+      check_opts(opts)
+      @version = opts[:version]
+      raise 'schema version must be an integer greater than 0' unless version_ok?
+      @schema_hash = {}
+      block.call
+    end
+
+    def check_opts(opts)
+      raise 'schema must supply a hash before the block' unless opts.is_a? Hash
+      raise 'schema must specify a version' unless opts[:version]
+    end
+
+    def version_ok?
+      version.is_a?(Integer) && version > 0
+    end
+
+    def entity(class_name, opts={}, &block)
+      # set default opts and merge passed in opts
+      @opts = { id: true }.merge opts
+      init_table(class_name)
+      block.call
+      ensure_primary_key
+    end
+
+    def init_table(class_name)
+      @current_table = class_name.tableize
+      @schema_hash[@current_table] = {}
+    end
+
+    def ensure_primary_key
+      # Check that the schema has one and only one primary key somewhere
+      table_schema = @schema_hash[@current_table]
+      valid_table = false
+      if @opts[:id]
+        table_schema['id'] = 'INTEGER PRIMARY KEY AUTOINCREMENT' unless table_schema.has_key? 'id'
+      else
+        primary_keys = table_schema.values.select{ |val| val.include? 'PRIMARY KEY' }
+        raise_primary_keys_error(table_schema.keys) unless primary_keys.length == 1
+      end
+    end
+
+    def add_column(name, type)
+      if @opts[:id] && name == 'id'
+        raise_id_error unless type == 'INTEGER'
+        type << ' PRIMARY KEY AUTOINCREMENT'
+      end
+      @schema_hash[@current_table][name] = type
+    end
+
+    %w(boolean float double integer datetime).each do |type|
+      define_method(type) do |*args|
+        column_name = args.first
+        column_opts =  args[1].is_a?(Hash) ? args[1] : {}
+        type = type.upcase
+        type = add_primary(type, column_name) if column_opts[:primary_key]
+        add_column column_name.to_s, type
+      end
+    end
+
+    def string(column_name, column_opts={})
+      type = 'VARCHAR'
+      type = add_primary(type, column_name) if column_opts[:primary_key]
+      add_column column_name.to_s, type
+    end
+
+    def integer32(column_name, column_opts={})
+      type = 'INTEGER'
+      type = add_primary(type, column_name) if column_opts[:primary_key]
+      add_column column_name.to_s, type
+    end
+
+    def raise_id_error
+      error_message = %Q(
+  Your schema defines a non integer `id` column for #{@current_table}.
+  If you do not wish to use the default id column, then you should
+  specify the `id: false` option.
+  )
+      raise error_message
+    end
+
+    def raise_primary_keys_error(primary_keys)
+      error_message = %Q(
+
+  Your schema specified `id: false` for #{@current_table} and therefore must
+  specify one primary key for this table. Instead you specified #{primary_keys.length}.
+
+  )
+      error_message += "These are the keys you gave: #{primary_keys}\n" if primary_keys.length > 1
+      raise error_message
+    end
+
+    def add_primary(type, name)
+      if @opts[:id]
+        puts "SWISS DB WARNING: ignoring primary_key: #{name} because `id` is the default primary key"
+      else
+        type << ' PRIMARY KEY'
+        type << ' AUTOINCREMENT' if type == 'INTEGER PRIMARY KEY'
+      end
+      type
+    end
+  end
+end

data/lib/schema_tools/writer.rb

@@ -0,0 +1,37 @@
+module SchemaTools
+  module Writer
+    class << self
+      attr_accessor :schema, :app
+
+      def create_schema_sql(schema, app)
+        @schema = schema
+        @app = app
+        write_schema_file
+      end
+
+      def write_version_file(version, app)
+        # TODO: Version checking, android expects monotonically increasing version ints
+        filename = File.join(app.resources_dirs.first, 'raw', 'version')
+        write_raw_resource_file(filename, version)
+      end
+
+      def write_schema_file
+        sql = ''
+
+        schema.each do |table_name, fields|
+          fields_string = fields.map { |k, v| "  #{k}   #{v}" }.join(",\n")
+          sql += "CREATE TABLE #{table_name}(\n#{fields_string}\n);\n\n"
+        end
+
+        filename = File.join(app.resources_dirs.first, 'raw', 'schema.sql')
+        write_raw_resource_file(filename, sql)
+      end
+
+      def write_raw_resource_file(filename, content)
+        # create raw directory if it doesn't exist
+        FileUtils.mkdir_p(File.dirname(filename))
+        File.write(filename, content)
+      end
+    end
+  end
+end

data/lib/swiss_db.rb

@@ -1,27 +1,41 @@
 # -*- coding: utf-8 -*-
 # SwissDB by jsilverMDX
 
-if defined?(Motion) && defined?(Motion::Project::Config)
-  lib_dir_path = File.dirname(File.expand_path(__FILE__))
-  Motion::Project::App.setup do |app|
-    # unless platform_name == "android"
-    #   raise "Sorry, the platform #{platform_name} is not supported by SwissDB"
-    # end
+def setup_schema(app)
+  require 'schema_tools/schema_builder'
+  require 'schema_tools/writer'
+  schema, version = SchemaTools::SchemaBuilder.build_schema(app)
+  SchemaTools::Writer.create_schema_sql(schema, app)
+  SchemaTools::Writer.write_version_file(version, app)
+  # TODO
+  # migrations = SwissDB::MigrationsBuilder.build_migrations
+  # SwissDB::SQLWriter.create_migration_sql(migrations)
+end
 
-    # scans app.files until it finds app/ (the default)
-    # if found, it inserts just before those files, otherwise it will insert to
-    # the end of the list
-    insert_point = app.files.find_index { |file| file =~ /^(?:\.\/)?app\// } || 0
+def building_app?(args)
+  # Don't write the schema to sql unless we're building the app
+  intersection = (args & %w(device archive build release emulator newclear))
+  !intersection.empty? || args == ""
+end
 
-    # change to "swiss_db" for just swiss_db
-    Dir.glob(File.join(lib_dir_path, "**/*.rb")).each do |file|
-      app.files.insert(insert_point, file)
-    end
+def add_app_files(app)
+  lib_dir_path = File.dirname(__FILE__)
+  insert_point = app.files.find_index { |file| file =~ /^(?:\.\/)?app\// } || 0
 
-    # load their schemas folder
-    app.files += Dir.glob("schemas/*.rb")
+  # Specify which folders to put into the app
+  swiss_db_files = Dir.glob(File.join(lib_dir_path, "/swiss_db/**/**.rb"))
+  motion_files = Dir.glob(File.join(lib_dir_path, "/motion-support/**/*.rb"))
 
-    # puts "APP FILES: #{app.files.inspect}"
+  (swiss_db_files + motion_files).each do |file|
+    app.files.insert(insert_point, file)
+  end
+end
 
+if defined?(Motion) && defined?(Motion::Project::Config)
+  Motion::Project::App.setup do |app|
+    setup_schema(app) if building_app?(ARGV)
+    add_app_files(app)
   end
+else
+  puts 'ERROR: SwissDB must be included in a RubyMotion App' if ARGV[0] != "gem:install"
 end

data/lib/swiss_db/cursor.rb

@@ -2,125 +2,178 @@
 # Helps move around a result set
 # Convenience methods over the standard cursor
 # Used by Swiss DataStore
+module SwissDB
+  class Cursor
 
-# class CursorModel # won't use model properties (custom methods)
+    FIELD_TYPE_BLOB    = 4
+    FIELD_TYPE_FLOAT   = 2
+    FIELD_TYPE_INTEGER = 1
+    FIELD_TYPE_NULL    = 0
+    FIELD_TYPE_STRING  = 3
 
-#   def initialize(h)
-#     h.each do |k,v|
-#       instance_variable_set("@#{k}", v)
-#     end
-#   end
+    attr_accessor :cursor, :model
 
-#   def method_missing(methId, *args)
-#     str = methId.id2name
-#     instance_variable_get("@#{str}")
-#   end
+    def initialize(cursor, model)
+      @cursor = cursor
+      @model = model
+      @values = {}
+    end
 
-# end
+    def model
+      @model
+    end
 
-class Cursor
+    def first
+      begin
+        return nil if count == 0
+        cursor.moveToFirst ? self : nil
+        swiss_model = model.new(to_hash)
+      ensure
+        cursor.close
+      end
+      swiss_model
+    end
 
-  FIELD_TYPE_BLOB    = 4
-  FIELD_TYPE_FLOAT   = 2
-  FIELD_TYPE_INTEGER = 1
-  FIELD_TYPE_NULL    = 0
-  FIELD_TYPE_STRING  = 3
+    def last
+      begin
+        return nil if count == 0
+        cursor.moveToLast ? self : nil
+        swiss_model = model.new(to_hash)
+      ensure
+        cursor.close
+      end
+      swiss_model
+    end
 
-  attr_accessor :cursor, :model
+    def current
+      model.new(to_hash)
+    end
 
-  def initialize(cursor, model)
-    @cursor = cursor
-    @model = model
-    @values = {}
-  end
+    def [](pos)
+      begin
+        return nil if count == 0
+        cursor.moveToPosition(pos) ? self : nil
+        swiss_model = model.new(to_hash)
+      ensure
+        cursor.close
+      end
+      swiss_model
+    end
 
-  def model
-    @model
-  end
+    def to_hash
+      hash_obj = {}
+      column_names.each do |k|
+        hash_obj[k] = self.send(k)
+      end
+      hash_obj
+    end
 
-  def first
-    return nil if count == 0
-    cursor.moveToFirst ? self : nil
-    model.new(to_hash, cursor)
-  end
+    def to_a
+      begin
+        return nil if count == 0
+        arr = []
+        (0...count).each do |i|
+          # puts i
+          cursor.moveToPosition(i)
+          arr << model.new(to_hash)
+        end
+      ensure
+        cursor.close
+      end
+      arr
+    end
 
-  def last
-    return nil if count == 0
-    cursor.moveToLast ? self : nil
-    model.new(to_hash, cursor)
-  end
+    # todo: take out setter code. it's not used anymore. leave the getter code. it is used. (see #to_hash)
 
-  def [](pos)
-    return nil if count == 0
-    cursor.moveToPosition(pos) ? self : nil
-    model.new(to_hash, cursor)
-  end
+    def method_missing(method_name, *args)
+      # puts "cursor method missing #{method_name}"
+      if valid_getter?(method_name)
+        get_method(method_name)
+      else
+        super
+      end
+    end
 
-  def to_hash
-      hash_obj = {}
-      $current_schema[model.table_name].each do |k, v|
-        hash_obj[k.to_sym] = self.send(k.to_sym)
+    def valid_getter?(method_name)
+      column_names.include? method_name
+    end
+
+    def is_setter?(method_name)
+      method_name[-1] == '='
+    end
+
+    def get_method(method_name)
+      index = cursor.getColumnIndex(method_name)
+      type = cursor.getType(index)
+      # puts "getting field #{method_name} at index #{index} of type #{type}"
+
+      if type == FIELD_TYPE_STRING #also boolean
+        str = cursor.getString(index).to_s
+
+        if str =~ /[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}.[0-9]{3}/
+          formatter = Java::Text::SimpleDateFormat.new('yyyy-MM-dd hh:mm:ss.SSS')
+          str = formatter.parse(str)
+        end
+
+        str = true if str == "true"
+        str = false if str == "false"
+        str
+      elsif type == FIELD_TYPE_INTEGER
+        cursor.getInt(index).to_i
+      elsif type == FIELD_TYPE_NULL
+        nil #??
+      elsif type == FIELD_TYPE_FLOAT
+        cursor.getFloat(index).to_f
+      elsif type == FIELD_TYPE_BLOB
+        cursor.getBlob(index)
       end
-      hash_obj
-  end
+    end
 
-  def to_a
-    return nil if count == 0
-    arr = []
-    (0...count).each do |i|
-      # puts i
-      cursor.moveToPosition(i)
-      arr << model.new(to_hash, cursor)
+    def count
+      cursor.getCount
+    end
+
+    def column_names
+      cursor.getColumnNames.map(&:to_sym)
     end
-    arr
-  end
 
-  # todo: take out setter code. it's not used anymore. leave the getter code. it is used. (see #to_hash)
+    def map(&block)
+      return [] if count == 0
+      arr = []
+      (0...count).each do |i|
+        # puts i
+        cursor.moveToPosition(i)
+        arr << yield(model.new(to_hash))
+      end
 
-  def method_missing(methId, *args)
-    method_name = methId.id2name
-    # puts "cursor method missing #{method_name}"
-    if valid_getter?(method_name)
-      get_method(method_name)
-    else
-      super
+      arr
     end
-  end
 
-  def valid_getter?(method_name)
-    column_names.include? method_name
-  end
+    def each(&block)
+      return [] if count == 0
+      arr = []
+      (0...count).each do |i|
+        # puts i
+        cursor.moveToPosition(i)
+        m = model.new(to_hash)
+        yield(m)
+        arr << m
+      end
 
-  def is_setter?(method_name)
-    method_name[-1] == '='
-  end
+      arr
+    end
 
-  def get_method(method_name)
-    index = cursor.getColumnIndex(method_name)
-    type = cursor.getType(index)
-    # puts "getting field #{method_name} at index #{index} of type #{type}"
-
-    if type == FIELD_TYPE_STRING #also boolean
-      str = cursor.getString(index).to_s
-      str = true if str == "true"
-      str = false if str == "false"
-      str
-    elsif type == FIELD_TYPE_INTEGER
-      cursor.getInt(index).to_i
-    elsif type == FIELD_TYPE_NULL
-      nil #??
-    elsif type == FIELD_TYPE_FLOAT
-      cursor.getFloat(index).to_f
-    elsif type == FIELD_TYPE_BLOB
-      cursor.getBlob(index)
+    # those methods allow the use of PMCursorAdapter with SwissDB
+    def moveToPosition(i)
+      cursor.moveToPosition(i)
     end
-  end
 
-  def count
-    cursor.getCount
-  end
+    def moveToLast
+      cursor.moveToLast
+    end
 
-  def column_names
-    cursor.getColumnNames
+    def moveToFirst
+      cursor.moveToFirst
+    end
   end
 end

data/lib/swiss_db/data_store.rb

@@ -1,50 +1,29 @@
-  # main connection point
-  # creates and upgrades our database for us
-  # and provides low level SQL features
-
+# main connection point
+# creates and upgrades our database for us
+# and provides low level SQL features
+module SwissDB
   class DataStore < Android::Database::SQLite::SQLiteOpenHelper
 
-    DATABASE_NAME = "swissdb"
-    DATABASE_VERSION = 1
     ContentValues = Android::Content::ContentValues
 
-    def self.current_schema=(schema)
-      @@current_schema = schema
-    end
-
-    def self.context=(context)
-      @@context = context
-    end
-
-    def self.context
-      @@context
-    end
-
     def writable_db
       getWritableDatabase
     end
 
     def self.drop_db
-      @@context.deleteDatabase(DATABASE_NAME)
+      SwissDB.context.deleteDatabase(SwissDB.db_name)
     end
 
     def onUpgrade(db, oldVersion, newVersion)
-      # maybe drop if needed...
-      db.execSQL("DROP *")
-      onCreate(db)
+      # TODO when migrations are implemented
+      mp "Calling onUpgrade"
+      mp "old version: #{oldVersion}"
+      mp "new version: #{newVersion}"
     end
 
     #create
     def onCreate(db)
-      # puts "table creation... running schema"
-      # THIS RELIES ON SCHEMA CODE TO SUCCEED
-      # NOTE: I don't know a better way of passing the schema here
-      # If you do just change it. For now this works.
-      # Thanks.
-      @@current_schema.each do |k, v|
-        create_table db, k, v
-      end
-      # database.execSQL("CREATE TABLE credentials(username TEXT, password TEXT)")
+      SwissDB.create_tables_from_schema(db)
     end
 
     #insert
@@ -52,7 +31,7 @@
       # puts "inserting data in #{table}"
       values = ContentValues.new(hash_values.count)
       hash_values.each do |k, v|
-        values.put(k, v)
+        values.put(k, coerces(v))
       end
       result = db.insert(table, nil, values)
       result
@@ -68,7 +47,7 @@
     def select(db=writable_db, table, values, model)
       puts "selecting data from #{table}"
       value_str = values.map do |k, v|
-        "#{k} = '#{v}'"
+        "#{k} = '#{coerces(v)}'"
       end.join(" AND ")
       sql = "select * from '#{table}' where #{value_str}"
       puts sql
@@ -80,10 +59,10 @@
 
     def update(db=writable_db, table, values, where_values)
       value_str = values.map do |k, v|
-        "'#{k}' = '#{v}'"
+        "'#{k}' = '#{coerces(v)}'"
       end.join(",")
       where_str = where_values.map do |k, v|
-        "#{k} = '#{v}'"
+        "#{k} = '#{coerces(v)}'"
       end.join(",")
       sql = "update '#{table}' set #{value_str} where #{where_str}"
       puts sql
@@ -97,13 +76,14 @@
       db.delete(table, nil, nil)
     end
 
-    # create table
-    def create_table(db=writable_db, table_name, fields)
-      fields_string = fields.map { |k, v| "#{k} #{v}" }.join(',')
-      sql = "CREATE TABLE #{table_name}(#{fields_string})"
-      puts sql
-      db.execSQL sql
+    # transform values
+    def coerces(v)
+      if v.is_a?(Time)
+        formatter = Java::Text::SimpleDateFormat.new('yyyy-MM-dd hh:mm:ss.SSS')
+        formatter.format(v).to_s
+      else
+        v.to_s
+      end
     end
-
-
-  end
+  end
+end

data/lib/swiss_db/swiss_db.rb

@@ -0,0 +1,66 @@
+module SwissDB
+  class << self
+
+    attr_accessor :store, :context, :resources, :version
+
+    def db_name
+      'swissdb'
+    end
+
+    def setup(context)
+      @context = context
+      @resources = context.getResources
+      get_version_from_raw
+      @store = DataStore.new(context, db_name, nil, version)
+    end
+
+    def get_version_from_raw
+      message = 'Error reading schema version'
+      read_from_raw_resource('version', message) do |reader|
+        @version = reader.readLine.to_i
+      end
+    end
+
+    def create_tables_from_schema(db)
+      message = 'Error reading schema SQL'
+      read_from_raw_resource('schema', message) do |reader|
+        execute_sql_script(db, reader)
+      end
+    end
+
+    def read_from_raw_resource(resource_name, error_message, &block)
+      resource_id = find_resource(resource_name, 'raw')
+      stream = resources.openRawResource(resource_id)
+      is_reader = Java::IO::InputStreamReader.new(stream)
+      reader = Java::IO::BufferedReader.new(is_reader)
+      begin
+        block.call(reader)
+      rescue
+        raise error_message
+      ensure
+        [stream, is_reader, reader].each(&:close)
+      end
+    end
+
+    private
+
+    def find_resource(name, type)
+      package_name = PMApplication.current_application.package_name
+      resources.getIdentifier(name, type, package_name)
+    end
+
+    def execute_sql_script(db, reader)
+      # is there a better way?
+      sql = ''
+      line = ''
+      while line = reader.readLine
+        sql << line
+        if line[-1] == ';'
+          db.execSQL(sql)
+          sql = ''
+        end
+      end
+    end
+
+  end
+end

data/lib/swiss_db/swiss_model.rb

@@ -1,122 +1,164 @@
 # Swiss Model
 # An ActiveRecord like Model for RubyMotion Android
+module SwissDB
+  class SwissModel
 
-class SwissModel
+    # meh? .. won't work for now in java... created classes become java packages
+    # name will become the namespace of the package...
+    # def self.inherited(subclass)
+    #    puts "New subclass: #{subclass.class.name.split('.').last}"
+    # end
 
-  # meh? .. won't work for now in java... created classes become java packages
-  # name will become the namespace of the package...
-  # def self.inherited(subclass)
-  #    puts "New subclass: #{subclass.class.name.split('.').last}"
-  # end
+    attr_accessor :values
 
-  attr_accessor :cursor, :values
+    def initialize(h={})
+      h.each do |k,v|
+        instance_variable_set("@#{k}", v)
+      end
+      @new_record = (h == {}) # any loaded record should have atleast SOME data
+      @values = {}
+    end
 
-  def initialize(h, cursor)
-    @cursor = cursor
-    h.each do |k,v|
-      instance_variable_set("@#{k}", v)
+    def self.method_missing(methId, *args)
+      str = methId.id2name
+      if str.include?("find_by")
+        where(str.split("find_by_")[1] => args[0]).first
+      end
     end
-    @values = {}
-  end
 
-  def method_missing(methId, *args)
-    str = methId.id2name
-    if instance_variable_get("@#{str}")
-      return instance_variable_get("@#{str}")
-    elsif str[-1] == '=' # setter
-      @values[str.chop] = args[0]
+    def method_missing(methId, *args)
+      str = methId.id2name
+
+      if str[-1] == '=' # setter
+        instance_variable_set("@#{str.chop}", args[0])
+        @values[str.chop] = args[0]
+        return args[0]
+      end
+
+      if instance_variable_get("@#{str}")
+        return instance_variable_get("@#{str}")
+      end
     end
-  end
 
-  def save
-    pk_value = self.send(self.class.primary_key.to_sym)
-    self.class.store.update(self.class.table_name, @values, {self.class.primary_key => pk_value})
-  end
+    def new_record?
+      @new_record
+    end
 
-  def update_attribute(key, value)
-    pk_value = self.send(self.class.primary_key.to_sym)
-    self.class.store.update(self.class.table_name, {key => value}, {self.class.primary_key => pk_value})
-  end
+    def save
+      unless new_record?
+        store.update(table_name,
+                     @values,
+                     {primary_key => primary_key_value})
+      else
+        store.insert(table_name,
+                     @values)
+      end
 
-  def update_attributes(hash)
-    hash.each do |k, v|
-      update_attribute(k, v)
+      @values = {}
     end
-  end
 
+    def update_attribute(key, value)
+      store.update(table_name,
+                   {key => value},
+                   {primary_key => primary_key_value})
+    end
 
-  def self.store
-    context = DataStore.context
-    @store ||= DataStore.new(context)
-    @store
-  end
+    def update_attributes(hash)
+      hash.each { |k, v| update_attribute(k, v) }
+    end
 
-  def self.class_name
-    @class_name
-  end
+    def primary_key
+      self.class.primary_key
+    end
 
-  def self.set_class_name(class_name) # hack, class.name not functioning in RM Android...
-    @class_name = class_name
-    set_table_name(class_name.tableize)
-  end
+    def primary_key_value
+      self.send(primary_key.to_sym)
+    end
 
-  def self.set_table_name(table_name)
-    @table_name = table_name
-  end
+    def table_name
+      self.class.table_name
+    end
 
-  def self.table_name
-    @table_name
-  end
+    def store
+      self.class.store
+    end
 
-  def self.set_primary_key(primary_key)
-    @primary_key = primary_key
-  end
+    # def destroy
+    #   # destroy this row
+    # end
 
-  def self.primary_key
-    @primary_key.nil? ? "id" : @primary_key
-  end
+    # -------------
+    # CLASS METHODS
+    # -------------
+    class << self
+      def store
+        SwissDB.store
+      end
 
-  def self.all
-    # select_all
-    cursor = store.select_all(@table_name, self)
-    cursor
-  end
+      def class_name
+        @class_name
+      end
 
-  def self.where(values)
-    # select <table> where <field> = <value>
-    cursor = store.select(@table_name, values, self)
-    cursor
-  end
+      def set_class_name(class_name) # hack, class.name not functioning in RM Android...
+        @class_name = class_name
+        set_table_name(class_name.tableize)
+      end
 
-  def self.first
-    # select all and get first
-    cursor = all.first
-    cursor
-  end
+      def set_table_name(table_name)
+        @table_name = table_name
+      end
 
-  def self.last
-    # select all and get last
-    cursor = all.last
-    cursor
-  end
+      def table_name
+        @table_name
+      end
 
-  def self.create(obj)
-    # create a row
-    result = store.insert(@table_name, obj)
-      if result == -1
-        puts "An error occured inserting values into #{@table_name}"
-      else
-        return result
+      def set_primary_key(primary_key)
+        @primary_key = primary_key
       end
-  end
 
-  # def destroy
-  #   # destroy this row
-  # end
+      def primary_key
+        @primary_key.nil? ? "id" : @primary_key
+      end
 
-  def self.destroy_all!
-    # destroy all of this kind (empty table)
-    store.destroy_all(@table_name)
-  end
+      def all
+        # select_all
+        cursor = store.select_all(@table_name, self)
+        cursor
+      end
+
+      def where(values)
+        # select <table> where <field> = <value>
+        cursor = store.select(@table_name, values, self)
+        cursor
+      end
+
+      def first
+        # select all and get first
+        model = all.first
+        model
+      end
+
+      def last
+        # select all and get last
+        model = all.last
+        model
+      end
 
-end
+      def create(obj)
+        # create a row
+        result = store.insert(@table_name, obj)
+        if result == -1
+          puts "An error occured inserting values into #{@table_name}"
+        else
+          return self.where(primary_key => result.intValue).first
+        end
+      end
+
+      def destroy_all!
+        # destroy all of this kind (empty table)
+        store.destroy_all(@table_name)
+      end
+    end
+
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: swiss_db
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Jonathan Silverman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-25 00:00:00.000000000 Z
+date: 2016-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -51,11 +51,12 @@ files:
 - lib/motion-support/inflector/inflections.rb
 - lib/motion-support/inflector/methods.rb
 - lib/motion-support/string.rb
+- lib/schema_tools/schema_builder.rb
+- lib/schema_tools/writer.rb
 - lib/swiss_db.rb
 - lib/swiss_db/cursor.rb
-- lib/swiss_db/data_store.java
 - lib/swiss_db/data_store.rb
-- lib/swiss_db/db.rb
+- lib/swiss_db/swiss_db.rb
 - lib/swiss_db/swiss_model.rb
 homepage: http://github.com/jsilverMDX
 licenses:

data/lib/swiss_db/data_store.java

@@ -1,8 +0,0 @@
-
-  private static final java.lang.String DB_NAME = "swissdb";
-  private static final int VERSION = 1;
-
-  public DataStore(android.content.Context context){
-    super(context, DB_NAME, null, VERSION);
-  }
-

data/lib/swiss_db/db.rb

@@ -1,61 +0,0 @@
-# "Swiss", RubyMotion Android SQLite by VirtualQ
-
-
-# schema loader stuff
-# i know it's rough but it works
-
-class Object
-
-  attr_accessor :current_schema
-
-  # convenience methods
-
-  def log(tag, str)
-    Android::Util::Log.d(tag, str)
-  end
-
-  def puts(str)
-    log "general", str
-  end
-
-  def current_schema
-    @current_schema
-  end
-
-  def schema(schema_name, &block)
-    puts "running schema for #{schema_name}"
-    @current_schema = {}
-    @database_name = schema_name
-    block.call
-    puts @current_schema.inspect
-  end
-
-  def entity(class_name, &block)
-    table_name = class_name.tableize
-    puts "adding entity #{table_name} to schema"
-    @table_name = table_name
-    @current_schema[@table_name] = {}
-    block.call
-    $current_schema = @current_schema
-    DataStore.current_schema = @current_schema
-  end
-
-  def add_column(name, type)
-    @current_schema[@table_name][name] = type
-  end
-
-  %w(boolean float double integer datetime).each do |type|
-    define_method(type) do |column_name|
-      add_column column_name.to_s, type.upcase
-    end
-  end
-
-  def string(column_name)
-    add_column column_name.to_s, "VARCHAR"
-  end
-
-  def integer32(column_name)
-    add_column column_name.to_s, "INTEGER"
-  end
-
-end