hyper-mesh 0.4.0

data/lib/reactive_record/engine.rb

@@ -0,0 +1,13 @@
+#require 'rails'
+
+module ReactiveRecord
+  class Engine < ::Rails::Engine
+    isolate_namespace ReactiveRecord
+    config.generators do |g|
+      g.test_framework      :rspec,        :fixture => false
+      g.fixture_replacement :factory_girl, :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,102 @@
+module ReactiveRecord
+  class AccessViolation < StandardError
+    def message
+      "ReactiveRecord::AccessViolation: #{super}"
+    end
+  end
+end
+
+class ActiveRecord::Base
+
+  attr_accessor :acting_user
+
+  def create_permitted?
+    true
+  end
+
+  def update_permitted?
+    true
+  end
+
+  def destroy_permitted?
+    true
+  end
+
+  def view_permitted?(attribute)
+    true
+  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, scope = nil, options = {})
+      define_method "#{attr_name}_is?".to_sym do |model|
+        send(options[:foreign_key] || "#{attr_name}_id") == model.id
+      end
+      belongs_to_without_reactive_record_add_is_method(attr_name, scope, options)
+    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
+      raise ReactiveRecord::AccessViolation, "for #{permission}(#{args})"
+    end
+  end
+
+end
+
+class ActionController::Base
+
+  def acting_user
+  end
+
+end

data/lib/reactive_record/pry.rb

@@ -0,0 +1,13 @@
+module ReactiveRecord
+
+  module Pry
+
+    def self.rescued(e)
+      if defined?(PryRescue) && e.instance_variable_defined?(:@rescue_bindings) && !e.is_a?(ReactiveRecord::AccessViolation)
+        ::Pry::rescued(e)
+      end
+    end
+
+  end
+
+end

data/lib/reactive_record/reactive_scope.rb

@@ -0,0 +1,18 @@
+# class ActiveRecord::Base
+#
+#   def self.to_sync(scope_name, opts={}, &block)
+#     watch_list = if opts[:watch]
+#       [*opts.delete[:watch]]
+#     else
+#       [self]
+#     end
+#     if RUBY_ENGINE=='opal'
+#       watch_list.each do |klass_to_watch|
+#         ReactiveRecord::Base.sync_blocks[klass_to_watch][self][scope_name] << block
+#       end
+#     else
+#       # this is where we put server side watchers in place to sync all clients!
+#     end
+#   end
+#
+# end

data/lib/reactive_record/scope_description.rb

@@ -0,0 +1,108 @@
+module ReactiveRecord
+  # Keeps track of the details (client side) of a scope.
+  # The main point is to provide knowledge of what models
+  # the scope is joined with, and the client side
+  # filter proc
+  class ScopeDescription
+    def initialize(model, name, opts)
+      sself = self
+      model.singleton_class.send(:define_method, "_#{name}_synchromesh_scope_description_") do
+        sself
+      end
+      @filter_proc = filter_proc(opts)
+      @name = name
+      @model = model
+      build_joins opts[:joins]
+    end
+
+    def self.find(target_model, name)
+      target_model.send "_#{name}_synchromesh_scope_description_"
+    end
+
+    def filter?
+      @filter_proc.respond_to?(:call)
+    end
+
+    def collector?
+      @is_collector
+    end
+
+    def joins_with?(record)
+      @joins.detect do |klass, vector|
+        vector.any? && (klass == :all || record.class == klass || record.class < klass)
+      end
+    end
+
+    def related_records_for(record)
+      ReactiveRecord::Base.catch_db_requests([]) do
+        (@joins[record.class.base_class] || @joins[:all]).collect do |vector|
+          crawl(record, *vector)
+        end.flatten.compact
+      end
+    end
+
+    def filter_records(related_records, args)
+      if collector?
+        Set.new(related_records.to_a.instance_exec(*args, &@filter_proc))
+      else
+        Set.new(related_records.select { |r| r.instance_exec(*args, &@filter_proc) })
+      end
+    rescue Exception => e
+      raise "Client side scope #{@model}.#{@name} raised error: #{e.message}"
+    end
+
+    # private methods
+
+    def filter_proc(opts)
+      return true unless opts.key?(:client) || opts.key?(:select)
+      client_opt = opts[:client] || opts[:select]
+      @is_collector = opts.key?(:select)
+      return client_opt if !client_opt || client_opt.respond_to?(:call)
+      raise 'Scope option :client or :select must be a proc, false, or nil'
+    end
+
+    def build_joins(joins_list)
+      if !@filter_proc || joins_list == []
+        @joins = { all: [] }
+      elsif joins_list.nil?
+        @joins = { @model => [[]], all: [] }
+      elsif joins_list == :all
+        @joins = { all: [[]] }
+      else
+        joins_list = [joins_list] unless joins_list.is_a? Array
+        map_joins_path joins_list
+      end
+    end
+
+    def map_joins_path(paths)
+      @joins = Hash.new { |h, k| h[k] = Array.new }.merge(@model => [[]])
+      paths.each do |path|
+        vector = []
+        path.split('.').inject(@model) do |model, attribute|
+          association = model.reflect_on_association(attribute)
+          raise build_error(path, model, attribute) unless association
+          vector = [association.inverse_of, *vector]
+          @joins[association.klass] << vector
+          association.klass
+        end
+      end
+    end
+
+    def build_error(path, model, attribute)
+      "Could not find joins association '#{model.name}.#{attribute}' "\
+      "for '#{path}' while processing scope #{@model.name}.#{@name}."
+    end
+
+    def crawl(item, method = nil, *vector)
+      if !method && item.is_a?(Collection)
+        item.all
+      elsif !method
+        item
+      elsif item.respond_to? :collect
+        item.collect { |record| crawl(record.send(method), *vector) }
+      else
+        crawl(item.send(method), *vector)
+      end
+    end
+  end
+end