opal-activerecord 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 04e6c4caafb2f1e23a844f1d9719cd2a1f47af68
+  data.tar.gz: 306d390550152f3ade7714f97844dc0679e74267
+SHA512:
+  metadata.gz: d2dd02a27d5982fc90bd3ba984c7184b02f9b9d064f5b2aa3cd6b6c3803857979a01a8e8cc59156aa12a3ac612f6e1c39b72b2be1577220bcc6765be1b07d571
+  data.tar.gz: 44b465aed34c997a4657e7252b9f9c9b201e8e56532fcbb3f946dc813f49c33eee23ca5d5c14ad92d60cf808f71ad4f9f3522b76beb2629b8ea552ee975662c2

data/.gitignore

@@ -0,0 +1,5 @@
+# VIM
+.backups
+**/.backups
+*.swp
+

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'opal',       :github => 'opal/opal'
+gem 'opal-rspec', '0.3.0.beta2'
+
+gem 'rspec' # for testing in MRI
+
+group :test do
+  # for testing compatibility with non-opal activerecord
+  gem 'activerecord'
+  gem 'sqlite3'
+end

data/Gemfile.lock

@@ -0,0 +1,77 @@
+GIT
+  remote: git://github.com/opal/opal.git
+  revision: 139b534a8e14719f1406318d432b305ba76db4b1
+  specs:
+    opal (0.6.0)
+      source_map
+      sprockets
+
+PATH
+  remote: .
+  specs:
+    opal-activerecord (0.0.1)
+      opal (>= 0.5.0, < 1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.0.0)
+      activesupport (= 4.0.0)
+      builder (~> 3.1.0)
+    activerecord (4.0.0)
+      activemodel (= 4.0.0)
+      activerecord-deprecated_finders (~> 1.0.2)
+      activesupport (= 4.0.0)
+      arel (~> 4.0.0)
+    activerecord-deprecated_finders (1.0.3)
+    activesupport (4.0.0)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    arel (4.0.1)
+    atomic (1.1.14)
+    builder (3.1.4)
+    diff-lcs (1.2.4)
+    hike (1.2.3)
+    i18n (0.6.5)
+    json (1.8.1)
+    minitest (4.7.5)
+    multi_json (1.8.4)
+    opal-rspec (0.3.0.beta2)
+      opal (>= 0.6.0, < 1.0.0)
+    rack (1.5.2)
+    rake (10.1.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.3)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+    source_map (3.0.1)
+      json
+    sprockets (2.10.1)
+      hike (~> 1.2)
+      multi_json (~> 1.0)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sqlite3 (1.3.8)
+    thread_safe (0.1.3)
+      atomic
+    tilt (1.4.1)
+    tzinfo (0.3.38)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord
+  opal!
+  opal-activerecord!
+  opal-rspec (= 0.3.0.beta2)
+  rake
+  rspec
+  sqlite3

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) <year> <copyright holders>
+
+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/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Elia Schito
+
+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,51 @@
+# Opal: ActiveRecord
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'opal-activerecord'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install opal-activerecord
+
+
+## Usage
+
+Inside your `application.js.rb`:
+
+```ruby
+require 'active_record'                 # to require the whole active record lib
+```
+
+## Testing
+
+There are two ways to run tests. You can run them inside of MRI
+for ease of testing and better debuggability or you can run them
+using Opal (as this is how it will actually be used).
+
+* To run in Opal do - rake
+* To run in MRI do - rspec spec
+
+In addition to this, you can run the spec against the real active
+record to make sure the tests duplicate the functionality there. To
+run that:
+
+* run_with_real_active_record=true rspec spec
+
+## Contributing
+
+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
+
+## License
+
+opal-activerecord is Copyright © 2014 Steve Tuckner. It is free software, and may be redistributed under the terms specified in the LICENSE file (an MIT License).

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler.require
+
+require 'opal/rspec/rake_task'
+Opal::RSpec::RakeTask.new(:default)
+
+require 'bundler/gem_tasks'

data/lib/opal-activerecord.rb

@@ -0,0 +1 @@
+require 'opal/activerecord'

data/lib/opal/activerecord.rb

