hyper-resource 1.0.0.lap34

data/lib/hyper_record/client_instance_methods.rb

@@ -0,0 +1,300 @@
+module HyperRecord
+  module ClientInstanceMethods
+
+    def initialize(record_hash = {})
+      # initalize internal data structures
+      record_hash = {} if record_hash.nil?
+      @properties_hash = {}
+      @changed_properties_hash = {}
+      @relations = {}
+      @rest_methods_hash = {}
+      self.class.rest_methods.keys.each { |method| @rest_methods_hash[method] = {} }
+      @destroyed = false
+      # for reactivity
+      @fetch_states = {}
+      @state_key = "#{self.class.to_s}_#{self.object_id}"
+      @observers = Set.new
+      @registered_collections = Set.new
+
+      _initialize_from_hash(record_hash)
+
+      # for reactivity
+      _register_observer
+    end
+
+    def _initialize_from_hash(record_hash)
+      reflections.keys.each do |relation|
+        if record_hash.has_key?(relation)
+          @fetch_states[relation] = 'f' # fetched
+          if reflections[relation][:kind] == :has_many
+            if record_hash[relation].nil?
+              @relations[relation] = HyperRecord::Collection.new([], self, relation)
+            else
+              @relations[relation] = self.class._convert_array_to_collection(record_hash[relation], self, relation)
+            end
+          else
+            @relations[relation] = self.class._convert_json_hash_to_record(record_hash[relation])
+          end
+        else
+          unless @fetch_states[collection] == 'f'
+            if reflections[relation][:kind] == :has_many
+              @relations[relation] = HyperRecord::Collection.new([], self, relation)
+            else
+              @relations[relation] = nil
+            end
+            @fetch_states[relation] = 'n' # not fetched
+          end
+        end
+        record_hash.delete(relation)
+      end
+
+      @properties_hash = record_hash
+
+      # change state
+      _mutate_state
+
+      # cache in global cache
+      self.class._record_cache[@properties_hash[:id]] = self if @properties_hash.has_key?(:id)
+    end
+
+    ### reactive api
+
+    def destroy
+      destroy_record
+      nil
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def link(other_record)
+      link_record(other_record)
+      self
+    end
+
+    def method_missing(method, arg)
+      if method.end_with?('=')
+        _register_observer
+        @changed_properties_hash[method.chop] = arg
+      else
+        _register_observer
+        if @changed_properties_hash.has_key?(method)
+          @changed_properties_hash[method]
+        else
+          @properties_hash[method]
+        end
+      end
+    end
+
+    def reflections
+      self.class.reflections
+    end
+
+    def reset
+      _register_observer
+      @changed_properties_hash = {}
+    end
+
+    def resource_base_uri
+      self.class.resource_base_uri
+    end
+
+    def rest_method_force_updates(method_name)
+      @rest_methods_hash[method_name][:force] = true
+    end
+
+    def rest_method_unforce_updates(method_name)
+      @rest_methods_hash[method_name][:force] = false
+    end
+
+    def save
+      save_record
+      self
+    end
+
+    def to_hash
+      _register_observer
+      res = @properties_hash.dup
+      res.merge!(@changed_properties_hash)
+      res
+    end
+
+    def to_s
+      _register_observer
+      @properties_hash.to_s
+    end
+
+    def unlink(other_record)
+      unlink_record(other_record, observer)
+      self
+    end
+
+    ### promise api
+
+    def destroy_record
+      _local_destroy
+      self.class._promise_delete("#{resource_base_uri}/#{@properties_hash[:id]}").then do |response|
+        nil
+      end.fail do |response|
+        error_message = "Destroying record #{self} failed!"
+        `console.error(error_message)`
+        response
+      end
+    end
+
+    def link_record(other_record, relation_name = nil)
+      _register_observer
+      called_from_collection = relation_name ? true : false
+      relation_name = other_record.class.to_s.underscore.pluralize unless relation_name
+      if reflections.has_key?(relation_name)
+        self.send(relation_name).push(other_record) unless called_from_collection
+      else
+        relation_name = other_record.class.to_s.underscore
+        raise "No collection for record of type #{other_record.class}" unless reflections.has_key?(relation_name)
+        self.send("#{relation_name}=", other_record) unless called_from_collection
+      end
+      payload_hash = other_record.to_hash
+      self.class._promise_post("#{resource_base_uri}/#{self.id}/relations/#{relation_name}.json", { data: payload_hash }).then do |response|
+        other_record.instance_variable_get(:@properties_hash).merge!(response.json[other_record.class.to_s.underscore])
+        _notify_observers
+        self
+      end.fail do |response|
+        error_message = "Linking record #{other_record} to #{self} failed!"
+        `console.error(error_message)`
+        response
+      end
+    end
+
+    def save_record
+      _register_observer
+      payload_hash =  @properties_hash.merge(@changed_properties_hash) # copy hash, becasue we need to delete some keys
+      (%i[id created_at updated_at] + reflections.keys).each do |key|
+        payload_hash.delete(key)
+      end
+      if @properties_hash[:id] && ! (@changed_properties_hash.has_key?(:id) && @changed_properties_hash[:id].nil?)
+        reset
+        self.class._promise_patch("#{resource_base_uri}/#{@properties_hash[:id]}", { data: payload_hash }).then do |response|
+          @properties_hash.merge!(response.json[self.class.to_s.underscore])
+          _notify_observers
+          self
+        end.fail do |response|
+          error_message = "Saving record #{self} failed!"
+          `console.error(error_message)`
+          response
+        end
+      else
+        reset
+        self.class._promise_post(resource_base_uri, { data: payload_hash }).then do |response|
+          @properties_hash.merge!(response.json[self.class.to_s.underscore])
+          _notify_observers
+          self
+        end.fail do |response|
+          error_message = "Creating record #{self} failed!"
+          `console.error(error_message)`
+          response
+        end
+      end
+    end
+
+    def unlink_record(other_record, relation_name = nil)
+      _register_observer
+      called_from_collection = collection_name ? true : false
+      relation_name = other_record.class.to_s.underscore.pluralize unless relation_name
+      raise "No relation for record of type #{other_record.class}" unless reflections.has_key?(relation_name)
+      self.send(relation_name).delete_if { |cr| cr == other_record } unless called_from_collection
+      self.class._promise_delete("#{resource_base_uri}/#{@properties_hash[:id]}/relations/#{relation_name}.json?record_id=#{other_record.id}").then do |response|
+        _notify_observers
+        self
+      end.fail do |response|
+        error_message = "Unlinking #{other_record} from #{self} failed!"
+        `console.error(error_message)`
+        response
+      end
+    end
+
+    ### internal
+
+    def _local_destroy
+      _register_observer
+      @destroyed = true
+      self.class._record_cache.delete(@properties_hash[:id])
+      @registered_collections.dup.each do |collection|
+        collection.delete(self)
+      end
+      @registered_collections = Set.new
+      _notify_observers
+    end
+
+    def _notify_observers
+      mutate.record_state(`Date.now() + Math.random()`)
+      @observers.each do |observer|
+        React::State.set_state(observer, @state_key, `Date.now() + Math.random()`)
+      end
+      @observers = Set.new
+      self.class._notify_class_observers
+    end
+
+    def _register_collection(collection)
+      @registered_collections << collection
+    end
+
+    def _register_observer
+      observer = React::State.current_observer
+      if observer
+        React::State.get_state(observer, @state_key)
+        @observers << observer # @observers is a set, observers get added only once
+      end
+    end
+
+    def _unregister_collection(collection)
+      @registered_collections.delete(collection)
+    end
+
+    def _update_record(data)
+      if data.has_key?(:relation)
+        if data.has_key?(:cause)
+          # this creation of variables for things that could be done in one line
+          # are a workaround for safari, to get it updating correctly
+          klass_name = data[:cause][:record_type]
+          c_record_class = Object.const_get(klass_name)
+          if c_record_class._record_cache.has_key?(data[:cause][:id])
+            c_record = c_record_class.find(data[:cause][:id])
+            if `Date.parse(#{c_record.updated_at}) >= Date.parse(#{data[:cause][:updated_at]})`
+              if @fetch_states[data[:relation]] == 'f'
+                if send(data[:relation]).include?(c_record)
+                  return
+                end
+              end
+            end
+          end
+        end
+        relation_fetch_state = @fetch_states[data[:relation]]
+        if relation_fetch_state == 'f'
+          @fetch_states[data[:relation]] = 'u'
+          send(data[:relation])
+        end
+        return
+      end
+      if data[:destroyed]
+        return if self.destroyed?
+        @remotely_destroyed = true
+        _local_destroy
+        return
+      end
+      if @properties_hash[:updated_at] && data[:updated_at]
+        return if `Date.parse(#{@properties_hash[:updated_at]}) >= Date.parse(#{data[:updated_at]})`
+      end
+      self.class._promise_get("#{resource_base_uri}/#{@properties_hash[:id]}.json").then do |response|
+        klass_key = self.class.to_s.underscore
+        self._initialize_from_hash(response.json[klass_key]) if response.json[klass_key]
+        _notify_observers
+        self
+      end.fail do |response|
+        error_message = "#{self} failed to update!"
+        `console.error(error_message)`
+        response
+      end
+    end
+  end
+end

