reactive-record 0.7.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c14856b73501aab70804ad8351301b87b948fd75
+  data.tar.gz: b0aef64c154ca72e6af956a1966e0e77235bafec
+SHA512:
+  metadata.gz: bcc0cdea12ce7c93e27b6179ed6c2842207cf7e046bef8da8eb46643a2adf6964fad1e6d4d0f3c75853bf661de19142f28c987352b4f16abe03fbacdab8464a2
+  data.tar.gz: f861152c0a4ca7fda801ccf5ee5b8603a7c50a40c8d19506d9c90c71d68c732b99e092da468aa951577341b9f2056c0a89c85d102fdfd192824b814ec92fc6ad

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 YOURNAME
+
+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.rdoc

@@ -0,0 +1,3 @@
+= ReactiveRecord
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,29 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+Bundler::GemHelper.install_tasks
+Dir[File.join(File.dirname(__FILE__), 'tasks/**/*.rake')].each {|f| load f }
+require 'rspec/core'
+require 'rspec/core/rake_task'
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new(:spec => 'app:db:test:prepare') 
+
+require 'opal/rspec/rake_task'
+require 'bundler'
+Bundler.require
+
+# Add our opal/ directory to the load path
+#Opal.append_path File.expand_path('../lib', __FILE__)
+
+Opal::RSpec::RakeTask.new(:spec_opal) do |s|
+  s.sprockets.paths.tap { s.sprockets.clear_paths }[0..-2].each { |path| s.sprockets.append_path path}
+  s.main = 'sprockets_runner'
+  s.append_path 'spec-opal'
+end
+
+task :default => [:spec, :spec_opal]

data/app/controllers/reactive_record/application_controller.rb

@@ -0,0 +1,4 @@
+module ReactiveRecord
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/controllers/reactive_record/reactive_record_controller.rb

@@ -0,0 +1,22 @@
+require 'reactive_record/server_data_cache'
+
+module ReactiveRecord
+
+  class ReactiveRecordController < ApplicationController
+    
+    def fetch
+      render :json => ReactiveRecord::ServerDataCache[params[:pending_fetches]]
+    end
+        
+
+    def save
+      render :json => ReactiveRecord::Base.save_records(params[:models], params[:associations])
+    end
+      
+    def destroy
+      render :json => ReactiveRecord::Base.destroy_record(params[:model], params[:id], params[:vector])
+    end
+
+  end
+
+end

data/config/routes.rb

@@ -0,0 +1,5 @@
+ReactiveRecord::Engine.routes.draw do
+  root :to => "reactive_record#fetch", via: :post
+  match 'save', to: 'reactive_record#save', via: :post
+  match 'destroy', to: 'reactive_record#destroy', via: :post
+end

data/lib/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+
+# Declare your gem's dependencies in reactive_record.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# jquery-rails is used by the dummy application
+gem "jquery-rails"
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use debugger
+# gem 'debugger'

data/lib/reactive-record.rb

@@ -0,0 +1,28 @@
+if RUBY_ENGINE == 'opal'
+  
+  require "opal-react"
+  require "reactive_record/server_data_cache"
+  require "reactive_record/active_record/reactive_record/while_loading"
+  require "reactive_record/active_record/reactive_record/isomorphic_base"
+  require "reactive_record/active_record/aggregations"
+  require "reactive_record/active_record/associations"
+  require "reactive_record/active_record/reactive_record/base"
+  require "reactive_record/active_record/reactive_record/collection"
+  require "reactive_record/active_record/class_methods"
+  require "reactive_record/active_record/instance_methods"
+  require "reactive_record/active_record/base"
+  require "reactive_record/interval"
+  
+else
+  
+  require "opal"
+  require "reactive_record/version"
+  require "reactive_record/engine"
+  require "reactive_record/server_data_cache"
+  require "reactive_record/active_record/reactive_record/isomorphic_base"
+  require "reactive_record/serializers"
+
+  Opal.append_path File.expand_path('../', __FILE__).untaint
+  Opal.append_path File.expand_path('../../vendor', __FILE__).untaint
+  
+end

data/lib/reactive_record/active_record/aggregations.rb

