isomorfeus-data 1.0.0.delta11

data/lib/lucid_hash/mixin.rb

@@ -0,0 +1,169 @@
+module LucidHash
+  module Mixin
+    def self.included(base)
+      if RUBY_ENGINE != 'opal'
+        Isomorfeus.add_valid_hash_class(base) unless base == LucidHash::Base
+      end
+
+      base.extend(Isomorfeus::Data::PropDeclaration)
+
+      def to_gid
+        [@class_name, @props_json]
+      end
+
+      def to_transport(inline: false)
+        if inline
+          { '_inline' => { @props_json => to_h }}
+        else
+          { 'hashes' => { @class_name => { @props_json => to_h }}}
+        end
+      end
+
+      base.instance_exec do
+        def on_load_block
+          @on_load_block
+        end
+
+        def query_block
+          @query_block
+        end
+      end
+
+      if RUBY_ENGINE == 'opal'
+        def initialize(store_path: nil, validated_props: nil)
+          @props = validated_props
+          @props_json = @props.to_json if @props
+          @class_name = self.class.name
+          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
+          @store_path = store_path ? store_path : [:data_state, :hashes, @class_name]
+        end
+
+        def loaded?
+          Redux.fetch_by_path(*(@store_path + [@props_json])) ? true : false
+        end
+
+        def [](name)
+          path = @store_path + [@props_json, name]
+          Redux.register_used_store_path(*path)
+          result = Redux.fetch_by_path(*path)
+          result ? result : nil
+        end
+
+        def key?(name)
+          path = @store_path + [@props_json, name]
+          Redux.register_used_store_path(*path)
+          Redux.fetch_by_path(*path) ? true : false
+        end
+
+        def method_missing(method_name, *args, &block)
+          path = @store_path + [@props_json]
+          Redux.register_used_store_path(*path)
+          raw_hash = Redux.fetch_by_path(*path)
+          if raw_hash
+            Hash.new(raw_hash).send(method_name, *args, &block)
+          else
+            Hash.new.send(method_name, *args, &block)
+          end
+        end
+
+        def to_h
+          raw_hash = Redux.fetch_by_path(*(@store_path + [@props_json]))
+          raw_hash ? Hash.new(raw_hash) : {}
+        end
+
+        base.instance_exec do
+          def load(props_hash = {})
+            validate_props(props_hash)
+            instance = self.new(validated_props: Isomorfeus::Data::Props.new(props_hash))
+            self.promise_load(props_hash, instance) unless instance.loaded?
+            instance
+          end
+
+          def on_load(&block)
+          end
+
+          def promise_load(props_hash = {}, instance = nil)
+            unless instance
+              validate_props(props_hash)
+              instance = self.new(validated_props: Isomorfeus::Data::Props.new(props_hash))
+            end
+
+            props_json = instance.instance_variable_get(:@props_json)
+
+            Redux.register_used_store_path(:data_state, :hashes, self.name, props_json)
+
+            Isomorfeus::Transport.promise_send_path('Isomorfeus::Data::Handler::HashLoadHandler', self.name, props_json).then do |response|
+              if response[:agent_response].key?(:error)
+                `console.error(#{response[:agent_response][:error].to_n})`
+                raise response[:agent_response][:error]
+              end
+              Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: response[:full_response][:data])
+              instance
+            end
+          end
+
+          def query
+            nil
+          end
+        end
+      else # RUBY_ENGINE
+        unless base == LucidHash::Base
+          base.prop :pub_sub_client, default: nil
+          base.prop :session_id, default: nil
+          base.prop :current_user, default: nil
+        end
+
+        def initialize(store_path: nil, validated_props: nil)
+          @props = validated_props
+          @props_json = @props.to_json if @props
+          @loaded = false
+          @class_name = self.class.name
+          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
+        end
+
+        def loaded?
+          @loaded
+        end
+
+        def [](name)
+          @data_hash[name]
+        end
+
+        def method_missing(method_name, *args, &block)
+          @data_hash.send(method_name, *args, &block)
+        end
+
+        def to_h
+          @data_hash.to_h.transform_keys { |k| k.to_s }
+        end
+
+        base.instance_exec do
+          def load(props_hash = {})
+            validate_props(props_hash)
+            instance = self.new(validated_props: Isomorfeus::Data::Props.new(props_hash))
+            instance.instance_exec do
+              @data_hash = self.class.query_block.call(props_hash)
+              @loaded = true
+            end
+            instance
+          end
+
+          def on_load(&block)
+            @on_load_block = block
+          end
+
+          def promise_load(props_hash = {}, instance = nil)
+            instance = self.load(props_hash)
+            result_promise = Promise.new
+            result_promise.resolve(instance)
+            result_promise
+          end
+
+          def query(&block)
+            @query_block = block
+          end
+        end
+      end  # RUBY_ENGINE
+    end
+  end
+end