data/lib/hyper_record/collection.rb

@@ -0,0 +1,39 @@
+module HyperRecord
+  class Collection < Array
+    def initialize(array, record = nil, relation_name = nil)
+      @record = record
+      @relation_name = relation_name
+      if array
+        array.each do |record|
+          record._register_collection(self)
+        end
+      end
+      @record._notify_observers if @record
+      array ? super(array) : super
+    end
+
+    def <<(other_record)
+      if @record && @relation_name
+        @record.link_record(other_record, @relation_name)
+      end
+      other_record._register_collection(self)
+      @record._notify_observers if @record
+      super(other_record)
+    end
+
+    def delete(other_record)
+      if @record && @relation_name && !other_record.instance_variable_get(:@remotely_destroyed)
+        @record.unlink_record(other_record, @relation_name)
+      end
+      other_record._unregister_collection(self)
+      @record._notify_observers if @record
+      super(other_record)
+    end
+
+    def push(other_record)
+      other_record._register_collection(self)
+      @record._notify_observers if @record
+      super(other_record)
+    end
+  end
+end

data/lib/hyper_record/dummy_value.rb

@@ -0,0 +1,23 @@
+module HyperRecord
+  class DummyValue
+    def intialize(type_class)
+      @backing_value = type_class.new
+    end
+
+    def method_missing(name, *args)
+      if args
+        @backing_value.send(name, args)
+      else
+        @backing_value.send(name)
+      end
+    end
+
+    def acts_as_string?
+      true
+    end
+
+    def to_s
+      "..."
+    end
+  end
+end

