hyper-model 0.6.0 → 0.99.0

data/lib/reactive_record/active_record_error.rb

@@ -0,0 +1,4 @@
+module ActiveRecord
+  class ActiveRecordError < StandardError
+  end
+end

data/lib/reactive_record/broadcast.rb

@@ -0,0 +1,223 @@
+module ReactiveRecord
+  class Broadcast
+
+    def self.after_commit(operation, model)
+      Hyperloop::InternalPolicy.regulate_broadcast(model) do |data|
+        if !Hyperloop.on_server? && Hyperloop::Connection.root_path
+          send_to_server(operation, data) rescue nil # server no longer running so ignore
+        else
+          SendPacket.run(data, operation: operation)
+        end
+      end
+    rescue ActiveRecord::StatementInvalid => e
+      raise e unless e.message == "Could not find table 'hyperloop_connections'"
+    end unless RUBY_ENGINE == 'opal'
+
+    def self.send_to_server(operation, data)
+      salt = SecureRandom.hex
+      authorization = Hyperloop.authorization(salt, data[:channel], data[:broadcast_id])
+      raise 'no server running' unless Hyperloop::Connection.root_path
+      SendPacket.remote(
+        Hyperloop::Connection.root_path,
+        data,
+        operation: operation,
+        salt: salt,
+        authorization: authorization
+      ).tap { |p| raise p.error if p.rejected? }
+    end unless RUBY_ENGINE == 'opal'
+
+    class SendPacket < Hyperloop::ServerOp
+      param authorization: nil, nils: true
+      param salt: nil
+      param :operation
+      param :broadcast_id
+      param :channel
+      param :channels
+      param :klass
+      param :record
+      param :operation
+      param :previous_changes
+
+      unless RUBY_ENGINE == 'opal'
+        validate do
+          params.authorization.nil? ||
+          Hyperloop.authorization(
+            params.salt, params.channel, params.broadcast_id
+          ) == params.authorization
+        end
+        dispatch_to do
+          # No need to broadcast if the changes are filtered out by a policy
+          params.channel unless params.operation == :change && params.previous_changes.empty?
+        end
+      end
+    end
+
+    SendPacket.on_dispatch do |params|
+      in_transit[params.broadcast_id].receive(params) do |broadcast|
+        if params.operation == :destroy
+          ReactiveRecord::Collection.sync_scopes broadcast
+        else
+          ReactiveRecord::Collection.sync_scopes broadcast.process_previous_changes
+        end
+      end
+    end
+
+    def self.to_self(record, data = {})
+      # simulate incoming packet after a local save
+      operation = if record.new?
+                    :create
+                  elsif record.destroyed?
+                    :destroy
+                  else
+                    :change
+                  end
+      dummy_broadcast = new.local(operation, record, data)
+      record.backing_record.sync! data unless operation == :destroy
+      ReactiveRecord::Collection.sync_scopes dummy_broadcast
+    end
+
+    def record_with_current_values
+      ReactiveRecord::Base.load_data do
+        backing_record = @backing_record || klass.find(record[:id]).backing_record
+        if destroyed?
+          backing_record.ar_instance
+        else
+          merge_current_values(backing_record)
+        end
+      end
+    end
+
+    def record_with_new_values
+      klass._react_param_conversion(record).tap do |ar_instance|
+        if destroyed?
+          ar_instance.backing_record.destroy_associations
+        elsif new?
+          ar_instance.backing_record.initialize_collections
+        end
+      end
+    end
+
+    def new?
+      @is_new
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def klass
+      Object.const_get(@klass)
+    end
+
+    def to_s
+      "klass: #{klass} record: #{record} new?: #{new?} destroyed?: #{destroyed?}"
+    end
+
+    # private
+
+    attr_reader :record
+
+    def self.open_channels
+      @open_channels ||= Set.new
+    end
+
+    def self.in_transit
+      @in_transit ||= Hash.new { |h, k| h[k] = new(k) }
+    end
+
+    def initialize(id)
+      @id = id
+      @received = Set.new
+      @record = {}
+      @previous_changes = {}
+    end
+
+    def local(operation, record, data)
+      @destroyed = operation == :destroy
+      @is_new = operation == :create
+      @klass = record.class.name
+      @record = data
+      record.backing_record.destroyed = false
+      @record[:id] = record.id if record.id
+      record.backing_record.destroyed = @destroyed
+      @backing_record = record.backing_record
+      @previous_changes = record.changes
+      # attributes = record.attributes
+      # data.each do |k, v|
+      #   next if klass.reflect_on_association(k) || attributes[k] == v
+      #   @previous_changes[k] = [attributes[k], v]
+      # end
+      self
+    end
+
+    def receive(params)
+      @destroyed = params.operation == :destroy
+      @channels ||= Hyperloop::IncomingBroadcast.open_channels.intersection params.channels
+      @received << params.channel
+      @klass ||= params.klass
+      @record.merge! params.record
+      @previous_changes.merge! params.previous_changes
+      ReactiveRecord::Base.when_not_saving(klass) do
+        @backing_record = ReactiveRecord::Base.exists?(klass, params.record[:id])
+        @is_new = params.operation == :create && !@backing_record
+        yield complete! if @channels == @received
+      end
+    end
+
+    def complete!
+      self.class.in_transit.delete @id
+    end
+
+    def value_changed?(attr, value)
+      attrs = @backing_record.synced_attributes
+      return true if attr == @backing_record.primary_key
+      return attrs[attr] != @backing_record.convert(attr, value) if attrs.key?(attr)
+
+      assoc = klass.reflect_on_association_by_foreign_key attr
+
+      return value unless assoc
+      child = attrs[assoc.attribute]
+      return value != child.id if child
+      value
+    end
+
+    def integrity_check
+      @previous_changes.each do |attr, value|
+        next if @record.key?(attr) && @record[attr] == value.last
+        React::IsomorphicHelpers.log "Broadcast contained change to #{attr} -> #{value.last} "\
+                                     "without corresponding value in attributes (#{@record}).\n",
+                                     :error
+        raise "Broadcast Integrity Error"
+      end
+    end
+
+    def process_previous_changes
+      return self unless @backing_record
+      integrity_check
+      return self if destroyed?
+      @record.dup.each do |attr, value|
+        next if value_changed?(attr, value)
+        @record.delete(attr)
+        @previous_changes.delete(attr)
+      end
+      self
+    end
+
+    def merge_current_values(br)
+      current_values = Hash[*@previous_changes.collect do |attr, values|
+        value = attr == :id ? record[:id] : values.first
+        if br.attributes.key?(attr) &&
+           br.attributes[attr] != br.convert(attr, value) &&
+           br.attributes[attr] != br.convert(attr, values.last)
+          React::IsomorphicHelpers.log "warning #{attr} has changed locally - will force a reload.\n"\
+               "local value: #{br.attributes[attr]} remote value: #{br.convert(attr, value)}->#{br.convert(attr, values.last)}",
+               :warning
+          return nil
+        end
+        [attr, value]
+      end.compact.flatten(1)]
+      # TODO: verify - it used to be current_values.merge(br.attributes)
+      klass._react_param_conversion(br.attributes.merge(current_values))
+    end
+  end
+end

