motion_record 0.0.1

data/lib/motion_record/schema/column_definition.rb

@@ -0,0 +1,111 @@
+module MotionRecord
+  module Schema
+    class ColumnDefinition
+      TYPE_MAP = {
+        :integer => "INTEGER",
+        :text    => "TEXT",
+        :float   => "REAL"
+      }
+      INVERSE_TYPE_MAP = {
+        "INTEGER" => :integer,
+        "TEXT"    => :text,
+        "REAL"    => :float
+      }
+
+      attr_reader :type
+      attr_reader :name
+      attr_reader :options
+      
+      # name    - name of the column
+      # type    - a Symbol representing the column type
+      # options - Hash of constraints for the column:
+      #           :primary - set to true to configure as the primary auto-incrementing key
+      #           :null - set to false to add a "NOT NULL" constraint
+      #           :default - TODO
+      def initialize(type, name, options)
+        @type = type.to_sym
+        @name = name.to_sym
+        @options = options
+      end
+
+      def to_sql_definition
+        [@name, sql_type, sql_options].compact.join(" ")
+      end
+
+      def default
+        @options[:default]
+      end
+
+      # Build a new ColumnDefinition from the result of a "PRAGMA table_info()"
+      # query
+      #
+      # pragma - Hash representing a row of the query's result:
+      #          :cid - column index
+      #          :name - column name
+      #          :type - column type
+      #          :notnull - integer flag for "NOT NULL"
+      #          :dflt_value - default value
+      #          :pk - integer flag for primary key
+      #
+      # Returns the new ColumnDefinition
+      def self.from_pragma(pragma)
+        type = INVERSE_TYPE_MAP[pragma[:type]]
+        options = {
+          :null    => (pragma[:notnull] != 1),
+          :primary => (pragma[:pk] == 1),
+          :default => (pragma[:dflt_value])
+        }
+
+        if options[:default]
+          case type
+          when :integer
+            options[:default] = options[:default].to_i
+          when :float
+            options[:default] = options[:default].to_f
+          end
+        end
+
+        self.new(type, pragma[:name], options)
+      end
+
+      protected
+
+      def sql_type
+        if TYPE_MAP[@type]
+          TYPE_MAP[@type]
+        else
+          raise "Unrecognized column type: #{@type.inspect}"
+        end
+      end
+
+      def sql_options
+        sql_options = []
+
+        @options.each do |key, value|
+          case key
+          when :primary
+            if value
+              sql_options << "PRIMARY KEY ASC AUTOINCREMENT"
+            end
+          when :null
+            if !value
+              sql_options << "NOT NULL"
+            end
+          when :default
+            if value
+              sql_options << "DEFAULT #{value.inspect}"
+            end
+          else
+            raise "Unrecognized column option: #{key.inspect}"
+          end
+        end
+
+        if sql_options.any?
+          sql_options.join(" ")
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/motion_record/schema/index_definition.rb

@@ -0,0 +1,35 @@
+module MotionRecord
+  module Schema
+    class IndexDefinition
+
+      # Initialize the index definition
+      #
+      # table_name - name of the table
+      # columns    - either the String name of the column to index or an Array
+      #              of column names
+      # options    - optional Hash of options for the index
+      #              :unique - set to true to create a unique index
+      #              :name - provide a String to override the default index name
+      def initialize(table_name, columns, options={})
+        @table_name = table_name
+        @columns = columns.is_a?(Array) ? columns : [columns]
+
+        @name    = options[:name] || build_name_from_columns
+        @unique  = !!options[:unique]
+      end
+
+      # Add the index to the database
+      def execute
+        index_statement = "CREATE#{' UNIQUE' if @unique} INDEX #{@name} ON #{@table_name} (#{@columns.join ", "})"
+
+        MotionRecord::Base.connection.execute index_statement
+      end
+
+      protected
+
+      def build_name_from_columns
+        "index_#{@table_name}_on_#{@columns.join "_and_"}"
+      end
+    end
+  end
+end

data/lib/motion_record/schema/migration.rb