@@ -0,0 +1,38 @@
+module ActiveRecord
+  
+  class Base
+    
+    def self.reflect_on_all_aggregations
+      base_class.instance_eval { @aggregations ||= [] }
+    end
+    
+    def self.reflect_on_aggregation(attribute)
+      reflect_on_all_aggregations.detect { |aggregation| aggregation.attribute == attribute }
+    end
+    
+  end
+  
+  module Aggregations
+    
+    class AggregationReflection
+      
+      attr_reader :klass_name
+      attr_reader :attribute
+      
+      def initialize(owner_class, macro, name, options = {})
+        owner_class.reflect_on_all_aggregations << self
+        @owner_class = owner_class
+        @klass_name =  options[:class_name] || name.camelize
+        @attribute =   name
+      end
+      
+      def klass
+        @klass ||= Object.const_get(@klass_name)
+      end
+      
+    end
+    
+  end
+  
+  
+end

data/lib/reactive_record/active_record/associations.rb

@@ -0,0 +1,54 @@
+module ActiveRecord
+  
+  class Base
+    
+    def self.reflect_on_all_associations
+      base_class.instance_eval { @associations ||= superclass.instance_eval { (@associations && @associations.dup) || [] } }
+    end
+    
+    def self.reflect_on_association(attribute)
+      reflect_on_all_associations.detect { |association| association.attribute == attribute }
+    end
+  
+  end
+  
+  module Associations
+    
+    class AssociationReflection
+      
+      attr_reader :association_foreign_key
+      attr_reader :attribute
+      attr_reader :macro
+            
+      def initialize(owner_class, macro, name, options = {})
+        owner_class.reflect_on_all_associations << self
+        @owner_class = owner_class
+        @macro =       macro
+        @klass_name =  options[:class_name] || (collection? && name.camelize.gsub(/s$/,"")) || name.camelize
+        @association_foreign_key = options[:foreign_key] || (macro == :belongs_to && "#{name}_id") || "#{@owner_class.name.underscore}_id"
+        @attribute =   name
+      end
+      
+      def inverse_of
+        unless @inverse_of
+          inverse_association = klass.reflect_on_all_associations.detect { | association | association.association_foreign_key == @association_foreign_key }
+          raise "Association #{@owner_class}.#{attribute} (foreign_key: #{@association_foreign_key}) has no inverse in #{@klass_name}" unless inverse_association
+          @inverse_of = inverse_association.attribute
+        end
+        @inverse_of
+      end
+      
+      def klass
+        @klass ||= Object.const_get(@klass_name)
+      end
+      
+      def collection?
+        [:has_many].include? @macro
+      end
+      
+    end
+    
+  end
+  
+  
+end

data/lib/reactive_record/active_record/base.rb

@@ -0,0 +1,9 @@
+module ActiveRecord
+  class Base
+    
+    extend  ClassMethods
+     
+    include InstanceMethods
+    
+  end
+end

data/lib/reactive_record/active_record/class_methods.rb