data/lib/lucid_node/base.rb

@@ -0,0 +1,5 @@
+module LucidNode
+  class Base
+    include LucidNode::Mixin
+  end
+end

data/lib/lucid_node/mixin.rb

@@ -0,0 +1,201 @@
+# api
+# class:
+#   attribute :my_attribute, server_only: false|true, class: ClassName, is_a: ClassName, default: value, validate: block
+#   my_node.class.attributes
+#   my_node.class.attribute_options
+# instance:
+#   my_node.my_attribute
+#   my_node.my_attribute = value
+#   my_node.changed_attributes
+#   my_node.changed?
+#   my_node.loaded?
+#   my_node.valid_attribute?(attr, value)
+#   my_node.validate_attribute!(attr, value)
+#   my_node.to_transport
+
+module LucidNode
+  module Mixin
+    def self.included(base)
+      attr_reader :id
+
+      def ==(other_node)
+        eql?(other_node)
+      end
+
+      def eql?(other_node)
+        @id == other_node.id && @class_name == other_node.instance_variable_get(:@class_name)
+      end
+
+      def id=(new_id)
+        new_id = new_id.to_s
+        changed_attributes[:id] = new_id
+        @id = new_id
+      end
+
+      def changed_attributes
+        @changed_attributes ||= Isomorfeus::Data::Props.new({})
+      end
+
+      def changed?
+        changed_attributes.any?
+      end
+
+      def to_cid
+        [@class_name, @id]
+      end
+
+      def valid_attribute?(attr, value)
+        begin
+          validate_attribute!(attr, value)
+          true
+        rescue
+          false
+        end
+      end
+
+      def validate_attribute!(attr, value)
+        attr_options = self.class.attribute_options[attr]
+
+        if attr_options.key?(:class)
+          raise "#{attr}: value class is not #{attr_options[:class]}!" unless value.class == attr_options[:class]
+        end
+
+        if attr_options.key?(:is_a)
+          raise "#{attr}: value is not a #{attr_options[:class]}!" unless value.is_a?(attr_options[:is_a])
+        end
+
+        if attr_options.key?(:validate)
+          raise "#{attr}: value failed validation!" unless attr_options[:validate].call(value)
+        end
+      end
+
+      base.instance_exec do
+        def query_block
+          @query_block
+        end
+
+        def attributes
+          attribute_options.keys
+        end
+
+        def attribute_options
+          @attribute_options ||= { id: {} }
+        end
+
+        def node_from_cid(cid)
+          Isomorfeus.cached_node_class(cid[0]).new({id: cid[1]})
+        end
+      end
+
+      if RUBY_ENGINE == 'opal'
+        def initialize(attributes_hash = nil)
+          attributes_hash = {} unless attributes_hash
+          self.class.attributes.each do |attr|
+            if attributes_hash.key?(attr)
+              validate_attribute!(attr, attributes_hash[attr])
+              changed_attributes[attr] = attributes_hash[attr]
+            elsif self.class.attribute_options[attr].key?(:default)
+              changed_attributes[attr] = self.class.attribute_options[attr][:default]
+            end
+          end
+          @id = attributes_hash[:id].to_s
+          @id = "new_#{object_id}" if @id.empty?
+          @class_name = self.class.name
+          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
+        end
+
+        def loaded?
+          Redux.fetch_by_path(:data_state, :node, @class_name, :instances, @id) ? true : false
+        end
+
+        def to_transport(*args)
+          Redux.register_used_store_path(:data_state, :nodes, @class_name, @id)
+          final_attributes = {}
+          self.class.attributes.each do |attr|
+            next if attr == :id
+            final_attributes[attr] = send(attr)
+          end
+          { 'nodes' => { @class_name => { @id => { attributes: final_attributes }}}}
+        end
+
+        base.instance_exec do
+          def attribute(name, options = {})
+            attribute_options[name] = options
+
+            define_method(name) do
+              Redux.register_used_store_path(:data_state, :nodes, @class_name, @id, :attributes, name)
+              if changed_attributes.key?(name)
+                changed_attributes[name]
+              else
+                Redux.fetch_by_path(:data_state, :nodes, @class_name, @id, :attributes, name)
+              end
+            end
+
+            define_method("#{name}=") do |arg|
+              validate_attribute!(name, arg)
+              Redux.register_used_store_path(:data_state, :nodes, @class_name, @id, :attributes, name)
+              changed_attributes.set(name, arg)
+            end
+          end
+
+          def query
+            nil
+          end
+        end
+      else # RUBY_ENGINE
+        def initialize(attributes_hash = nil)
+          attributes_hash = {} unless attributes_hash
+          given_attributes = Isomorfeus::Data::Props.new(attributes_hash)
+          valid_attributes_hash = {}
+          self.class.attributes.each do |attr|
+            if given_attributes.key?(attr)
+              validate_attribute!(attr, given_attributes[attr])
+              valid_attributes_hash[attr] = given_attributes[attr]
+            elsif self.class.attribute_options[attr].key?(:default)
+              valid_attributes_hash[attr] = self.class.attribute_options[attr][:default]
+            end
+          end
+          @attributes = Isomorfeus::Data::Props.new(valid_attributes_hash)
+          @id = @attributes[:id].to_s
+          @id = "new_#{object_id}" if @id.empty?
+          @class_name = self.class.name
+          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
+        end
+
+        def loaded?
+          true
+        end
+
+        def to_transport(*args)
+          final_attributes = {}
+          self.class.attributes.each do |attr|
+            next if attr == :id
+            include_attribute = @attributes.key?(attr)
+            include_attribute = !self.class.attribute_options[attr][:server_only] if self.class.attribute_options[attr].key?(:server_only)
+            final_attributes[attr.to_s] = send(attr) if include_attribute
+          end
+          { 'nodes' => { @class_name => { @id => { 'attributes' => final_attributes }}}}
+        end
+
+        base.instance_exec do
+          def attribute(name, options = {})
+            attribute_options[name] = options
+
+            define_method(name) do
+              if changed_attributes.key?(name)
+                changed_attributes[name]
+              else
+                @attributes[name]
+              end
+            end
+
+            define_method("#{name}=") do |arg|
+              validate_attribute!(name, arg)
+              changed_attributes.set(name, arg)
+            end
+          end
+        end
+      end # RUBY_ENGINE
+    end
+  end
+end

