motion_record 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NDdiYmE3NTlmNjMzMmVjN2UwMmJhNjk1YTRlOGFlYmQxYjVmMmNkYQ==
+  data.tar.gz: !binary |-
+    YTgzNmU2OTFhMzVhNjRiYWZlNGY1MjZiZDQ0MWI5Njk0Y2VlMTQ3Zg==
+SHA512:
+  metadata.gz: !binary |-
+    NWVkNjgwMjUwYzBkNjgzY2FhNmY5OTM1YWI0N2M1Nzk4ZjQ2N2M5YWE5MTc4
+    NDViNWZkYmQ0NjhlZTFlMzM5NjAyOGIwNTMzYjQzNzEzMDhkNGE0OTkzZWM4
+    MTRkNDg4ZTA1N2NiYWJmNjBiZDcwY2I0Mjk5NTI0NzdjZWNjZmI=
+  data.tar.gz: !binary |-
+    ZDkxM2Y1ODI4NTFmYmExZjMwZjM2MzEzOTgxMjRiNWYyYWM1ODlmNWE4YWJk
+    MTNlNTY5ZTMyOTExZWE2ODRjYzRkYTZjODYyNDYzZGQ4ZGUxYjJjMmNhMmEy
+    YjMyYTRlMmRiYzhmNDIwOTUyMzEzOWM4MmRmMWI1Njk2M2U2MDY=

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/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Zach Millman
+
+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,246 @@
+MotionRecord
+============
+
+*Miniature ActiveRecord for RubyMotion*
+
+Everything you need to start using SQLite as the datastore for your RubyMotion
+app.
+
+:turtle: Android support should be coming soon
+
+[![Code Climate](https://codeclimate.com/github/magoosh/motion_record/badges/gpa.svg)](https://codeclimate.com/github/magoosh/motion_record) [![Test Coverage](https://codeclimate.com/github/magoosh/motion_record/badges/coverage.svg)](https://codeclimate.com/github/magoosh/motion_record)
+
+Installation
+------------
+
+Add this line to your Gemfile:
+
+```ruby
+gem "motion_record"
+```
+
+On iOS, MotionRecord uses [motion-sqlite3](https://github.com/mattgreen/motion-sqlite3)
+as a wrapper for connecting to SQLite, so add these too:
+
+```ruby
+gem "motion-sqlite3"
+# Requires the most recent unpublished version of motion.h
+# https://github.com/kastiglione/motion.h/issues/11
+gem "motion.h", :git => "https://github.com/kastiglione/motion.h"
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+* TODO: Android???
+
+MotionRecord::Schema
+--------------------
+
+Define and run all pending SQLite migrations with the `up!` DSL.
+
+```ruby
+def application(application, didFinishLaunchingWithOptions:launchOptions)
+  MotionRecord::Schema.up! do
+    migration 1, "Create messages table" do
+      create_table :messages do |t|
+        t.text    :subject,      null: false
+        t.text    :body
+        t.integer :read_at
+        t.integer :remote_id
+        t.float   :satisfaction, default: 0.0
+      end
+    end
+
+    migration 2, "Index messages table" do
+      add_index :messages, :remote_id, :unique => true
+      add_index :messages, [:subject, :read_at]
+    end
+  end
+  # ...
+end
+```
+
+#### Schema Configuration
+
+By default, MotionRecord will print all SQL statements and use a file named
+`"app.sqlite3"` in the application's Application Support folder. To disable
+logging (for release) or change the filename, pass configuration options to `up!`
+
+```ruby
+resource_file = File.join(NSBundle.mainBundle.resourcePath, "data.sqlite3")
+MotionRecord::Schema.up!(file: resource_file, debug: false) # ...
+```
+
+You can also specify that MotionRecord should use an in-memory SQLite database
+which will be cleared every time the app process is killed.
+
+```ruby
+MotionRecord::Schema.up!(file: :memory) # ...
+```
+
+MotionRecord::Base
+------------------
+
+MotionRecord::Base provides a superclass for defining objects which are stored
+in the database.
+
+```ruby
+class Message < MotionRecord::Base
+  # That's all!
+end
+```
+
+Attribute methods are inferred from the associated SQLite table definition.
+
+```ruby
+message = Message.new(subject: "Welcome!", body: "If you have any questions...")
+# => #<Message: @id=nil @subject="Welcome!" @body="If you have any..." ...>
+message.satisfaction
+# => 0.0
+```
+
+Manage persistence with `save!`, `delete!`, and `persisted?`
+
+```ruby
+message = Message.new(subject: "Welcome!", body: "If you have any questions...")
+message.save!
+message.id
+# => 1
+message.delete!
+message.persisted?
+# => false
+```
+
+* TODO: Better default inflection of class names to table names
+
+MotionRecord::Scope
+-------------------
+
+Build scopes on MotionRecord::Base classes with `where`, `order` and `limit`.
+
+```ruby
+Message.where(body: nil).order("read_at DESC").limit(3).find_all
+```
+
+Run queries on scopes with `exists?`, `first`, `find`, `find_all`, `pluck`,
+`update_all`, and `delete_all`.
+
+```ruby
+Message.where(remote_id: 2).exists?
+# => false
+Message.find(21)
+# => #<Message @id=21 @subject="What's updog?" ...>
+Message.where(read_at: nil).pluck(:subject)
+# => ["What's updog?", "What's updog?", "What's updog?"]
+Message.where(read_at: nil).find_all
+# => [#<Message @id=20 ...>, #<Message @id=21 ...>, #<Message @id=22 ...>]
+Message.where(read_at: nil).update_all(read_at: Time.now.to_i)
+```
+
+* TODO: Return "rows modified" count for update_all and delete_all
+
+Run calculations on scopes with `count`, `sum`, `maximum`, `minimum`, and
+`average`.
+
+```ruby
+Message.where(subject: "Welcome!").count
+# => 1
+Message.where(subject: "How do you like the app?").maximum(:satisfaction)
+# => 10.0
+```
+
+* TODO: Predicates for comparisons other than `=`
+* TODO: Handle datatype conversion in `where` and `update_all`
+
+MotionRecord::Serialization
+----------------------------------
+
+SQLite has a very limited set of datatypes (TEXT, INTEGER, and REAL), but you
+can easily store other objects as attributes in the database with serializers.
+
+#### Built-in Serializers
+
+MotionRecord provides a built-in serializer for Time objects to any column
+datatype.
+
+```ruby
+class Message < MotionRecord::Base
+  serialize :read_at, :time
+end
+
+Message.create!(subject: "Hello!", read_at: Time.now)
+#    SQL: INSERT INTO messages (subject, body, read_at, ...) VALUES (?, ?, ?...)
+# Params: ["Hello!", nil, 1420099200, ...]
+Message.first.read_at
+# => 2015-01-01 00:00:00 -0800
+```
+
+Boolean attributes can be serialized to INTEGER columns where 0 and NULL are
+`false` and any other value is `true`.
+
+```ruby
+class Message < MotionRecord::Base
+  serialize :satisfaction_submitted, :boolean
+end
+```
+
+Objects can also be stored to TEXT columns as JSON.
+
+```ruby
+class Survey < MotionRecord::Base
+  serialize :response, :json
+end
+
+survey = Survey.new(response: {nps: 10, what_can_we_improve: "Nothing :)"})
+survey.save!
+#    SQL: INSERT INTO surveys (response) VALUES (?)
+# Params: ['{"nps":10, "what_can_we_improve":"Nothing :)"}']
+Survey.first
+# => #<Survey: @id=1 @response={"nps"=>10, "what_can_we_improve"=>"Nothing :)"}>
+```
+
+* TODO: Make JSON serializer cross-platform
+
+#### Custom Serializers
+
+To write a custom serializer, extend MotionRecord::Serialization::BaseSerializer
+and provide your class to `serialize` instead of a symbol.
+
+```ruby
+class MoneySerializer < MotionRecord::Serialization::BaseSerializer
+  def serialize(value)
+    raise "Wrong column type!" unless @column.type == :integer
+    value.cents
+  end
+
+  def deserialize(value)
+    raise "Wrong column type!" unless @column.type == :integer
+    Money.new(value)
+  end
+end
+
+class Purchase < MotionRecord::Base
+  serialize :amount_paid_cents, MoneySerializer
+end
+```
+
+MotionRecord::Association
+-------------------------
+
+* TODO: has_many and belongs_to
+
+
+Contributing
+------------
+
+Please do!
+
+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/motion_record/base.rb

@@ -0,0 +1,54 @@
+module MotionRecord
+  class Base
+    include Persistence
+
+    def initialize(attributes={})
+      initialize_from_attribute_hash(attributes)
+    end
+
+    def to_attribute_hash
+      self.class.attribute_names.each_with_object({}) do |name, hash|
+        hash[name] = self.instance_variable_get "@#{name}"
+      end
+    end
+
+    def connection
+      self.class.connection
+    end
+
+    protected
+
+    def initialize_from_attribute_hash(hash)
+      self.class.attribute_defaults.merge(hash).each do |name, value|
+        self.instance_variable_set "@#{name}", value
+      end
+    end
+
+    class << self
+      # Add attribute methods to the model
+      #
+      # name    - Symobl name of the attribute
+      # options - optional configuration Hash:
+      #           :default - default value for the attribute (nil otherwise)
+      def define_attribute(name, options = {})
+        attr_accessor name
+        self.attribute_names << name.to_sym
+        if options[:default]
+          self.attribute_defaults[name.to_sym] = options[:default]
+        end
+      end
+
+      def attribute_names
+        @attribute_names ||= []
+      end
+
+      def attribute_defaults
+        @attribute_defaults ||= {}
+      end
+
+      def connection
+        ConnectionAdapters::SQLiteAdapter.instance
+      end
+    end
+  end
+end

data/lib/motion_record/connection_adapters/sqlite_adapter.rb

@@ -0,0 +1,160 @@
+module MotionRecord
+  module ConnectionAdapters
+    class SQLiteAdapter
+      class << self
+        # Configure the SQLite connection
+        #
+        # options - Hash of configuration options for the SQLite connection
+        #           :file - full name of the database file, or :memory for
+        #                   in-memory database files (default is "app.sqlite3"
+        #                   in the app's `/Library/Application Support` folder)
+        #           :debug - set to false to turn off SQL debug logging
+        def configure(options={})
+          @configuration_options = options
+        end
+
+        def instance
+          @instance ||= ConnectionAdapters::SQLiteAdapter.new(filename, debug?)
+        end
+
+        # Full filename of the database file
+        def filename
+          if (file = @configuration_options[:file])
+            if file == :memory
+              ":memory:"
+            else
+              file
+            end
+          else
+            create_default_database_file
+          end
+        end
+
+        # Returns true if debug logging is enabled for the database
+        def debug?
+          if @configuration_options.has_key?(:debug)
+            !!@configuration_options[:debug]
+          else
+            true
+          end
+        end
+
+        protected
+
+        # Create the default database file in `Library/Application Support` if
+        # it doesn't exist and return the file's full path
+        def create_default_database_file
+          fm = NSFileManager.defaultManager
+
+          support_path = fm.URLsForDirectory(NSApplicationSupportDirectory, inDomains: NSUserDomainMask).first.path
+          file_path = File.join(support_path, "app.sqlite3")
+
+          unless fm.fileExistsAtPath(file_path)
+            fm.createDirectoryAtPath(support_path, withIntermediateDirectories:true, attributes:nil, error:nil)
+            success = fm.createFileAtPath(file_path, contents: nil, attributes: nil)
+            raise "Couldn't create file #{path}" unless success
+          end
+
+          file_path
+        end
+      end
+
+      def initialize(file, debug=true)
+        @db = SQLite3::Database.new(file)
+        @db.logging = debug
+      end
+
+      def execute(command)
+        @db.execute(command)
+      end
+
+      def table_exists?(table_name)
+        # FIXME: This statement is totally vulnerable to SQL injection
+        @db.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='#{table_name}'").any?
+      end
+
+      # Load all records for a scope
+      #
+      # scope - A MotionRecord::Scope
+      #
+      # Returns an Array of row Hashes
+      def select(scope)
+        select_statement = "SELECT * FROM #{scope.klass.table_name} #{scope.predicate}"
+        @db.execute(select_statement, scope.predicate_values)
+      end
+
+      # Add a row to a table
+      #
+      # table_name - name of the table
+      # params     - Hash of column names to values to insert
+      def insert(table_name, params)
+        pairs = params.to_a
+        param_names  = pairs.map(&:first)
+        param_values = pairs.map(&:last)
+        param_marks = Array.new(param_names.size, "?").join(", ")
+
+        insert_statement = "INSERT INTO #{table_name} (#{param_names.join(", ")}) VALUES (#{param_marks})"
+
+        @db.execute insert_statement, param_values
+      end
+
+      # Add a row to a table
+      #
+      # scope  - A MotionRecord::Scope
+      # params - Hash of column names to values to update
+      def update(scope, params)
+        pairs = params.to_a
+        param_names  = pairs.map(&:first)
+        param_values = pairs.map(&:last)
+        param_marks  = param_names.map { |param| "#{param} = ?" }.join(", ")
+
+        update_statement = "UPDATE #{scope.klass.table_name} SET #{param_marks} #{scope.predicate}"
+
+        @db.execute update_statement, param_values + scope.predicate_values
+      end
+
+      # Delete rows from a table
+      #
+      # scope - MotionRecord::Scope defining the set of rows to delete
+      def delete(scope)
+        delete_statement = "DELETE FROM #{scope.klass.table_name} #{scope.predicate}"
+
+        @db.execute delete_statement, scope.predicate_values
+      end
+
+      # Run a calculation on a set of rows
+      #
+      # scope  - MotionRecord::Scope which defines the set of rows
+      # method - one of :count, :maximum, :minimum, :sum, :average
+      # column - name of the column to run the calculation on
+      #
+      # Returns the numerical value of calculation or nil if there were no rows
+      # in the scope
+      def calculate(scope, method, column)
+        case method
+        when :count
+          calculation = "COUNT(#{column || "*"})"
+        when :maximum
+          calculation = "MAX(#{column})"
+        when :minimum
+          calculation = "MIN(#{column})"
+        when :sum
+          calculation = "SUM(#{column})"
+        when :average
+          calculation = "AVG(#{column})"
+        else
+          raise "Unrecognized calculation: #{method.inspect}"
+        end
+
+        calculate_statement = "SELECT #{calculation} AS #{method} FROM #{scope.klass.table_name} #{scope.predicate}"
+
+        if (row = @db.execute(calculate_statement, scope.predicate_values).first)
+          row[method]
+        else
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/motion_record/persistence.rb

@@ -0,0 +1,99 @@
+module MotionRecord
+  module Persistence
+
+    def save!
+      persist!
+    end
+
+    def delete!
+      if persisted?
+        self.class.where(primary_key_condition).delete_all
+      else
+        raise "Can't delete unpersisted records"
+      end
+    end
+
+    def primary_key_condition
+      {self.class.primary_key => self.instance_variable_get("@#{self.class.primary_key}")}
+    end
+
+    def persisted?
+      !!@persisted
+    end
+
+    def mark_persisted!
+      @persisted = true
+    end
+
+    def mark_unpersisted!
+      @persisted = false
+    end
+
+    protected
+
+    def persist!
+      # HACK: Must ensure that attribute definitions are loaded from the table
+      self.class.table_columns
+
+      params = self.to_attribute_hash.reject { |k, _v| k == self.class.primary_key }
+      table_params = self.class.to_table_params(params)
+
+      if persisted?
+        self.class.where(primary_key_condition).update_all(table_params)
+      else
+        connection.insert self.class.table_name, table_params
+      end
+
+      self.mark_persisted!
+    end
+
+    module ClassMethods
+      include MotionRecord::ScopeHelpers::ClassMethods
+      include MotionRecord::Serialization::ClassMethods
+
+      def create!(attributes={})
+        self.new(attributes).save!
+      end
+
+      # Sybmol name of the primary key column
+      def primary_key
+        :id
+      end
+
+      def table_name
+        # HACK: poor-man's .pluralize
+        self.to_s.downcase + "s"
+      end
+
+      def table_columns
+        unless @table_columns
+          @table_columns = get_columns_from_schema.each_with_object({}) do |column, hash|
+            hash[column.name] = column
+          end
+          @table_columns.values.each do |column|
+            define_attribute_from_column(column)
+          end
+        end
+        @table_columns
+      end
+
+      protected
+
+      # Internal: Fetch column definitions from the database
+      def get_columns_from_schema
+        pragma_columns = connection.execute "PRAGMA table_info(#{table_name});"
+        pragma_columns.map { |p| Schema::ColumnDefinition.from_pragma(p) }
+      end
+
+      # Interal: Set up setter/getter methods to correspond with a table column
+      def define_attribute_from_column(column)
+        # TODO: handle options
+        define_attribute column.name, default: column.default
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end