hyper-resource 1.0.0.lap58 → 1.0.0.lap62

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bcbeaa04a6654be3f24e097ea9d2f2f73b9579857a66e1c6ceee03c49013073
-  data.tar.gz: 38bc971a2d049850bafc340cce9545f42953f4fac8eb0ef944217d2dacd6bde8
+  metadata.gz: 1b68ab98c8c4f86ae7f9ef65df1e9fce88f1cf4d769f5f043da7d8798415abc9
+  data.tar.gz: aff99ed6aa6fc953e8e003ee98728f414ca796644cfeadd9d4ca729ba365cb69
 SHA512:
-  metadata.gz: 0d502dd12afec243680c27aad39b8998ccb180b6e8783a0ececc989163d47f84aca92909ef9a73cfc99a9e19c11ab32c7e76eb77bdfaec879230ba0845169dbf
-  data.tar.gz: 6dc999b8179e2d0a990a52d528f467fc158b4fbb338b7b439db0308cb34fa76a0146e15d0092a429a53c751dcd39cb537b4da35e02a472a76d62eb47b8c23331
+  metadata.gz: 6f8c4c16583165457179a7175d00f69a98d1a3f081dbd1b87f5fff42a4a68cf4125f65eb8f7c28262160b2ab31a7af0077b9ed7ba9a612f40296947b2f3557db
+  data.tar.gz: d947709f378d8add9359dc2970fe7e05446dbd4e08cf9c9cfdcee55932a4ab346b8f992e6e1de5256c62c76ec1b4fa6510479141e1bb0a8c66d115b17ec40774

data/lib/hyper_record/class_methods.rb

@@ -5,7 +5,7 @@ module HyperRecord
       if record_hash.has_key?(:id)
         record = _record_cache[record_hash[:id].to_s]
         if record
-          record.instance_variable_get(:@properties_hash).merge!(record_hash)
+          record.instance_variable_get(:@properties).merge!(record_hash)
           return record
         end
       end
@@ -309,15 +309,15 @@ module HyperRecord
       _property_options[name] = options
       define_method(name) do
         _register_observer
-        if @properties_hash[:id]
-          if @changed_properties_hash.has_key?(name)
-            @changed_properties_hash[name]
+        if @properties[:id]
+          if @changed_properties.has_key?(name)
+            @changed_properties[name]
           else
-            @properties_hash[name]
+            @properties[name]
           end
         else
           # record has not been fetched or is new and not yet saved
-          if @properties_hash[name].nil?
+          if @properties[name].nil?
             # TODO move default to initializer?
             if self.class._property_options[name].has_key?(:default)
               self.class._property_options[name][:default]
@@ -327,13 +327,13 @@ module HyperRecord
               HyperRecord::DummyValue.new(NilClass)
             end
           else
-            @properties_hash[name]
+            @properties[name]
           end
         end
       end
       define_method("#{name}=") do |value|
         _register_observer
-        @changed_properties_hash[name] = value
+        @changed_properties[name] = value
       end
     end
 
@@ -342,47 +342,48 @@ module HyperRecord
     end
 
     def rest_class_method(name, options = { default_result: '...' })
-      rest_methods[name] = options
-      rest_methods[name][:class_method] = true
-      singleton_class.send(:define_method, "promise_#{name}") do |*args|
+      rest_class_methods[name] = options
+      define_singleton_method("promise_#{name}") do |*args|
+        name_args = _name_args(name, *args)
+        _class_fetch_states[name_args] = 'i'
+        rest_class_methods[name_args] = { result: options[:default_result] } unless rest_class_methods.has_key?(name_args)
         _promise_get_or_patch("#{resource_base_uri}/methods/#{name}.json?timestamp=#{`Date.now() + Math.random()`}", *args).then do |response_json|
-          rest_methods[name][:result] = response_json[:result] # result is parsed json
+          rest_class_methods[name_args][:result] = response_json[:result] # result is parsed json
+          _class_fetch_states[name_args] = 'f'
           _notify_class_observers
-          rest_methods[name][:result]
+          rest_class_methods[name_args][:result]
         end.fail do |response|
           error_message = "#{self.to_s}.#{name}, a rest_method, failed to execute!"
           `console.error(error_message)`
           response
         end
       end
-      singleton_class.send(:define_method, name) do |*args|
+      define_singleton_method(name) do |*args|
+        name_args = _name_args(name, *args)
         _register_class_observer