@@ -0,0 +1,113 @@
+module ActiveRecord
+  
+  module ClassMethods
+    
+    def base_class
+
+      unless self < Base
+        raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord"
+      end
+
+      if superclass == Base || superclass.abstract_class?
+        self
+      else
+        superclass.base_class
+      end
+
+    end
+
+    def abstract_class?
+      defined?(@abstract_class) && @abstract_class == true
+    end
+
+    def primary_key
+      base_class.instance_eval { @primary_key_value || :id }
+    end
+
+    def primary_key=(val)
+     base_class.instance_eval {  @primary_key_value = val }
+    end
+    
+    def inheritance_column
+      base_class.instance_eval {@inheritance_column_value || "type"}
+    end
+
+    def inheritance_column=(name)
+      base_class.instance_eval {@inheritance_column_value = name}
+    end
+
+    def model_name
+      # in reality should return ActiveModel::Name object, blah blah
+      name
+    end
+
+    def find(id)
+      base_class.instance_eval {ReactiveRecord::Base.find(self, primary_key, id)}
+    end
+    
+    def find_by(opts = {})
+      base_class.instance_eval {ReactiveRecord::Base.find(self, opts.first.first, opts.first.last)}
+    end
+    
+    def method_missing(name, *args, &block)
+      if args.count == 1 && name =~ /^find_by_/ && !block
+        find_by(name.gsub(/^find_by_/, "") => args[0])
+      else
+        raise "#{self.name}.#{name}(#{args}) (called class method missing)"
+      end
+    end
+    
+    def abstract_class=(val)
+      @abstract_class = val
+    end
+    
+    def scope(name, body)
+      singleton_class.send(:define_method, name) { ReactiveRecord::Collection.new(self, nil, nil, self, name) }
+    end
+    
+    def all
+      ReactiveRecord::Collection.new(self)
+    end
+        
+    [:belongs_to, :has_many, :has_one].each do |macro| 
+      define_method(macro) do |name, opts = {}| 
+        Associations::AssociationReflection.new(base_class, macro, name, opts)
+      end
+    end
+    
+    def composed_of(name, opts = {})
+      Aggregations::AggregationReflection.new(base_class, :composed_of, name, opts)
+    end
+
+    [
+      "table_name=", "before_validation", "with_options", "validates_presence_of", "validates_format_of", 
+      "accepts_nested_attributes_for", "after_create", "before_save", "before_destroy", "where", "validate", 
+      "attr_protected", "validates_numericality_of", "default_scope", "has_attached_file", "attr_accessible",
+      "serialize"
+    ].each do |method|
+      define_method(method.to_s) { |*args, &block| }
+    end
+    
+    def _react_param_conversion(param, opt = nil)
+      # defines how react will convert incoming json to this ActiveRecord model
+      param_is_native = !param.respond_to?(:is_a?) rescue true
+      param = JSON.from_object param if param_is_native
+      if param.is_a? self
+        param
+      elsif param.is_a? Hash
+        if opt == :validate_only
+          ReactiveRecord::Base.infer_type_from_hash(self, param) == self
+        else
+          target = find(param[primary_key])
+          param.each { |key, value| param[key] = [value] }
+          ReactiveRecord::Base.load_from_json(param, target)
+          target
+        end
+      else
+        nil
+      end
+    end
+    
+  end
+  
+end

data/lib/reactive_record/active_record/instance_methods.rb

@@ -0,0 +1,76 @@
+module ActiveRecord
+  
+  module InstanceMethods
+        
+    def attributes
+      @backing_record.attributes
+    end
+    
+    def initialize(hash = {})
+      if hash.is_a? ReactiveRecord::Base
+        @backing_record = hash
+      else
+        # standard active_record new -> creates a new instance, primary key is ignored if present
+        hash[primary_key] = nil
+        @backing_record = ReactiveRecord::Base.new(self.class, hash, self)
+      end
+    end
+    
+    def primary_key
+      self.class.primary_key
+    end
+    
+    def id
+      @backing_record.reactive_get!(primary_key)
+    end
+    
+    def id=(value)
+      @backing_record.id = value
+    end
+
+    def model_name
+      # in reality should return ActiveModel::Name object, blah blah
+      self.class.model_name
+    end
+    
+    def revert
+      @backing_record.revert
+    end
+    
+    def changed?
+      @backing_record.changed?
+    end
+    
+    def ==(ar_instance)
+      @backing_record == ar_instance.instance_eval { @backing_record }
+    end
+    
+    def method_missing(name, *args, &block)
+      if name =~ /_changed\?$/
+        @backing_record.changed?(name.gsub(/_changed\?$/,""))
+      elsif args.count == 1 && name =~ /=$/ && !block
+        attribute_name = name.gsub(/=$/,"")
+        @backing_record.reactive_set!(attribute_name, args[0])
+      elsif args.count == 0 && !block
+        @backing_record.reactive_get!(name) 
+      else
+        super
+      end
+    end
+    
+    def save(&block) 
+      @backing_record.save &block
+    end
+    
+    def saving?
+      @backing_record.saving?
+    end
+    
+    def destroy(&block)
+      @backing_record.destroy &block
+    end
+    
+  end
+  
+end
+