data/lib/reactive_record/engine.rb

@@ -0,0 +1,11 @@
+module HyperMesh
+  class Engine < ::Rails::Engine
+    isolate_namespace ReactiveRecord
+    config.generators do |g|
+      g.test_framework      :rspec,        :fixture => false
+      g.fixture_replacement :factory_bot, :dir => 'spec/factories'
+      g.assets false
+      g.helper false
+    end
+  end
+end

data/lib/reactive_record/interval.rb

@@ -0,0 +1,190 @@
+module Browser
+
+# Allows you to create an interval that executes the function every given
+# seconds.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/Window.setInterval
+class Interval
+  # @!attribute [r] every
+  # @return [Float] the seconds every which the block is called
+  attr_reader :every
+
+  # Create and start an interval.
+  #
+  # @param window [Window] the window to start the interval on
+  # @param time [Float] seconds every which to call the block
+  def initialize(window, time, &block)
+    @window = Native.convert(window)
+    @every  = time
+    @block  = block
+
+    @aborted = false
+  end
+
+  # Check if the interval has been stopped.
+  def stopped?
+    @id.nil?
+  end
+
+  # Check if the interval has been aborted.
+  def aborted?
+    @aborted
+  end
+
+  # Abort the interval, it won't be possible to start it again.
+  def abort
+    `#@window.clearInterval(#@id)`
+
+    @aborted = true
+    @id      = nil
+  end
+
+  # Stop the interval, it will be possible to start it again.
+  def stop
+    return if stopped?
+
+    `#@window.clearInterval(#@id)`
+
+    @stopped = true
+    @id      = nil
+  end
+
+  # Start the interval if it has been stopped.
+  def start
+    raise "the interval has been aborted" if aborted?
+    return unless stopped?
+
+    @id = `#@window.setInterval(#@block, #@every * 1000)`
+  end
+
+  # Call the [Interval] block.
+  def call
+    @block.call
+  end
+end
+
+class Window
+  # Execute the block every given seconds.
+  #
+  # @param time [Float] the seconds between every call
+  #
+  # @return [Interval] the object representing the interval
+  def every(time, &block)
+    Interval.new(@native, time, &block).tap(&:start)
+  end
+
+  # Execute the block every given seconds, you have to call [#start] on it
+  # yourself.
+  #
+  # @param time [Float] the seconds between every call
+  #
+  # @return [Interval] the object representing the interval
+  def every!(time, &block)
+    Interval.new(@native, time, &block)
+  end
+end
+
+end
+
+module Kernel
+  # (see Browser::Window#every)
+  def every(time, &block)
+    $window.every(time, &block)
+  end
+
+  # (see Browser::Window#every!)
+  def every!(time, &block)
+    $window.every!(time, &block)
+  end
+end
+
+class Proc
+  # (see Browser::Window#every)
+  def every(time)
+    $window.every(time, &self)
+  end
+
+  # (see Browser::Window#every!)
+  def every!(time)
+    $window.every!(time, &self)
+  end
+end
+
+module Browser
+
+# Allows you to delay the call to a function which gets called after the
+# given time.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/Window.setTimeout
+class Delay
+  # @!attribute [r] after
+  # @return [Float] the seconds after which the block is called
+  attr_reader :after
+
+  # Create and start a timeout.
+  #
+  # @param window [Window] the window to start the timeout on
+  # @param time [Float] seconds after which the block is called
+  def initialize(window, time, &block)
+    @window = Native.convert(window)
+    @after  = time
+    @block  = block
+  end
+
+  # Abort the timeout.
+  def abort
+    `#@window.clearTimeout(#@id)`
+  end
+
+  # Start the delay.
+  def start
+    @id = `#@window.setTimeout(#{@block.to_n}, #@after * 1000)`
+  end
+end
+
+class Window
+  # Execute a block after the given seconds.
+  #
+  # @param time [Float] the seconds after it gets called
+  #
+  # @return [Delay] the object representing the timeout
+  def after(time, &block)
+    Delay.new(@native, time, &block).tap(&:start)
+  end
+
+  # Execute a block after the given seconds, you have to call [#start] on it
+  # yourself.
+  #
+  # @param time [Float] the seconds after it gets called
+  #
+  # @return [Delay] the object representing the timeout
+  def after!(time, &block)
+    Delay.new(@native, time, &block)
+  end
+end
+
+end
+
+module Kernel
+  # (see Browser::Window#after)
+  def after(time, &block)
+    `setTimeout(#{block.to_n}, time * 1000)`
+  end
+
+  # (see Browser::Window#after!)
+  def after!(time, &block)
+    `setTimeout(#{block.to_n}, time * 1000)`
+  end
+end
+
+class Proc
+  # (see Browser::Window#after)
+  def after(time)
+    $window.after(time, &self)
+  end
+
+  # (see Browser::Window#after!)
+  def after!(time)
+    $window.after!(time, &self)
+  end
+end