-        if rest_methods[name][:force] || !rest_methods[name].has_key?(:result)
+        rest_class_methods[name_args] = { result: options[:default_result] } unless rest_methods.has_key?(name_args)
+        unless 'fi'.include?(_class_fetch_states[name_args])
           self.send("promise_#{name}", *args)
         end
-        if rest_methods[name].has_key?(:result)
-          rest_methods[name][:result]
-        else
-          rest_methods[name][:default_result]
-        end
+        rest_class_methods[name_args][:result]
+      end
+      define_singleton_method("update_#{name}") do |*args|
+        _class_fetch_states[_name_args(name, *args)] = 'u'
       end
-    end
-
-    def rest_class_method_force_updates(method_name)
-      rest_methods[method_name][:force] = true
-    end
-
-    def rest_class_method_unforce_updates(method_name)
-      rest_methods[method_name][:force] = false
     end
 
     def rest_method(name, options = { default_result: '...' })
-      rest_methods[name] = options
       define_method("promise_#{name}") do |*args|
+        name_args = self.class._name_args(name, *args)
+        @fetch_states[name_args] = 'i'
+        @rest_methods[name] = options unless @rest_methods.has_key?(name)
+        @rest_methods[name_args] = { result: options[:default_result] } unless @rest_methods.has_key?(name_args)
+        raise "#{self.class.to_s}[_no_id_].#{name}, can't execute instance rest_method without id!" unless self.id
         self.class._promise_get_or_patch("#{resource_base_uri}/#{self.id}/methods/#{name}.json?timestamp=#{`Date.now() + Math.random()`}", *args).then do |response_json|
-          @rest_methods_hash[name][:result] = response_json[:result] # result is parsed json
+          @rest_methods[name_args][:result] = response_json[:result] # result is parsed json
+          @fetch_states[name_args] = 'f'
           _notify_observers
-          @rest_methods_hash[name][:result]
+          @rest_methods[name_args][:result]
         end.fail do |response|
           error_message = "#{self.class.to_s}[#{self.id}].#{name}, a rest_method, failed to execute!"
           `console.error(error_message)`
@@ -391,19 +392,21 @@ module HyperRecord
       end
       define_method(name) do |*args|
         _register_observer
-        if self.id && (self.class.rest_methods[name][:force] || @rest_methods_hash[name][:force] || !@rest_methods_hash[name].has_key?(:result))
+        name_args = self.class._name_args(name, *args)
+        @rest_methods[name] = options unless @rest_methods.has_key?(name)
+        @rest_methods[name_args] = { result: options[:default_result] } unless @rest_methods.has_key?(name_args)
+        unless 'fi'.include?(@fetch_states[name_args])
           self.send("promise_#{name}", *args)
         end
-        if @rest_methods_hash[name].has_key?(:result)
-          @rest_methods_hash[name][:result]
-        else
-          self.class.rest_methods[name][:default_result]
-        end
+        @rest_methods[name_args][:result]
+      end
+      define_method("update_#{name}") do |*args|
+        @fetch_states[self.class._name_args(name, *args)] = 'u'
       end
     end
 
-    def rest_methods
-      @rest_methods_hash ||= {}
+    def rest_class_methods
+      @rest_class_methods ||= {}
     end
 
     def resource_base_uri
@@ -412,11 +415,7 @@ module HyperRecord
 
     def scope(name, options)
       define_singleton_method("promise_#{name}") do |*args|
-        name_args = if args.size > 0
-                      "#{name}_#{args.to_json}"
-                    else
-                      name
-                    end
+        name_args = _name_args(name, *args)
         _class_fetch_states[name_args] = 'i'
         self._promise_get_or_patch("#{resource_base_uri}/scopes/#{name}.json", *args).then do |response_json|
           scopes[name_args] = _convert_array_to_collection(response_json[self.to_s.underscore][name])
@@ -430,27 +429,16 @@ module HyperRecord
         end
       end
       define_singleton_method(name) do |*args|
-        name_args = if args.size > 0
-                      "#{name}_#{args.to_json}"
-                    else
-                      name
-                    end
+        name_args = _name_args(name, *args)
         scopes[name_args] = HyperRecord::Collection.new unless scopes.has_key?(name_args)
-        if _class_fetch_states.has_key?(name_args) && 'fi'.include?(_class_fetch_states[name_args])
-          scopes[name_args]
-        else
-          _register_class_observer
+        _register_class_observer
+        unless 'fi'.include?(_class_fetch_states[name_args])
           self.send("promise_#{name}", *args)
-          scopes[name_args]
         end
+        scopes[name_args]
       end
       define_singleton_method("update_#{name}") do |*args|