@@ -0,0 +1,25 @@
+# MotionRecord::Schema::Migration represents versions of migrations which have
+# been run
+
+module MotionRecord
+  module Schema
+    class Migration < Base
+      class << self
+        def table_name
+          "schema_migrations"
+        end
+
+        def table_exists?
+          connection.table_exists?(table_name)
+        end
+
+        def create_table
+          table = Schema::TableDefinition.new(table_name, id: false)
+          table.integer :version, :null => false
+          table.index :version, :unique => true
+          table.execute
+        end
+      end
+    end
+  end
+end

data/lib/motion_record/schema/migration_definition.rb

@@ -0,0 +1,32 @@
+module MotionRecord
+  module Schema
+    class MigrationDefinition
+      attr_reader :version
+      attr_reader :name
+
+      def initialize(version, name = nil)
+        @version = version.to_i
+        @name = name || "Migration ##{@version}"
+        @definitions = []
+      end
+
+      def execute
+        @definitions.each(&:execute)
+      end
+
+      def create_table(name, options = {})
+        table_definition = TableDefinition.new(name, options)
+
+        if block_given?
+          yield table_definition
+        end
+
+        @definitions << table_definition
+      end
+
+      def add_index(name, columns, options = {})
+        @definitions << IndexDefinition.new(name, columns, options)
+      end
+    end
+  end
+end

data/lib/motion_record/schema/migrator.rb

@@ -0,0 +1,39 @@
+module MotionRecord
+  module Schema
+    class Migrator
+
+      attr_reader :migrations
+
+      def initialize(migrations)
+        @migrations = migrations
+        @migrated_versions = nil
+
+        initialize_schema_table
+      end
+
+      def run
+        pending_migrations.each do |migration|
+          migration.execute
+          @migrated_versions << migration.version
+          Schema::Migration.create!(version: migration.version)
+        end 
+      end
+
+      def pending_migrations
+        @migrations.reject { |migration| migrated.include?(migration.version) }
+      end
+
+      def migrated
+        @migrated_versions ||= Schema::Migration.pluck(:version).sort
+      end
+
+      protected
+
+      def initialize_schema_table
+        unless Schema::Migration.table_exists?
+          Schema::Migration.create_table
+        end
+      end
+    end
+  end
+end

data/lib/motion_record/schema/migrator_definition.rb

@@ -0,0 +1,18 @@
+# DSL helper for defining migrations
+module MotionRecord
+  module Schema
+    class MigratorDefinition
+      attr_reader :migrations
+
+      def initialize
+        @migrations = []
+      end    
+
+      def migration(version, name=nil, &block)
+        migration_definition = Schema::MigrationDefinition.new(version, name)
+        migration_definition.instance_eval &block
+        @migrations << migration_definition
+      end
+    end
+  end
+end

data/lib/motion_record/schema/table_definition.rb

@@ -0,0 +1,46 @@
+module MotionRecord
+  module Schema
+    class TableDefinition
+      def initialize(name, options={})
+        @name = name
+        @columns = []
+        @index_definitions = []
+
+        unless options.has_key?(:id) && !options[:id]
+          add_default_primary_column
+        end
+      end
+
+      def execute
+        # Create table
+        column_sql = @columns.map(&:to_sql_definition).join(", ")
+        MotionRecord::Base.connection.execute "CREATE TABLE #{@name} (#{column_sql})"
+
+        # Create table's indexes
+        @index_definitions.each(&:execute)
+      end
+
+      def text(column_name, options={})
+        @columns << ColumnDefinition.new(:text, column_name, options)
+      end
+
+      def integer(column_name, options={})
+        @columns << ColumnDefinition.new(:integer, column_name, options)
+      end
+
+      def float(column_name, options={})
+        @columns << ColumnDefinition.new(:float, column_name, options)
+      end
+
+      def index(columns, options={})
+        @index_definitions << IndexDefinition.new(@name, columns, options)
+      end
+
+      protected
+
+      def add_default_primary_column
+        @columns << ColumnDefinition.new(:integer, "id", primary: true)
+      end
+    end
+  end
+end

data/lib/motion_record/schema.rb