metadata

@@ -0,0 +1,180 @@
+--- !ruby/object:Gem::Specification
+name: isomorfeus-data
+version: !ruby/object:Gem::Version
+  version: 1.0.0.delta11
+platform: ruby
+authors:
+- Jan Biedermann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+- !ruby/object:Gem::Dependency
+  name: opal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+- !ruby/object:Gem::Dependency
+  name: opal-activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+- !ruby/object:Gem::Dependency
+  name: opal-autoloader
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: isomorfeus-react
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 16.9.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 16.9.2
+- !ruby/object:Gem::Dependency
+  name: isomorfeus-redux
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.11
+- !ruby/object:Gem::Dependency
+  name: isomorfeus-transport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.delta11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.delta11
+description: Write Browser Apps that transparently access server side data with Graphs
+  and Collections with ease.
+email: jan@kursator.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/isomorfeus-data.rb
+- lib/isomorfeus/data/config.rb
+- lib/isomorfeus/data/core_ext/hash/deep_merge.rb
+- lib/isomorfeus/data/handler/array_load_handler.rb
+- lib/isomorfeus/data/handler/collection_load_handler.rb
+- lib/isomorfeus/data/handler/graph_load_handler.rb
+- lib/isomorfeus/data/handler/hash_load_handler.rb
+- lib/isomorfeus/data/prop_declaration.rb
+- lib/isomorfeus/data/props.rb
+- lib/isomorfeus/data/reducer.rb
+- lib/isomorfeus/data/version.rb
+- lib/lucid_array/base.rb
+- lib/lucid_array/mixin.rb
+- lib/lucid_collection/base.rb
+- lib/lucid_collection/mixin.rb
+- lib/lucid_edge/base.rb
+- lib/lucid_edge/mixin.rb
+- lib/lucid_graph/base.rb
+- lib/lucid_graph/mixin.rb
+- lib/lucid_hash/base.rb
+- lib/lucid_hash/mixin.rb
+- lib/lucid_node/base.rb
+- lib/lucid_node/mixin.rb
+homepage: http://isomorfeus.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Compose Graphs and Collections of data just as needed for a isomorfeus app.
+test_files: []