-        name_args = if args.size > 0
-                      "#{name}_#{args.to_json}"
-                    else
-                      name
-                    end
-        _class_fetch_states[name_args] = 'u'
+        _class_fetch_states[_name_args(name, *args)] = 'u'
       end
     end
 
@@ -502,6 +490,14 @@ module HyperRecord
       @_class_state_key
     end
 
+    def _name_args(name, *args)
+      if args.size > 0
+        "#{name}_#{args.to_json}"
+      else
+        name
+      end
+    end
+
     def _promise_find(id, record_in_progress)
       _class_fetch_states["record_#{id}"] = 'i'
       _promise_get("#{resource_base_uri}/#{id}.json").then do |response|

data/lib/hyper_record/client_instance_methods.rb

@@ -4,13 +4,16 @@ module HyperRecord
     def initialize(record_hash = {})
       # initalize internal data structures
       record_hash = {} if record_hash.nil?
-      @properties_hash = {}
-      @changed_properties_hash = {}
+      @properties = {}
+      @changed_properties = {}
       @relations = {}
-      @rest_methods_hash = {}
-      self.class.rest_methods.keys.each { |method| @rest_methods_hash[method] = {} }
+      @rest_methods = {}
       @destroyed = false
-      # for reactivity
+      # for reactivity, possible @fetch_states:
+      # n - not fetched
+      # f - fetched
+      # i - fetch in progress
+      # u - update needed, fetch on next usage
       @fetch_states = {}
       @state_key = "#{self.class.to_s}_#{self.object_id}"
       @observers = Set.new
@@ -42,19 +45,16 @@ module HyperRecord
             else
               @relations[relation] = nil
             end
-            @fetch_states[relation] = 'n' # not fetched
+            @fetch_states[relation] = 'n'
           end
         end
         record_hash.delete(relation)
       end
 
-      @properties_hash = record_hash
-
-      # change state
-      _mutate_state
+      @properties = record_hash
 
       # cache in global cache
-      self.class._record_cache[@properties_hash[:id].to_s] = self if @properties_hash.has_key?(:id)
+      self.class._record_cache[@properties[:id].to_s] = self if @properties.has_key?(:id)
     end
 
     ### reactive api
@@ -79,12 +79,12 @@ module HyperRecord
     def method_missing(method, arg)
       _register_observer
       if method.end_with?('=')
-        @changed_properties_hash[method.chop] = arg
+        @changed_properties[method.chop] = arg
       else
-        if @changed_properties_hash.has_key?(method)
-          @changed_properties_hash[method]
+        if @changed_properties.has_key?(method)
+          @changed_properties[method]
         else
-          @properties_hash[method]
+          @properties[method]
         end
       end
     end
@@ -95,21 +95,13 @@ module HyperRecord
 
     def reset
       _register_observer
-      @changed_properties_hash = {}
+      @changed_properties = {}
     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
       _register_observer
       promise_save.then do
@@ -120,14 +112,14 @@ module HyperRecord
 
     def to_hash
       _register_observer
-      res = @properties_hash.dup
-      res.merge!(@changed_properties_hash)
+      res = @properties.dup
+      res.merge!(@changed_properties)
       res
     end
 
     def to_s
       _register_observer
-      @properties_hash.to_s
+      @properties.to_s
     end
 
     def unlink(other_record)
@@ -142,7 +134,7 @@ module HyperRecord
 
     def promise_destroy
       _local_destroy
-      self.class._promise_delete("#{resource_base_uri}/#{@properties_hash[:id]}").then do |response|
+      self.class._promise_delete("#{resource_base_uri}/#{@properties[:id]}").then do |response|
         self
       end.fail do |response|
         error_message = "Destroying record #{self} failed!"
@@ -155,15 +147,15 @@ module HyperRecord
       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
+        @relations[relation_name].push(other_record) if !called_from_collection && @fetch_states[relation_name] == 'f'
       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
+        @relations[relation_name].push(other_record) if !called_from_collection && @fetch_states[relation_name] == 'f'
       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])
+        other_record.instance_variable_get(:@properties).merge!(response.json[other_record.class.to_s.underscore])
         self
       end.fail do |response|
         error_message = "Linking record #{other_record} to #{self} failed!"
@@ -173,14 +165,14 @@ module HyperRecord
     end
 
     def promise_save