@@ -0,0 +1,5 @@
+require 'opal'
+require 'opal/activerecord/version'
+
+# Just register our opal code path with opal build tools
+Opal.append_path File.expand_path('../../../opal', __FILE__)

data/lib/opal/activerecord/version.rb

@@ -0,0 +1,5 @@
+module Opal
+  module Activerecord
+    VERSION = '0.0.1'
+  end
+end

data/opal-activerecord.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'opal/activerecord/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'opal-activerecord'
+  gem.version       = Opal::Activerecord::VERSION
+  gem.authors       = ['Steve Tuckner']
+  gem.email         = ['stevetuckner@stewdle.com']
+  gem.summary       = %q{A small port of the glorious ActiveRecord for Opal}
+  gem.description   = %q{
+                        This implements a subset of the rails/activerecord.
+                        It currently handles has_many and belongs_to
+                        associations, saving, finding and simple where
+                        queries. 
+                      }
+  gem.licenses      = ['MIT']
+  gem.homepage      = 'https://github.com/boberetezeke/opal-activerecord'
+  gem.rdoc_options << '--main' << 'README' <<
+                      '--line-numbers' <<
+                      '--include' << 'opal'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_dependency 'opal', ['>= 0.5.0', '< 1.0.0']
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'opal-rspec'
+end

data/opal/active_record.rb

@@ -0,0 +1 @@
+require 'active_record/core'

data/opal/active_record/core.rb

