hyper-mesh 0.4.0

data/lib/reactive_record/active_record/associations.rb

@@ -0,0 +1,111 @@
+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)
+      if found = reflect_on_all_associations.detect { |association| association.attribute == attribute and association.owner_class == self }
+        found
+      elsif superclass == Base
+        nil
+      else
+        superclass.reflect_on_association(attribute)
+      end
+    end
+
+  end
+
+  module Associations
+
+    class AssociationReflection
+
+      attr_reader :association_foreign_key
+      attr_reader :attribute
+      attr_reader :macro
+      attr_reader :owner_class
+      attr_reader :source
+
+      def initialize(owner_class, macro, name, options = {})
+        owner_class.reflect_on_all_associations << self
+        @owner_class = owner_class
+        @macro =       macro
+        @options =     options
+        @klass_name =  options[:class_name] || (collection? && name.camelize.gsub(/s$/, '')) || name.camelize
+        if @klass_name < ActiveRecord::Base
+          @klass = @klass_name
+          @klass_name = @klass_name.name
+        end rescue nil
+        @association_foreign_key = options[:foreign_key] || (macro == :belongs_to && "#{name}_id") || "#{@owner_class.name.underscore}_id"
+        @source = options[:source] || @klass_name.underscore if options[:through]
+        @attribute = name
+      end
+
+      def through_association
+        return unless @options[:through]
+        @through_association ||= @owner_class.reflect_on_all_associations.detect do |association|
+          association.attribute == @options[:through]
+        end
+        raise "Through association #{@options[:through]} for "\
+              "#{@owner_class}.#{attribute} not found." unless @through_association
+        @through_association
+      end
+
+      alias through_association? through_association
+
+      def through_associations
+        # find all associations that use the inverse association as the through association
+        # that is find all associations that are using this association in a through relationship
+        @through_associations ||= klass.reflect_on_all_associations.select do |assoc|
+          assoc.through_association && assoc.inverse == self
+        end
+      end
+
+      def source_associations
+        # find all associations that use this association as the source
+        # that is final all associations that are using this association as the source in a
+        # through relationship
+        @source_associations ||= owner_class.reflect_on_all_associations.collect do |sibling|
+          sibling.klass.reflect_on_all_associations.select do |assoc|
+            assoc.source == attribute
+          end
+        end.flatten
+      end
+
+      def inverse
+        @inverse ||=
+          through_association ? through_association.inverse : find_inverse
+      end
+
+      def inverse_of
+        @inverse_of ||= inverse.attribute
+      end
+
+      def find_inverse
+        klass.reflect_on_all_associations.each do |association|
+          next if association.association_foreign_key != @association_foreign_key
+          next if association.klass != @owner_class
+          next if association.attribute == attribute
+          return association if klass == association.owner_class
+        end
+        raise "Association #{@owner_class}.#{attribute} "\
+              "(foreign_key: #{@association_foreign_key}) "\
+              "has no inverse in #{@klass_name}"
+      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,177 @@
+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 enum(*args)
+      # when we implement schema validation we should also implement value checking
+    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) do | *args |
+        args = (args.count == 0) ? name : [name, *args]
+        ReactiveRecord::Base.class_scopes(self)[args] ||= ReactiveRecord::Collection.new(self, nil, nil, self, args)
+      end
+      singleton_class.send(:define_method, "#{name}=") do |collection|
+        ReactiveRecord::Base.class_scopes(self)[name] = collection
+      end
+    end
+
+    def all
+      ReactiveRecord::Base.class_scopes(self)[:all] ||= ReactiveRecord::Collection.new(self, nil, nil, self, "all")
+    end
+
+    def all=(collection)
+      ReactiveRecord::Base.class_scopes(self)[:all] = collection
+    end
+
+    # def server_methods(*methods)
+    #   methods.each do |method|
+    #     define_method(method) do |*args|
+    #       if args.count == 0
+    #         @backing_record.reactive_get!(method, :initialize)
+    #       else
+    #         @backing_record.reactive_get!([[method]+args], :initialize)
+    #       end
+    #     end
+    #     define_method("#{method}!") do |*args|
+    #       if args.count == 0
+    #         @backing_record.reactive_get!(method, :force)
+    #       else
+    #         @backing_record.reactive_get!([[method]+args], :force)
+    #       end
+    #     end
+    #   end
+    # end
+    #
+    # alias_method :server_method, :server_methods
+
+    [:belongs_to, :has_many, :has_one].each do |macro|
+      define_method(macro) do |*args| # is this a bug in opal?  saying name, scope=nil, opts={} does not work!
+        name = args.first
+        opts = (args.count > 1 and args.last.is_a? Hash) ? args.last : {}
+        Associations::AssociationReflection.new(self, macro, name, opts)
+      end
+    end
+
+    def composed_of(name, opts = {})
+      Aggregations::AggregationReflection.new(base_class, :composed_of, name, opts)
+    end
+
+    def column_names
+      []  # it would be great to figure out how to get this information on the client!  For now we just return an empty array
+    end
+
+    def columns_hash
+      HyperMesh::ClientDrivers.public_columns_hash[name] || {}
+    end
+
+    [
+      "table_name=", "before_validation", "with_options", "validates_presence_of", "validates_format_of",
+      "accepts_nested_attributes_for", "before_create", "after_create", "before_save", "after_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)
+      param = Native(param)
+      param = JSON.from_object(param.to_n) if param.is_a? Native::Object
+      result = if param.is_a? self
+        param
+      elsif param.is_a? Hash
+        if opt == :validate_only
+          klass = ReactiveRecord::Base.infer_type_from_hash(self, param)
+          klass == self or klass < self
+        else
+          if param[primary_key]
+            target = find(param[primary_key])
+          else
+            target = new
+          end
+          associations = reflect_on_all_associations
+          param = param.collect do |key, value|
+            assoc = reflect_on_all_associations.detect do |assoc|
+              assoc.association_foreign_key == key
+            end
+            if assoc
+              if value
+                [assoc.attribute, {id: [value], type: [nil]}]
+              else
+                [assoc.attribute, [nil]]
+              end
+            else
+              [key, [value]]
+            end
+          end
+          ReactiveRecord::ServerDataCache.load_from_json(Hash[param], target)
+          target
+        end
+      else
+        nil
+      end
+      result
+    end
+
+  end
+
+end

data/lib/reactive_record/active_record/error.rb

@@ -0,0 +1,26 @@
+module ActiveModel
+  
+  class Error
+    
+    attr_reader :messages
+    
+    def initialize(msgs = {})
+      @messages = msgs || {}
+      @messages.each { |attribute, messages| @messages[attribute] = messages.uniq }
+    end
+    
+    def [](attribute)
+      messages[attribute]
+    end
+    
+    def delete(attribute)
+      messages.delete(attribute)
+    end
+    
+    def empty?
+      messages.empty?
+    end
+    
+  end
+  
+end

data/lib/reactive_record/active_record/instance_methods.rb

@@ -0,0 +1,129 @@
+module ActiveRecord
+
+  module InstanceMethods
+
+    attr_reader :backing_record
+
+    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
+        # we have to build the backing record first then initialize it so associations work correctly
+        @backing_record = ReactiveRecord::Base.new(self.class, {}, self)
+        @backing_record.instance_eval do
+          self.class.load_data do
+            hash.each do |attribute, value|
+              unless attribute == primary_key
+                reactive_set!(attribute, convert(attribute, value))
+                changed_attributes << attribute
+              end
+            end
+            #changed_attributes << primary_key # insures that changed attributes has at least one element
+          end
+        end
+      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 dup
+      self.class.new(self.attributes)
+    end
+
+    def ==(ar_instance)
+      @backing_record == ar_instance.instance_eval { @backing_record }
+    end
+
+    def method_missing(name, *args, &block)
+      if name =~ /\!$/
+        name = name.gsub(/\!$/,"")
+        force_update = true
+      end
+      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, backing_record.convert(attribute_name, args[0]))
+      elsif args.count.zero? && !block
+        @backing_record.reactive_get!(name, force_update)
+      elsif !block
+        @backing_record.reactive_get!([[name]+args], force_update)
+      else
+        super
+      end
+    end
+
+    def itself
+      # this is useful when you just want to get a handle on record instance
+      # in the ReactiveRecord.load method
+      id # force load of id...
+      self
+    end
+
+    def load(*attributes, &block)
+      first_time = true
+      ReactiveRecord.load do
+        results = attributes.collect { |attr| @backing_record.reactive_get!(attr, first_time) }
+        results = yield *results if block
+        first_time = false
+        block.nil? && results.count == 1 ? results.first : results
+      end
+    end
+
+    def save(opts = {}, &block)
+      @backing_record.save(opts.has_key?(:validate) ? opts[:validate] : true, opts[:force], &block)
+    end
+
+    def saving?
+      @backing_record.saving?
+    end
+
+    def destroy(&block)
+      @backing_record.destroy &block
+    end
+
+    def destroyed?
+      @backing_record.destroyed
+    end
+
+    def new?
+      @backing_record.new?
+    end
+
+    def errors
+      React::State.get_state(@backing_record, @backing_record)
+      @backing_record.errors
+    end
+
+  end
+
+end