@@ -0,0 +1,35 @@
+module MotionRecord
+  module Schema
+    # Define and run all pending migrations (should be done during app setup)
+    #
+    # 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
+    #
+    # Example:
+    #   
+    #     MotionRecord::Schema.up! do
+    #       migration 1, "Create events table" do
+    #         create_table "events" do |t|
+    #           t.text :name, :null => false
+    #           t.text :properties
+    #         end
+    #       end
+    #   
+    #       migration 2, "Index events table" do
+    #         add_index "events", "name", :unique => true
+    #       end
+    #     end
+    #
+    def self.up!(options={}, &block)
+      ConnectionAdapters::SQLiteAdapter.configure(options)
+
+      definition = Schema::MigratorDefinition.new
+      definition.instance_eval &block
+
+      Schema::Migrator.new(definition.migrations).run
+    end
+  end
+end

data/lib/motion_record/scope.rb

@@ -0,0 +1,129 @@
+# A model for building scoped database queries
+#
+
+module MotionRecord
+  class Scope
+
+    attr_reader :klass
+    attr_reader :conditions
+
+    def initialize(klass, options = {})
+      @klass = klass
+      @conditions = options[:conditions] || {} # TODO: freeze?
+      @order = options[:order]
+      @limit = options[:limit]
+    end
+
+    # Scope builder
+
+    def where(conditions={})
+      Scope.new(@klass, :conditions => @conditions.merge(conditions), :order => @order, :limit => @limit)
+    end
+
+    def order(ordering_term)
+      Scope.new(@klass, :conditions => @conditions, :order => ordering_term, :limit => @limit)
+    end
+
+    def limit(limit_value)
+      Scope.new(@klass, :conditions => @conditions, :order => @order, :limit => limit_value)
+    end
+
+    # Read-only queries
+
+    def exists?
+      count > 0
+    end
+
+    def first
+      limit(1).find_all.first
+    end
+
+    def find(id)
+      self.where(@klass.primary_key => id).first
+    end
+
+    def find_all
+      connection.select(self).map { |row| @klass.from_table_params(row) }
+    end
+
+    def pluck(attribute)
+      connection.select(self).map { |row| row[attribute] }
+    end
+
+    # Persistence queries
+
+    def update_all(params)
+      connection.update(self, params)
+    end
+
+    def delete_all
+      connection.delete(self)
+    end
+
+    # Calculations
+
+    def count(column=nil)
+      calculate(:count, column)
+    end
+
+    def maximum(column)
+      calculate(:maximum, column)
+    end
+
+    def minimum(column)
+      calculate(:minimum, column)
+    end
+
+    def sum(column)
+      calculate(:sum, column)
+    end
+
+    def average(column)
+      calculate(:average, column)
+    end
+
+    # SQL helpers
+
+    def predicate?
+      predicate_segments.any?
+    end
+
+    def predicate
+      predicate_segments.join(" ")
+    end
+
+    def predicate_values
+      condition_columns.map { |column| @conditions[column] }
+    end
+
+    protected
+
+    def calculate(method, column)
+      connection.calculate(self, method, column)
+    end
+
+    def predicate_segments
+      unless @predicate_segments
+        @predicate_segments = []
+        if condition_columns.any?
+          @predicate_segments << "WHERE #{condition_columns.map { |c| "#{c} = ? " }.join " AND "}"
+        end
+        if @order
+          @predicate_segments << "ORDER BY #{@order}"
+        end
+        if @limit
+          @predicate_segments << "LIMIT #{@limit}"
+        end
+      end
+      @predicate_segments
+    end
+
+    def condition_columns
+      @condition_columns ||= @conditions.keys
+    end
+
+    def connection
+      Base.connection
+    end
+  end
+end

data/lib/motion_record/scope_helpers.rb