@@ -0,0 +1,545 @@
+class String
+  def singularize
+    /^(.*)s$/.match(self)[1]
+  end
+end
+
+def debug(str)
+  #puts(str) #if $debug_on
+end
+
+module Arel
+  class SelectManager
+    attr_accessor :ordering, :limit, :offset
+    attr_accessor :table_name, :node
+
+    def initialize(connection, table_name)
+      @connection = connection
+      @table_name = table_name
+    end
+
+    def where(node)
+      @node = node
+    end
+
+    def execute
+      @connection.execute(self)
+    end
+  end
+
+  module Nodes
+    class BinaryOp
+      attr_reader :left_node, :right_node
+      def initialize(left_node, right_node)
+        @left_node = left_node
+        @right_node = right_node
+      end
+
+      def to_s
+        "BinaryNode: #{self.class}: left:#{@left_node}, right:#{@right_node}"
+      end
+    end
+
+    class And < BinaryOp
+      def value(record)
+        @left_node.value(record) && @right_node.value(record)
+      end
+    end
+
+    class Or < BinaryOp
+      def value(record)
+        @left_node.value(record) || @right_node.value(record)
+      end
+    end
+
+    class Equality < BinaryOp
+      def value(record)
+        @left_node.value(record) == @right_node.value(record)
+      end
+    end
+
+    class NotEqual < BinaryOp
+      def value(record)
+        @left_node.value(record) != @right_node.value(record)
+      end
+    end
+
+    class Literal
+      def initialize(value)
+        @value = value
+      end
+
+      def value(record)
+        @value
+      end
+
+      def to_s
+        "Literal: #{@value}"
+      end
+    end
+
+    class Symbol
+      def initialize(symbol)
+        @symbol = symbol
+      end
+
+      def value(record)
+        record.send(@symbol)
+      end
+
+      def to_s
+        "Symbol: #{@symbol}"
+      end
+    end
+
+    class Ordering
+      attr_reader :order_str
+      def initialize(order_str)
+        @order_str = order_str
+      end
+    end
+
+    class Limit
+      attr_reader :limit
+      def initialize(limit)
+        @limit = limit
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  class Association
+    attr_reader :foreign_key, :association_type
+
+    def initialize(klass, association_type, name, options, connection)
+      @association_type = association_type
+      @klass = klass
+      @name = name
+      @options = options
+      @connection = connection
+      if @association_type == :belongs_to
+        @foreign_key =  "#{name}_id"
+      elsif @association_type == :has_many
+        @foreign_key = "#{@klass.table_name.singularize}_id"
+      end
+    end
+
+    def table_name
+      (@association_type == :belongs_to) ? @name.to_s + "s" : @name.to_s
+    end
+
+    def all
+      where(1 => 1)
+    end
+    alias load all
+
+    def where(query={})
+      Relation.new(query, @connection) 
+    end
+
+    def to_s
+      "#Association: #{@name}: #{@association_type}"
+    end
+  end
+
+  class CollectionProxy
+    def initialize(connection, owner, association)
+      @connection = connection
+      @owner = owner
+      @association = association
+    end
+
+    def <<(collection)
+      debug "CollectionProxy(owner: #{@owner})#<<(#{collection})"
+      collection = [collection] unless collection.is_a?(Array)
+      collection.each do |obj|
+        obj.write_attribute(@association.foreign_key, @owner.id)
+        obj.save
+      end
+    end
+
+    def method_missing(sym, *args, &block)
+      if [:first, :last, :all, :load, :reverse].include?(sym)
+        where_clause = "#{@owner.table_name.singularize}_id"
+        debug "#{sym}: for table: #{@association.table_name}, where: #{where_clause} == #{@owner.id}"
+        Relation.new(@connection, @association.table_name).where(where_clause => @owner.id).send(sym)
+      else
+        super
+      end
+    end
+  end
+
+  class Relation
+    def initialize(connection, table_name)
+      @select_manager = Arel::SelectManager.new(connection, table_name)
+    end
+
+    def execute
+      @records = @select_manager.execute
+    end
+
+    def where(query)
+      key, value = query.first
+      node = eq_node(key, value)
+      if query.keys.size > 1
+        query.to_a[1..-1].each do |key, value|
+          node = Arel::Nodes::And.new(node, eq_node(key, value))
+        end
+      end
+
+      @select_manager.where(node)
+      self
+    end
+
+    def order(order_str)
+      @select_manager.ordering = Arel::Nodes::Ordering.new(order_str)
+      self
+    end
+
+    def limit(num)
+      @select_manager.limit = Arel::Nodes::Limit.new(num)
+      self
+    end
+
+    def offset(index)
+      @select_manager.offset = Arel::Nodes::Offset.new(index)
+      self
+    end
+
+    def first
+      execute.first
+    end
+
+    def last
+      execute.last
+    end
+
+    def reverse
+      execute.reverse
+    end
+
+    def [](index)
+      execute[index]
+    end
+
+    def all
+      execute
+    end
+    alias load all
+
+    def each
+      execute.each { |record| yield record }
+    end
+
+    def eq_node(key, value)
+      Arel::Nodes::Equality.new(Arel::Nodes::Symbol.new(key), Arel::Nodes::Literal.new(value))
+    end
+  end
+
+  class MemoryStore
+    attr_reader :tables
+
+    def initialize
+      @tables = {}
+      @next_ids = {}
+    end
+
+    def execute(select_manager)
+      debug "MemoryStore#execute: table name = #{select_manager.table_name}"
+      debug "MemoryStore#execute: tables = #{@tables.keys}"
+      debug "MemoryStore#node = #{select_manager.node}"
+      records = @tables[select_manager.table_name.to_s].values.select do |record|
+        if select_manager.node
+          debug "MemoryStore#execute: checking record: #{record}"
+          select_manager.node.value(record)
+        else
+          true
+        end
+      end
+      debug "MemoryStore#execute: result = #{records.inspect}"
+      records
+    end
+
+    def push(table_name, record)
+      init_new_table(table_name)
+      @tables[table_name][record.id] = record
+    end
+
+    def find(table_name, id)
+      if @tables[table_name]
+        record = @tables[table_name][id]
+      else
+        record = nil
+      end
+
+      raise "record not found" unless record
+      record
+    end
+
+    def on_change(&call_back)
+      @change_callback = call_back
+    end
+
+    def create(table_name, record)
+      debug "MemoryStore#Create(#{record})"
+      init_new_table(table_name)
+      next_id = gen_next_id(table_name)
+      @tables[table_name][next_id] = record
+      @change_callback.call(:insert, record) if @change_callback
+      return next_id
+    end
+
+    def update(table_name, record)
+      init_new_table(table_name)
+      table = @tables[table_name]
+      @change_callback.call(:update, record) if @change_callback && record.attributes != table[record.id]
+      table[record.id] = record
+    end
+
+    def destroy(table_name, record)
+      @change_callback.call(:delete, record) if @change_callback
+      @tables[table_name].delete(record.id)
+    end
+
+    def gen_next_id(table_name)
+      next_id = @next_ids[table_name]
+      @next_ids[table_name] += 1
+      return "T-#{next_id}"
+    end
+
+    def init_new_table(table_name)
+      @tables[table_name] ||= {}
+      @next_ids[table_name] ||= 1
+    end
+
+    def to_s
+      "tables: #{@tables.inspect}, next_ids: #{@next_ids.inspect}"
+    end
+  end
+
+  class Base
+    attr_accessor :attributes, :observers
+
+    def self.new_from_json(json)
+      object = self.new
+      object.attributes = json
+      object
+    end
+
+    def self.accepts_nested_attributes_for(*args)
+    end
+
+    def self.default_scope(*args)
+    end
+
+    def self.scope(*args)
+    end
+
+    def self.has_many(name, options={})
+      @associations ||= {}
+      @associations[name.to_s] = Association.new(self, :has_many, name, options, @connection)
+    end
+
+    def self.belongs_to(name, options={})
+      @associations ||= {}
+      @associations[name.to_s] = Association.new(self, :belongs_to, name, options, @connection)
+    end
+    
+    def self.table_name
+      self.to_s.downcase + "s"
+    end
+
+    def self.find(id)
+      connection.find(table_name, id)
+    end
+
+    def self.associations
+      @associations || {}
+    end
+
+    def self.after_initialize(sym)
+      @after_initialize_callback = sym
+    end
+
+    def self.connection
+      # FIXME: Base.connection seems very hacky, ideally I would like
+      #        to do something like super.respond_to?(:connection)
+      #
+      @connection || Base.connection
+    end
+
+    def self.connection=(connection)
+      @connection = connection
+    end
+
+    def self.create(*args)
+      obj = self.new(*args)
+      #obj.save
+      obj
+    end
+
+    def self.method_missing(sym, *args)
+      if [:first, :last, :all, :where].include?(sym)
+        Relation.new(connection, table_name).send(sym, *args)
+      else
+        super
+      end
+    end
+
+    def self.new(*args)
+      super(*args)
+    end
+
+    def initialize(initializers={})
+      @attributes = {}
+      @associations = {}
+      @observers = {}
+      initializers.each do |initializer, value|
+        @attributes[initializer.to_s] = value
+      end
+    end
+
+    def method_missing(sym, *args)
+      method_name = sym.to_s
+      debug "Base#method_missing: #{method_name}, #{attributes}"
+      if m = /(.*)=$/.match(method_name)
+        val = write_value(m[1], args.shift)
+      else
+        val = read_value(method_name)
+      end
+      debug "Base#method_missing (at end), val = #{val}"
+      val
+    end
+
+    # stolen from ActiveRecord:core.rb
+    def ==(comparison_object)
+       super ||
+       comparison_object.instance_of?(self.class) &&
+         !id.nil? &&
+        comparison_object.id == id
+    end
+    alias :eql? :==
+
+    def on_change(sym, &block)
+      str = sym.to_s
+      self.observers ||= {}
+      self.observers[str] ||= []
+      self.observers[str].push(block)
+      debug "Base#on_change: self.observers = #{self.observers.inspect}"
+    end
+
+    def write_attribute(attribute_name, new_value)
+      attribute_name = attribute_name.to_s
+      old_value = self.attributes[attribute_name]
+      self.attributes[attribute_name] = new_value
+
+      if self.observers[attribute_name] then
+        self.observers[attribute_name].each do |observer|
+          observer.call(old_value, new_value)
+        end
+      end
+    end
+
+    def read_attribute(attribute_name)
+      self.attributes[attribute_name.to_s]
+    end
+
+    def write_value(name, new_value)
+      assoc = self.class.associations[name]
+      if assoc 
+        if self.id 
+          if assoc.association_type == :has_many
+            new_value.each do |value|
+              value.write_attribute("#{table_name.singularize}_id", self.id)
+              value.save
+            end
+          elsif assoc.association_type == :belongs_to
+            if new_value.id
+              write_attribute("#{new_value.table_name}_id", new_value.id)
+
+            else
+              write_attribute(name, new_value)
+            end
+          end
+        else
+          write_attribute(name, new_value)
+        end
+      else
+        write_attribute(name, new_value)
+      end
+    end
+
+    def read_value(name)
+      debug "Base#read_value, name = #{name}, self.class.associations = #{self.class.associations.inspect}"
+      if assoc = self.class.associations[name]
+        val = (assoc.association_type == :has_many)
+        if assoc.association_type == :has_many
+          if self.id
+            CollectionProxy.new(connection, self, assoc)
+          else
+            read_attribute(name) || []
+          end
+        elsif assoc.association_type == :belongs_to
+          if self.id
+            Relation.new(connection, assoc.table_name).where("id" => read_attribute("#{assoc.table_name}_id")).first
+          else
+            read_attribute(name)
+          end
+        end
+      else
+        read_attribute(name)
+      end
+    end
+
+    def save
+      debug "save: memory(before) = #{connection}"
+      debug "save: self(before): #{self}"
+      self.class.associations.to_a.select do |name_and_assoc|
+        name = name_and_assoc[0]
+        assoc = name_and_assoc[1]
+        assoc.association_type == :belongs_to
+      end.each do |name_and_assoc|
+        name = name_and_assoc[0]
+        assoc = name_and_assoc[1]
+        debug "name = #{name}, #{assoc}"
+        debug "value = #{read_attribute(name).inspect}"
+        belongs_to_value =  read_attribute(name)
+        if belongs_to_value 
+          debug "save: has belongs_to_value: id(#{belongs_to_value.id}), #{belongs_to_value.attributes}"
+          belongs_to_value.save unless belongs_to_value.id
+          @attributes["#{name}_id"] = belongs_to_value.id
+        end
+      end 
+
+      debug "save: self(after): #{self}"
+      if self.id
+        connection.update(table_name, self)
+      else
+        @attributes['id'] = connection.create(table_name, self)
+      end
+
+      debug "save: memory(after) = #{connection}"
+    end
+
+    def destroy
+      @connection.destroy(table_name, self)
+    end
+
+    def id
+      @attributes['id']
+    end
+
+    def table_name
+      self.class.table_name
+    end
+
+    def connection
+      self.class.connection
+    end
+
+    def to_s
+      "#{self.class}:#{self.attributes}"
+    end
+  end
+end