-      payload_hash = @properties_hash.merge(@changed_properties_hash) # copy hash, because we need to delete some keys
+      payload_hash = @properties.merge(@changed_properties) # copy hash, because 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?)
+      if @properties[:id] && ! (@changed_properties.has_key?(:id) && @changed_properties[: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])
+        self.class._promise_patch("#{resource_base_uri}/#{@properties[:id]}", { data: payload_hash }).then do |response|
+          @properties.merge!(response.json[self.class.to_s.underscore])
           self
         end.fail do |response|
           error_message = "Saving record #{self} failed!"
@@ -190,7 +182,7 @@ module HyperRecord
       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])
+          @properties.merge!(response.json[self.class.to_s.underscore])
           self
         end.fail do |response|
           error_message = "Creating record #{self} failed!"
@@ -204,8 +196,8 @@ module HyperRecord
       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|
+      @relations[relation_name].delete_if { |cr| cr == other_record } if !called_from_collection && @fetch_states[relation_name] == 'f'
+      self.class._promise_delete("#{resource_base_uri}/#{@properties[:id]}/relations/#{relation_name}.json?record_id=#{other_record.id}").then do |response|
         self
       end.fail do |response|
         error_message = "Unlinking #{other_record} from #{self} failed!"
@@ -219,7 +211,7 @@ module HyperRecord
     def _local_destroy
       _register_observer
       @destroyed = true
-      self.class._record_cache.delete(@properties_hash[:id].to_s)
+      self.class._record_cache.delete(@properties[:id].to_s)
       @registered_collections.dup.each do |collection|
         collection.delete(self)
       end
@@ -267,7 +259,7 @@ module HyperRecord
             end
             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)
+                if @relations[data[:relation]].include?(c_record)
                   return unless data[:cause][:destroyed]
                 end
               end
@@ -275,7 +267,17 @@ module HyperRecord
           end
         end
         @fetch_states[data[:relation]] = 'u'
-        send(data[:relation])
+        send("prommise_#{data[:relation]}").then do |collection|
+          _notify_observers
+        end.fail do |response|
+          error_message = "#{self}[#{self.id}].#{data[:relation]} failed to update!"
+          `console.error(error_message)`
+        end
+        return
+      end
+      if data.has_key?(:rest_method)
+        @fetch_states[data[:rest_method]] = 'u'
+        _notify_observers
         return
       end
       if data[:destroyed]