data/lib/reactive_record/permissions.rb

@@ -0,0 +1,117 @@
+module Hyperloop
+  class InternalPolicy
+
+    def self.accessible_attributes_for(model, acting_user)
+      user_channels = ClassConnectionRegulation.connections_for(acting_user, false) +
+        InstanceConnectionRegulation.connections_for(acting_user, false)
+      internal_policy = InternalPolicy.new(model, model.attribute_names, user_channels)
+      ChannelBroadcastRegulation.broadcast(internal_policy)
+      InstanceBroadcastRegulation.broadcast(model, internal_policy)
+      internal_policy.accessible_attributes_for
+    end
+
+    def accessible_attributes_for
+      accessible_attributes = Set.new
+      @channel_sets.each do |channel, attribute_set|
+        accessible_attributes.merge attribute_set
+      end
+      accessible_attributes << :id unless accessible_attributes.empty?
+      accessible_attributes
+    end
+  end
+end
+
+class ActiveRecord::Base
+
+  attr_accessor :acting_user
+
+  def view_permitted?(attribute)
+    Hyperloop::InternalPolicy.accessible_attributes_for(self, acting_user).include? attribute.to_sym
+  end
+
+  def create_permitted?
+    false
+  end
+
+  def update_permitted?
+    false
+  end
+
+  def destroy_permitted?
+    false
+  end
+
+  def only_changed?(*attributes)
+    (self.attributes.keys + self.class.reactive_record_association_keys).each do |key|
+      return false if self.send("#{key}_changed?") and !attributes.include? key
+    end
+    true
+  end
+
+  def none_changed?(*attributes)
+    attributes.each do |key|
+      return false if self.send("#{key}_changed?")
+    end
+    true
+  end
+
+  def any_changed?(*attributes)
+    attributes.each do |key|
+      return true if self.send("#{key}_changed?")
+    end
+    false
+  end
+
+  def all_changed?(*attributes)
+    attributes.each do |key|
+      return false unless self.send("#{key}_changed?")
+    end
+    true
+  end
+
+  class << self
+
+    attr_reader :reactive_record_association_keys
+
+    [:has_many, :belongs_to, :composed_of].each do |macro|
+      define_method "#{macro}_with_reactive_record_add_changed_method".to_sym do |attr_name, *args, &block|
+        define_method "#{attr_name}_changed?".to_sym do
+          instance_variable_get "@reactive_record_#{attr_name}_changed".to_sym
+        end
+        (@reactive_record_association_keys ||= []) << attr_name
+        send "#{macro}_without_reactive_record_add_changed_method".to_sym, attr_name, *args, &block
+      end
+      alias_method "#{macro}_without_reactive_record_add_changed_method".to_sym, macro
+      alias_method macro, "#{macro}_with_reactive_record_add_changed_method".to_sym
+    end
+
+    alias belongs_to_without_reactive_record_add_is_method belongs_to
+
+    def belongs_to(attr_name, *args)
+      belongs_to_without_reactive_record_add_is_method(attr_name, *args).tap do
+        define_method "#{attr_name}_is?".to_sym do |model|
+          self.class.reflections[attr_name].foreign_key == model.id
+        end
+      end
+    end
+  end
+
+  def check_permission_with_acting_user(user, permission, *args)
+    old = acting_user
+    self.acting_user = user
+    if self.send(permission, *args)
+      self.acting_user = old
+      self
+    else
+      Hyperloop::InternalPolicy.raise_operation_access_violation(:crud_access_violation, "for #{self} - #{permission}(#{args}) acting_user: #{user}")
+    end
+  end
+
+end
+
+class ActionController::Base
+
+  def acting_user
+  end
+
+end