data/opal/opal-activerecord.rb

@@ -0,0 +1 @@
+require 'active_record'

data/spec/activerecord_spec.rb

@@ -0,0 +1,297 @@
+require 'spec_helper'
+
+class A < ActiveRecord::Base
+end
+
+class B < ActiveRecord::Base
+  has_many :cs
+end
+
+class C < ActiveRecord::Base
+  belongs_to :b
+  has_many :ds
+end
+
+class D < ActiveRecord::Base
+  belongs_to :c
+  belongs_to :e
+end
+
+class E < ActiveRecord::Base
+  has_many :ds
+  has_many :cs, :through => :ds
+end
+
+describe "ActiveRecord::Base" do
+  if running_with_real_active_record
+    before do
+      ActiveRecord::Base.establish_connection(
+        adapter:  'sqlite3',
+        database: 'test.sqlite3'
+      )
+      ActiveRecord::Base.connection.create_table("as") {|t| t.integer :x; t.integer :y}
+      ActiveRecord::Base.connection.create_table("bs") {|t| t.integer :x; t.integer :y}
+      ActiveRecord::Base.connection.create_table("cs") {|t| t.integer :x; t.integer :y; t.integer :b_id}
+      ActiveRecord::Base.connection.create_table("ds") {|t| t.integer :x; t.integer :y; t.integer :c_id; t.integer :e_id}
+      ActiveRecord::Base.connection.create_table("es") {|t| t.integer :x; t.integer :y}
+    end
+
+    after do
+      ActiveRecord::Base.connection.drop_table("as")
+      ActiveRecord::Base.connection.drop_table("bs")
+      ActiveRecord::Base.connection.drop_table("cs")
+      ActiveRecord::Base.connection.drop_table("ds")
+      ActiveRecord::Base.connection.drop_table("es")
+    end
+  else
+    # only set memory_store for opal
+    let(:memory_store) { ActiveRecord::MemoryStore.new }
+    before do
+      ActiveRecord::Base.connection = memory_store
+    end
+  end
+
+  if !running_with_real_active_record
+    describe ".new_from_json" do
+      context "when constructing just one object" do
+        it "should set attributes on a class with no relationships" do
+          a = A.new_from_json({"x" => 1, "y" => 2})
+          expect(a.x).to eq(1)
+          expect(a.y).to eq(2)
+        end
+
+        it "should set attributes on a class with a has_many relationship" do
+          b = B.new_from_json({"x" => 1, "y" => 2})
+          expect(b.x).to eq(1)
+          expect(b.y).to eq(2)
+        end
+
+        it "should set attributes on a class with a belongs_to relationship" do
+          d = D.new_from_json({"x" => 1, "y" => 2})
+          expect(d.x).to eq(1)
+          expect(d.y).to eq(2)
+        end
+      end
+
+=begin
+      context "when contructing an object with a has_many that contains embedded has_many objects" do
+        it "should create the first object and the has_many objects" do
+          b = B.new_from_json({x: 1, y: 2, cs: [{s: 3, t: 4}]})
+          expect(b.x).to eq(1)
+          expect(b.y).to eq(2)
+          expect(b.c.size).to eq(1)
+          #expect(b.c.first.s).to eq(3)
+          #expect(b.c.first.t).to eq(4)
+        end
+      end
+=end
+    end
+  end
+
+  context "when using an active record model with no associations" do
+    it "should be true" do
+      expect(nil).to eq(nil)
+    end
+  end
+
+  context "when using an active record model with no associations" do
+
+    context "when starting with a new model" do
+      let(:a) { A.new(x:1) }
+
+      context "when testing for equality" do
+        let(:a1) { A.new(x:1, y:1) }
+        let(:a2) { A.new(x:1, y:1) }
+
+        it "is equal if the objects are the same object" do
+          expect(a1 == a1).to eq(true)
+        end
+
+        it "is not equal if the objects are different objects" do
+          expect(a1 == a2).to eq(false)
+        end
+      end
+
+      it "can create one" do
+        expect(a.x).to eq(1)
+      end
+
+      it "has no id" do
+        expect(a.id).to be_nil
+      end
+
+      it "has an id after save" do
+        a.save
+        expect(a.id).to_not be_nil
+      end
+
+      if !running_with_real_active_record
+        it "is in the store after the save" do
+          a.save
+          expect(memory_store.tables["as"].size).to eq(1)
+        end
+      end
+
+    end
+
+    context "when searching for objects" do
+      let(:a1) { A.new(x:1, y:1) }
+      let(:a2) { A.new(x:1, y:2) }
+      let(:a3) { A.new(x:2, y:2) }
+
+      before do
+        a1.save
+        a2.save
+        a3.save
+      end
+
+      context "when testing for equality" do
+        it "is equal if the objects have the same id" do
+          expect(a1 == A.first).to eq(true)
+        end
+
+        it "is not equal if the objects are different objects" do
+          expect(a2 == A.first).to eq(false)
+        end
+      end
+
+      it "finds the first object saved when using first" do
+        expect(A.first.x).to eq(1)
+      end
+
+      it "finds the last object saved when using last" do
+        expect(A.last.x).to eq(2)
+      end
+
+      it "returns all records when using load" do
+        expect(A.all.map{|a| a.x}.sort).to eq([1,1,2])
+      end
+
+      it "returns the record with 1 when using where" do
+        expect(A.where(x:1,y:1).load.map{|a| [a.x,a.y]}).to eq([[1,1]])
+      end
+
+      it "returns the record with x:1 and y:3 when using where" do
+        expect(A.where(x:1).load.map{|a| a.y}).to eq([1,2])
+      end
+    end
+  end
+
+  context "when using an active record models with has_many/belongs_to associations" do
+    let(:b) { B.new(x:1) }
+    let(:c) { C.new(y:1) }
+    let(:d) { D.new(x:1, y:1) }
+
+    context "when the objects are not yet saved" do
+
+      it "has a B object with [] for the C association" do
+        expect(b.cs).to eq([])
+      end
+
+      it "has a C object with nil for the B association" do
+        expect(c.b).to be_nil
+      end
+
+      it "allows setting of C object on B" do
+        b.cs = [c]
+        expect(b.cs).to eq([c])
+      end
+
+      it "allows setting of B object on C" do
+        c.b = b
+        expect(c.b).to eq(b)
+      end
+
+      it "saves b when saving c" do
+        c.b = b
+        c.save
+        expect(b.id).to_not be_nil
+      end
+
+      it "saves b and c when saving d" do
+        c.b = b
+        d.c = c
+        d.save
+        expect(c.id).to_not be_nil
+        expect(b.id).to_not be_nil
+      end
+    end
+
+    context "when the has many side is saved only" do
+      before do
+        b.save
+      end
+
+      context "when setting cs" do
+        it "allows setting of C object on B" do
+          b.cs = [c]
+          expect(b.cs.load).to eq([c])
+        end
+
+        it "saves C object when associating it with B" do
+          b.cs = [c]
+          expect(c.id).to_not be_nil
+        end
+      end
+
+      context "when appending to cs" do
+        it "allows setting of C object on B" do
+          b.cs << c
+          expect(b.cs.load).to eq([c])
+        end
+
+        it "saves C object when associating it with B" do
+          b.cs  << c
+          expect(c.id).to_not be_nil
+        end
+      end
+    end
+
+    context "when the belongs_to side is saved only" do
+      before do
+        c.save
+      end
+
+      context "when setting b" do
+
+        it "doesn't save b on assignment to c" do
+          c.b = b
+          expect(b.id).to be_nil
+        end
+
+        it "saves b when saving c" do
+          c.b = b
+          c.save
+          expect(b.id).to_not be_nil
+        end
+      end
+    end
+
+    context "when objects are saved" do
+      before do
+        b.save
+        c.save
+      end
+
+      it "has a B object with [] for the C association" do
+        expect(b.cs.load).to eq([])
+      end
+
+      it "has a C object with nil for the B association" do
+        expect(c.b).to be_nil
+      end
+
+      it "allows setting of C object on B" do
+        b.cs = [c]
+        expect(b.cs.load).to eq([c])
+      end
+
+      it "allows setting of B object on C" do
+        c.b = b
+        c.save
+        expect(c.b).to eq(b)
+      end
+    end
+  end
+end
+ 

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+
+if ENV['run_with_real_active_record']
+  Bundler.require(:test)
+  require "active_record"
+else
+  if RUBY_ENGINE == "opal"
+    require 'opal-rspec'
+    require 'opal-activerecord'
+  else
+    require_relative '../opal/active_record/core'
+  end
+end
+
+
+module TestUnitHelpers
+  def assert_equal actual, expected
+    actual.should == expected
+  end
+end
+
+RSpec.configure do |config|
+  config.include TestUnitHelpers
+end
+
+def running_with_real_active_record
+  ENV['run_with_real_active_record']
+end
+

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: opal-activerecord
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Steve Tuckner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: opal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: opal-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "\n                        This implements a subset of the rails/activerecord.\n
+  \                       It currently handles has_many and belongs_to\n                        associations,
+  saving, finding and simple where\n                        queries. \n                      "
+email:
+- stevetuckner@stewdle.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/opal-activerecord.rb
+- lib/opal/activerecord.rb
+- lib/opal/activerecord/version.rb
+- opal-activerecord.gemspec
+- opal/active_record.rb
+- opal/active_record/core.rb
+- opal/opal-activerecord.rb
+- spec/activerecord_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/boberetezeke/opal-activerecord
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --main
+- README
+- --line-numbers
+- --include
+- opal
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: A small port of the glorious ActiveRecord for Opal
+test_files:
+- spec/activerecord_spec.rb
+- spec/spec_helper.rb