@@ -284,18 +286,16 @@ module HyperRecord
         _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]})`
+      if @properties[:updated_at] && data[:updated_at]
+        return if `Date.parse(#{@properties[: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]
+      self.class._class_fetch_states["record_#{id}"] = 'u'
+      self.class._promise_find(@properties[:id], self).then do |record|
         _notify_observers
         self
       end.fail do |response|
         error_message = "#{self} failed to update!"
         `console.error(error_message)`
-        response
       end
     end
   end

data/lib/hyper_record/pub_sub.rb

@@ -1,10 +1,14 @@
 module HyperRecord
   module PubSub
     def self.included(base)
+      attr_accessor :current_rest_method_params
+
       base.extend(HyperRecord::PubSub::ClassMethods)
     end
 
     module ClassMethods
+      attr_accessor :current_rest_method_params
+
       def _pusher_client
         Hyperloop.pusher_instance ||= Pusher::Client.new(
           app_id: Hyperloop.pusher[:app_id],
@@ -70,6 +74,45 @@ module HyperRecord
         Hyperloop.redis_instance.del("HRPS__#{record.class}__#{record.id}") if record.destroyed?
       end
 
+      def publish_rest_class_method(record_class, rest_class_method_name)
+        subscribers = Hyperloop.redis_instance.hgetall("HRPS__#{record_class}__rest_class_method__#{rest_class_method_name}")
+        time_now = Time.now.to_f
+        scrub_time = time_now - 24.hours.to_f
+        subscribers.each do |session_id, last_requested|
+          if last_requested.to_f < scrub_time
+            Hyperloop.redis_instance.hdel("HRPS__#{record_class}__rest_class_method__#{rest_class_method_name}", session_id)
+            next
+          end
+          message = {
+            record_type: record_class.to_s,
+            rest_class_method: rest_class_method_name
+          }
+          if Hyperloop.resource_transport == :pusher
+            _pusher_client.trigger("hyper-record-update-channel-#{session_id}", 'update', message)
+          end
+        end
+      end
+
+      def publish_rest_method(record, method_name)
+        subscribers = Hyperloop.redis_instance.hgetall("HRPS__#{record.class}__#{record.id}__rest_method__#{method_name}")
+        time_now = Time.now.to_f
+        scrub_time = time_now - 24.hours.to_f
+        subscribers.each do |session_id, last_requested|
+          if last_requested.to_f < scrub_time
+            Hyperloop.redis_instance.hdel("HRPS__#{record.class}__#{record.id}__rest_method__#{method_name}", session_id)
+            next
+          end
+          message = {
+            record_type: record_class.to_s,
+            id: record.id,
+            rest_method: method_name
+          }
+          if Hyperloop.resource_transport == :pusher
+            _pusher_client.trigger("hyper-record-update-channel-#{session_id}", 'update', message)
+          end
+        end
+      end
+
       def publish_scope(record_class, scope_name)
         subscribers = Hyperloop.redis_instance.hgetall("HRPS__#{record_class}__scope__#{scope_name}")
         time_now = Time.now.to_f
@@ -112,6 +155,22 @@ module HyperRecord
         Hyperloop.redis_instance.hset "HRPS__#{record.class}__#{record.id}", session.id.to_s, Time.now.to_f.to_s
       end
 
+      def subscribe_rest_class_method(record_class, rest_class_method_name)
+        return unless session.id
+        time_now = Time.now.to_f.to_s
+        session_id = session.id.to_s
+        Hyperloop.redis_instance.pipelined do
+          Hyperloop.redis_instance.hset("HRPS__#{record_class}__rest_class_method_name__#{rest_class_method_name}", session_id, time_now)
+        end
+      end
+
+      def subscribe_rest_method(record, rest_method_name)
+        return unless session.id
+        time_now = Time.now.to_f.to_s
+        session_id = session.id.to_s
+        Hyperloop.redis_instance.hset("HRPS__#{record.class}__#{record.id}__rest_method__#{rest_method_name}", session_id, time_now)
+      end
+
       def subscribe_scope(collection, record_class = nil, scope_name = nil)
         return unless session.id
         time_now = Time.now.to_f.to_s
@@ -136,6 +195,16 @@ module HyperRecord
         publish_record(record)
       end
 
+      def pub_sub_rest_class_method(record_class, rest_class_method_name)
+        subscribe_rest_class_method(record_class, rest_class_method_name)
+        publish_rest_class_method(record_class, rest_class_method_name)
+      end
+
+      def pub_sub_rest_method(record, rest_method_name)
+        subscribe_rest_method(record, rest_method_name)
+        publish_rest_method(record, rest_method_name)
+      end
+
       def pub_sub_scope(collection, record_class, scope_name)
         subscribe_scope(collection, record_class, scope_name)
         publish_scope(record_class, scope_name)

data/lib/hyper_record/server_class_methods.rb

@@ -26,7 +26,7 @@ module HyperRecord
     end
 
     def rest_methods
-      @rest_methods_hash ||= {}
+      @rest_methods ||= {}
     end
 
     def resource_scopes

data/lib/hyperloop/resource/client_drivers.rb

@@ -97,11 +97,24 @@ module Hyperloop
             if scope_params
               scope_params = '[' + scope_params
               record_class._class_fetch_states[data[:scope]] = 'u'
-              record_class.send(scope_name, *JSON.parse(scope_params))
+              record_class.send("promise_#{scope_name}", *JSON.parse(scope_params)).then do |collection|
+                record_class._notify_class_observers
+              end.fail do |response|
+                error_message = "#{record_class}.#{scope_name}(#{scope_params}), a scope failed to update!"
+                `console.error(error_message)`
+              end
             else
               record_class._class_fetch_states[data[:scope]] = 'u'
-              record_class.send(data[:scope])
+              record_class.send(data[:scope]).then do |collection|
+                record_class._notify_class_observers
+              end.fail do |response|
+                error_message = "#{record_class}.#{scope_name}, a scope failed to update!"
+                `console.error(error_message)`
+              end
             end
+          elsif data[:rest_class_method]
+            record_class._class_fetch_states[data[:rest_class_method]] = 'u'
+            record_class._notify_class_observers
           elsif record_class.record_cached?(data[:id])
             record = record_class.find(data[:id])
             record._update_record(data)

data/lib/hyperloop/resource/version.rb

@@ -1,5 +1,5 @@
 module Hyperloop
   module Resource
-    VERSION = '1.0.0.lap58'
+    VERSION = '1.0.0.lap62'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hyper-resource
 version: !ruby/object:Gem::Version
-  version: 1.0.0.lap58
+  version: 1.0.0.lap62
 platform: ruby
 authors:
 - Jan Biedermann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-26 00:00:00.000000000 Z
+date: 2018-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opal