data/lib/hyper_record/server_class_methods.rb

@@ -0,0 +1,19 @@
+module HyperRecord
+  module ServerClassMethods
+    def rest_method(name, options = { default_result: '...' }, &block)
+      rest_methods[name] = options
+      rest_methods[name][:params] = block.arity
+      define_method(name) do |*args|
+        if args.size > 0
+          instance_exec(*args, &block)
+        else
+          instance_exec(&block)
+        end
+      end
+    end
+
+    def rest_methods
+      @rest_methods_hash ||= {}
+    end
+  end
+end

data/lib/hyperloop/resource/client_drivers.rb

@@ -0,0 +1,109 @@
+module Hyperloop
+  module Resource
+    class ClientDrivers
+      include React::IsomorphicHelpers
+
+      class << self
+        attr_reader :opts
+      end
+
+      if RUBY_ENGINE != 'opal'
+
+        prerender_footer do |controller|
+          # next if Hyperloop.transport == :none
+          # if defined?(PusherFake)
+          #   path = ::Rails.application.routes.routes.detect do |route|
+          #     route.app == Hyperloop::Engine ||
+          #       (route.app.respond_to?(:app) && route.app.app == Hyperloop::Engine)
+          #   end.path.spec
+          #   pusher_fake_js = PusherFake.javascript(
+          #     auth: { headers: { 'X-CSRF-Token' => controller.send(:form_authenticity_token) } },
+          #     authEndpoint: "#{path}/hyperloop-pusher-auth"
+          #   )
+          # end
+
+          config_hash = {
+            resource_transport: Hyperloop.resource_transport,
+            resource_api_base_path: Hyperloop.resource_api_base_path,
+            session_id: controller.session.id,
+            current_user_id: (controller.current_user.id if controller.current_user),
+            form_authenticity_token: controller.send(:form_authenticity_token)
+          }
+          case Hyperloop.resource_transport
+          when :action_cable
+          when :pusher
+            config_hash[:pusher] = {
+              key: Hyperloop.pusher[:key],
+              cluster: Hyperloop.pusher[:cluster],
+              encrypted: Hyperloop.pusher[:encrypted],
+              client_logging: Hyperloop.pusher[:client_logging] ? true : false
+            }
+          when :pusher_fake
+          end
+
+          "<script type='text/javascript'>\n"\
+            "window.HyperloopOpts = #{config_hash.to_json};\n"\
+            "Opal.Hyperloop.$const_get('Resource').$const_get('ClientDrivers').$initialize_client_drivers_on_boot();\n"\
+          "</script>\n"
+        end
+
+      else
+
+        def self.initialize_client_drivers_on_boot
+
+          return if @initialized
+
+          @initialized = true
+          @opts = {}
+
+          if on_opal_client?
+
+            @opts = Hash.new(`window.HyperloopOpts`)
+            @opts[:hyper_record_update_channel] = "hyper-record-update-channel-#{@opts[:session_id]}"
+            case @opts[:resource_transport]
+            when :pusher
+              if @opts[:pusher][:client_logging] && `window.console && window.console.log`
+                `Pusher.log = function(message) {window.console.log(message);}`
+              end
+
+              h = nil
+              pusher_api = nil
+              %x{
+                h = {
+                  encrypted: #{@opts[:pusher][:encrypted]},
+                  cluster: #{@opts[:pusher][:cluster]}
+
+                };
+                pusher_api = new Pusher(#{@opts[:pusher][:key]}, h)
+              }
+              @opts[:pusher][:pusher_api] = pusher_api
+              @opts[:pusher][:channel] = pusher_api.JS.subscribe(@opts[:hyper_record_update_channel])
+              @opts[:pusher][:channel].JS.bind('update', `function(data){
+                return Opal.Hyperloop.$const_get('Resource').$const_get('ClientDrivers').$process_notification(Opal.Hash.$new(data));
+              }`)
+
+            when opts[:resource_transport] == :action_cable
+              opts[:action_cable_consumer] =
+                `ActionCable.createConsumer.apply(ActionCable, #{[*opts[:action_cable_consumer_url]]})`
+              Hyperloop.connect(*opts[:auto_connect])
+            end
+          end
+        end
+
+        def self.process_notification(data)
+          record_class = Object.const_get(data[:record_type])
+          if data[:scope]
+            scope_fetch_state = record_class._class_fetch_states[data[:scope]]
+            if scope_fetch_state == 'f'
+              record_class._class_fetch_states[data[:scope]] = 'u'
+              record_class.send(data[:scope])
+            end
+          elsif record_class.record_cached?(data[:id])
+            record = record_class.find(data[:id])
+            record._update_record(data)
+          end
+        end
+      end
+    end
+  end
+end