@@ -0,0 +1,89 @@
+# These helper methods make it possible to call scope methods like `where` and
+# `find` directly on MotionRecord::Base classes
+#
+# Example:
+#
+#    Event.where(:name => "launched").find_all
+#
+# FIXME: MotionRecord::Persistence includes this module, but the normal file
+# ordering breaks the dependency
+module MotionRecord
+  module ScopeHelpers
+    module ClassMethods
+
+      # Read-only queries
+
+      def exists?
+        scoped.exists?
+      end
+
+      def first
+        scoped.first
+      end
+
+      def find(id)
+        scoped.find(id)
+      end
+
+      def find_all
+        scoped.find_all
+      end
+
+      def pluck(attribute)
+        scoped.pluck(attribute)
+      end
+
+      # Persistence queries
+
+      def update_all(params)
+        scoped.update_all(params)
+      end
+
+      def delete_all
+        scoped.delete_all
+      end
+
+      # Calculations
+
+      def count(column=nil)
+        scoped.count(column)
+      end
+
+      def maximum(column)
+        scoped.maximum(column)
+      end
+
+      def minimum(column)
+        scoped.minimum(column)
+      end
+
+      def sum(column)
+        scoped.sum(column)
+      end
+
+      def average(column)
+        scoped.average(column)
+      end
+
+      # Scope building
+
+      def where(conditions={})
+        scoped.where(conditions)
+      end
+
+      def order(ordering_term)
+        scoped.order(ordering_term)
+      end
+
+      def limit(limit_value)
+        scoped.limit(limit_value)
+      end
+
+      protected
+
+      def scoped
+        Scope.new(self)
+      end
+    end
+  end
+end

data/lib/motion_record/serialization/base_serializer.rb

@@ -0,0 +1,20 @@
+module MotionRecord
+  module Serialization
+    class BaseSerializer
+      # column - a Schema::ColumnDefinition object
+      def initialize(column)
+        @column = column
+      end
+
+      # Override this method in a subclass to define the custom serializer
+      def serialize(value)
+        raise "Must be implemented"
+      end
+
+      # Override this method in a subclass to define the custom serializer
+      def deserialize(value)
+        raise "Must be implemented"
+      end
+    end
+  end
+end

data/lib/motion_record/serialization/boolean_serializer.rb

@@ -0,0 +1,26 @@
+module MotionRecord
+  module Serialization
+    class BooleanSerializer < BaseSerializer
+
+      def serialize(value)
+        if @column.type == :integer
+          value ? 1 : 0
+        else
+          raise "Can't serialize #{value.inspect} to #{@column.type.inspect}"
+        end
+      end
+
+      def deserialize(value)
+        if @column.type == :integer
+          if value == 0 || value.nil?
+            false
+          else
+            true
+          end
+        else
+          raise "Can't deserialize #{value.inspect} from #{@column.type.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/motion_record/serialization/default_serializer.rb

@@ -0,0 +1,14 @@
+# This serializer converts the object back and forth as-is
+module MotionRecord
+  module Serialization
+    class DefaultSerializer < BaseSerializer
+      def serialize(value)
+        value
+      end
+
+      def deserialize(value)
+        value
+      end
+    end
+  end
+end

data/lib/motion_record/serialization/json_serializer.rb

@@ -0,0 +1,38 @@
+module MotionRecord
+  module Serialization
+    class JSONParserError < StandardError; end
+
+    class JSONSerializer < BaseSerializer
+
+      def serialize(value)
+        unless @column.type == :text
+          raise "JSON can only be serialized to TEXT columns"
+        end
+        self.class.generate_json(value)
+      end
+
+      def deserialize(value)
+        unless @column.type == :text
+          raise "JSON can only be deserialized from TEXT columns"
+        end
+        self.class.parse_json(value)
+      end
+
+      # JSON generate/parse code is hoisted from BubbleWrap::JSON
+
+      def self.generate_json(obj)
+        NSJSONSerialization.dataWithJSONObject(obj, options:0, error:nil).to_str
+      end
+
+      def self.parse_json(str_data)
+        return nil unless str_data
+        data = str_data.respond_to?('dataUsingEncoding:') ? str_data.dataUsingEncoding(NSUTF8StringEncoding) : str_data
+        opts = NSJSONReadingMutableContainers | NSJSONReadingMutableLeaves | NSJSONReadingAllowFragments
+        error = Pointer.new(:id)
+        obj = NSJSONSerialization.JSONObjectWithData(data, options:opts, error:error)
+        raise JSONParserError, error[0].description if error[0]
+        obj
+      end
+    end
+  end
+end