isomorfeus-data 1.0.0.delta11

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c88289965bb31facfa65c47f0765ce3666ceb4037396dfad2cc7f186b26015cc
+  data.tar.gz: 4324025cab83a20528a5cc1003111cb6315cb4332998bde4acdedbeea3d18a9a
+SHA512:
+  metadata.gz: 37f57249d5a9605b4beb5ff9d84e5959636ccb33f64a643f7c5ba56b7e2b8392f8778a61c949e3fd5f34e25691e58e68f76d1966cf8660a398a511d965d58b74
+  data.tar.gz: 3cb3de2349ab663682381cabd57a70f29819efb2ef7760fc0d5bb9ce065a7eb83f1b652ff9fff5f0d5abf1b82b962813520612e58b67675a9366e178e0ebf198

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Jan Biedermann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,3 @@
+# isomorfeus-data
+
+see docs for now

data/lib/isomorfeus/data/config.rb

@@ -0,0 +1,116 @@
+module Isomorfeus
+  # available settings
+  class << self
+    def cached_array_classes
+      @cached_array_classes ||= {}
+    end
+
+    def cached_array_class(class_name)
+      return cached_array_classes[class_name] if cached_array_classes.key?(class_name)
+      cached_array_classes[class_name] = "::#{class_name}".constantize
+    end
+
+    def cached_collection_classes
+      @cached_collection_classes ||= {}
+    end
+
+    def cached_collection_class(class_name)
+      return cached_collection_classes[class_name] if cached_collection_classes.key?(class_name)
+      cached_collection_classes[class_name] = "::#{class_name}".constantize
+    end
+
+    def cached_edge_classes
+      @cached_edge_classes ||= {}
+    end
+
+    def cached_edge_class(class_name)
+      return cached_edge_classes[class_name] if cached_edge_classes.key?(class_name)
+      cached_edge_classes[class_name] = "::#{class_name}".constantize
+    end
+
+    def cached_graph_classes
+      @cached_graph_classes ||= {}
+    end
+
+    def cached_graph_class(class_name)
+      return cached_graph_classes[class_name] if cached_graph_classes.key?(class_name)
+      cached_graph_classes[class_name] = "::#{class_name}".constantize
+    end
+
+    def cached_hash_classes
+      @cached_hash_classes ||= {}
+    end
+
+    def cached_hash_class(class_name)
+      return cached_hash_classes[class_name] if cached_hash_classes.key?(class_name)
+      cached_hash_classes[class_name] = "::#{class_name}".constantize
+    end
+
+    def cached_node_classes
+      @cached_node_classes ||= {}
+    end
+
+    def cached_node_class(class_name)
+      return cached_node_classes[class_name] if cached_node_classes.key?(class_name)
+      cached_node_classes[class_name] = "::#{class_name}".constantize
+    end
+
+    if RUBY_ENGINE != 'opal'
+      def valid_array_class_names
+        @valid_array_class_names ||= Set.new
+      end
+
+      def valid_array_class_name?(class_name)
+        valid_array_class_names.include?(class_name)
+      end
+
+      def add_valid_array_class(klass)
+        class_name = klass.name
+        class_name = class_name.split('>::').last if class_name.start_with?('#<')
+        valid_array_class_names << class_name
+      end
+
+      def valid_collection_class_names
+        @valid_collection_class_names ||= Set.new
+      end
+
+      def valid_collection_class_name?(class_name)
+        valid_collection_class_names.include?(class_name)
+      end
+
+      def add_valid_collection_class(klass)
+        class_name = klass.name
+        class_name = class_name.split('>::').last if class_name.start_with?('#<')
+        valid_collection_class_names << class_name
+      end
+
+      def valid_graph_class_names
+        @valid_graph_class_names ||= Set.new
+      end
+
+      def valid_graph_class_name?(class_name)
+        valid_graph_class_names.include?(class_name)
+      end
+
+      def add_valid_graph_class(klass)
+        class_name = klass.name
+        class_name = class_name.split('>::').last if class_name.start_with?('#<')
+        valid_graph_class_names << class_name
+      end
+
+      def valid_hash_class_names
+        @valid_hash_class_names ||= Set.new
+      end
+
+      def valid_hash_class_name?(class_name)
+        valid_hash_class_names.include?(class_name)
+      end
+
+      def add_valid_hash_class(klass)
+        class_name = klass.name
+        class_name = class_name.split('>::').last if class_name.start_with?('#<')
+        valid_hash_class_names << class_name
+      end
+    end
+  end
+end

data/lib/isomorfeus/data/core_ext/hash/deep_merge.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+# taken from: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/hash/deep_merge.rb
+
+class Hash
+  # Returns a new hash with +self+ and +other_hash+ merged recursively.
+  #
+  #   h1 = { a: true, b: { c: [1, 2, 3] } }
+  #   h2 = { a: false, b: { x: [3, 4, 5] } }
+  #
+  #   h1.deep_merge(h2) # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
+  #
+  # Like with Hash#merge in the standard library, a block can be provided
+  # to merge values:
+  #
+  #   h1 = { a: 100, b: 200, c: { c1: 100 } }
+  #   h2 = { b: 250, c: { c1: 200 } }
+  #   h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val }
+  #   # => { a: 100, b: 450, c: { c1: 300 } }
+  def deep_merge(other_hash, &block)
+    dup.deep_merge!(other_hash, &block)
+  end
+
+  # Same as +deep_merge+, but modifies +self+.
+  def deep_merge!(other_hash, &block)
+    merge!(other_hash) do |key, this_val, other_val|
+      if this_val.is_a?(Hash) && other_val.is_a?(Hash)
+        this_val.deep_merge(other_val, &block)
+      elsif block_given?
+        block.call(key, this_val, other_val)
+      else
+        other_val
+      end
+    end
+  end
+end

data/lib/isomorfeus/data/handler/array_load_handler.rb

@@ -0,0 +1,41 @@
+module Isomorfeus
+  module Data
+    module Handler
+      class ArrayLoadHandler < LucidHandler::Base
+        on_request do |pub_sub_client, session_id, current_user, request, response|
+          result = { error: 'No such thing' }
+          # promise_send_path('Isomorfeus::Data::Handler::CollectionLoadHandler', self.to_s, props_hash)
+          request.each_key do |array_class_name|
+            if Isomorfeus.valid_array_class_name?(array_class_name)
+              array_class = Isomorfeus.cached_array_class(array_class_name)
+              if array_class
+                props_json = request[array_class_name]
+                begin
+                  props = Oj.load(props_json, mode: :strict)
+                  props.merge!({pub_sub_client: pub_sub_client, session_id: session_id, current_user: current_user})
+                  array = array_class.load(props)
+                  array.instance_exec do
+                    array_class.on_load_block.call(pub_sub_client, session_id, current_user) if array_class.on_load_block
+                  end
+                  response.deep_merge!(data: array.to_transport)
+                  result = { success: 'ok' }
+                rescue Exception => e
+                  result = if Isomorfeus.production?
+                             { error: { array_class_name => 'No such thing!' }}
+                           else
+                             { error: { array_class_name => "Isomorfeus::Data::Handler::ArrayLoadHandler: #{e.message}" }}
+                           end
+                end
+              else
+                result = { error: { array_class_name => 'No such thing!' }}
+              end
+            else
+              result = { error: { array_class_name => 'No such thing!' }}
+            end
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/data/handler/collection_load_handler.rb

@@ -0,0 +1,42 @@
+module Isomorfeus
+  module Data
+    module Handler
+      class CollectionLoadHandler < LucidHandler::Base
+        on_request do |pub_sub_client, session_id, current_user, request, response|
+          result = { error: 'No such thing' }
+          # promise_send_path('Isomorfeus::Data::Handler::CollectionLoadHandler', self.to_s, props_hash)
+          request.each_key do |collection_class_name|
+            if Isomorfeus.valid_collection_class_name?(collection_class_name)
+              collection_class = Isomorfeus.cached_collection_class(collection_class_name)
+              if collection_class
+                props_json = request[collection_class_name]
+                begin
+                  props = Oj.load(props_json, mode: :strict)
+                  props.merge!({pub_sub_client: pub_sub_client, session_id: session_id, current_user: current_user})
+                  collection = collection_class.load(props)
+                  collection.instance_exec do
+                    collection_class.on_load_block.call(pub_sub_client, session_id, current_user) if collection_class.on_load_block
+                  end
+                  response.deep_merge!(data: collection.to_transport)
+                  response.deep_merge!(data: collection.included_items_to_transport)
+                  result = { success: 'ok' }
+                rescue Exception => e
+                  result = if Isomorfeus.production?
+                             { error: { collection_class_name => 'No such thing!' }}
+                           else
+                             { error: { collection_class_name => "Isomorfeus::Data::Handler::CollectionLoadHandler: #{e.message}" }}
+                           end
+                end
+              else
+                result = { error: { collection_class_name => 'No such thing!' }}
+              end
+            else
+              result = { error: { collection_class_name => 'No such thing!' }}
+            end
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/data/handler/graph_load_handler.rb

@@ -0,0 +1,42 @@
+module Isomorfeus
+  module Data
+    module Handler
+      class GraphLoadHandler < LucidHandler::Base
+        on_request do |pub_sub_client, session_id, current_user, request, response|
+          result = { error: 'No such thing' }
+          # promise_send_path('Isomorfeus::Data::Handler::GraphLoadHandler', self.to_s, props_hash)
+          request.each_key do |graph_class_name|
+            if Isomorfeus.valid_graph_class_name?(graph_class_name)
+              graph_class = Isomorfeus.cached_graph_class(graph_class_name)
+              if graph_class
+                props_json = request[graph_class_name]
+                begin
+                  props = Oj.load(props_json, mode: :strict)
+                  props.merge!({pub_sub_client: pub_sub_client, session_id: session_id, current_user: current_user})
+                  graph = graph_class.load(props)
+                  graph.instance_exec do
+                    graph_class.on_load_block.call(pub_sub_client, session_id, current_user) if graph_class.on_load_block
+                  end
+                  response.deep_merge!(data: graph.to_transport)
+                  response.deep_merge!(data: graph.included_items_to_transport)
+                  result = { success: 'ok' }
+                rescue Exception => e
+                  result = if Isomorfeus.production?
+                             { error: { graph_class_name => 'No such thing!' }}
+                           else
+                             { error: { graph_class_name => "Isomorfeus::Data::Handler::GraphLoadHandler: #{e.message}" }}
+                           end
+                end
+              else
+                result = { error: { graph_class_name => 'No such thing!' }}
+              end
+            else
+              result = { error: { graph_class_name => 'No such thing!' }}
+            end
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/data/handler/hash_load_handler.rb

@@ -0,0 +1,41 @@
+module Isomorfeus
+  module Data
+    module Handler
+      class HashLoadHandler < LucidHandler::Base
+        on_request do |pub_sub_client, session_id, current_user, request, response|
+          result = { error: 'No such thing' }
+          # promise_send_path('Isomorfeus::Data::Handler::HashLoadHandler', self.to_s, props_hash)
+          request.each_key do |hash_class_name|
+            if Isomorfeus.valid_hash_class_name?(hash_class_name)
+              hash_class = Isomorfeus.cached_hash_class(hash_class_name)
+              if hash_class
+                props_json = request[hash_class_name]
+                begin
+                  props = Oj.load(props_json, mode: :strict)
+                  props.merge!({pub_sub_client: pub_sub_client, session_id: session_id, current_user: current_user})
+                  hash = hash_class.load(props)
+                  hash.instance_exec do
+                    hash_class.on_load_block.call(pub_sub_client, session_id, current_user) if hash_class.on_load_block
+                  end
+                  response.deep_merge!(data: hash.to_transport)
+                  result = { success: 'ok' }
+                rescue Exception => e
+                  result = if Isomorfeus.production?
+                             { error: { hash_class_name => 'No such thing!' }}
+                           else
+                             { error: { hash_class_name => "Isomorfeus::Data::Handler::HashLoadHandler: #{e.message}" }}
+                           end
+                end
+              else
+                result = { error: { hash_class_name => 'No such thing!' }}
+              end
+            else
+              result = { error: { hash_class_name => 'No such thing!' }}
+            end
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/data/prop_declaration.rb

@@ -0,0 +1,58 @@
+module Isomorfeus
+  module Data
+    module PropDeclaration
+      # props, very similar to Components:
+      #   prop :text, class: String # a required prop of class String, class must match exactly
+      #   prop :other, is_a: Enumerable # a required prop, which can be a Array for example, but at least must be a Enumerable
+      #   prop :cool, default: 'yet some more text' # a optional prop with a default value
+      #   prop :even_cooler, class: String, required: false
+      def prop(prop_name, options_hash = {})
+        declared_props[prop_name.to_sym] = options_hash
+      end
+
+      def declared_props
+        @declared_props ||= {}
+      end
+
+      def validate_props(props_hash)
+        p = declared_props
+
+        props = Isomorfeus::Data::Props.new(props_hash)
+
+        raise "#{self}: Wrong or to many props given!" if (props.keys - p.keys).size > 0
+
+        # validation
+        p.each_key do |key|
+          # determine if prop is required
+          required = if p[key].key?(:required)
+                       p[key][:required]
+                     elsif p[key].key?(:default)
+                       false
+                     else
+                       true
+                     end
+
+          # assign value
+          value = if props.key?(key)
+                    props[key]
+                  elsif p[key].key?(:default)
+                    props_hash[key] = p[key][:default].dup
+                  else
+                    raise "#{self}: Required prop not given: #{key}!" if required
+                    nil
+                  end
+
+          # check if passed value is of correct type
+          if props_hash.key?(key)
+            if p[key].key?(:class) && value.class != (p[key][:class])
+              raise "#{self}: #{key} value is not of class #{p[key][:class]} but instead a #{value.class}!"
+            end
+            if p[key].key?(:is_a) && !value.is_a?(p[key][:is_a])
+              raise "#{self}: #{key} value is not a #{p[key][:is_a]}!"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/data/props.rb

@@ -0,0 +1,96 @@
+module Isomorfeus
+  module Data
+    class Props
+      def initialize(props_hash)
+        props_hash = {} unless props_hash
+        @props_hash = props_hash
+      end
+
+      def any?
+        @props_hash.keys.size > 0
+      end
+
+      if RUBY_ENGINE == 'opal'
+        def [](prop_name)
+          @props_hash[prop_name]
+        end
+
+        def []=(prop_name, value)
+          @props_hash[prop_name] = value
+        end
+
+        def key?(prop_name)
+          @props_hash.key?(prop_name)
+        end
+
+        def keys
+          @props_hash.keys
+        end
+
+        def method_missing(prop_name, *args, &block)
+          return @props_hash[prop_name] if @props_hash.key?(prop_name)
+          super(prop_name, *args, &block)
+        end
+
+        def set(prop_name, value)
+          @props_hash[prop_name] = value
+        end
+
+        def to_json
+          JSON.dump(to_transport)
+        end
+
+        def to_transport
+          transport_hash = {}.merge(@props_hash)
+          transport_hash
+        end
+      else # RUBY_ENGINE
+        def [](prop_name)
+          name = prop_name.to_sym
+          return @props_hash[name] if @props_hash.key?(name)
+          name = prop_name.to_s
+          return @props_hash[name] if @props_hash.key?(name)
+          nil
+        end
+
+        def []=(prop_name, value)
+          @props_hash[prop_name.to_sym] = value
+        end
+
+        def key?(prop_name)
+          @props_hash.key?(prop_name.to_sym) || @props_hash.key?(prop_name.to_s)
+        end
+
+        def keys
+          @props_hash.keys.map(&:to_sym)
+        end
+
+        def method_missing(prop_name, *args, &block)
+          name = prop_name.to_sym
+          return @props_hash[name] if @props_hash.key?(name)
+          name = prop_name.to_s
+          return @props_hash[name] if @props_hash.key?(name)
+          super(prop_name, *args, &block)
+        end
+
+        def set(prop_name, value)
+          @props_hash[prop_name.to_sym] = value
+        end
+
+        def to_json
+          Oj.dump(to_transport, mode: :strict)
+        end
+
+        def to_transport
+          transport_hash = {}.merge(@props_hash)
+          transport_hash.delete(:pub_sub_client)
+          transport_hash.delete(:session_id)
+          transport_hash.delete(:current_user)
+          transport_hash
+        end
+      end # RUBY_ENGINE
+
+      alias_method :has_key?, :key?
+    end
+  end
+end

data/lib/isomorfeus/data/reducer.rb

@@ -0,0 +1,30 @@
+module Isomorfeus
+  module Data
+    module Reducer
+      def self.add_reducer_to_store
+        data_reducer = Redux.create_reducer do |prev_state, action|
+          action_type = action[:type]
+          if action_type.JS.startsWith('DATA_')
+            case action_type
+            when 'DATA_STATE'
+              if action.key?(:set_state)
+                action[:set_state]
+              else
+                prev_state
+              end
+            when 'DATA_LOAD'
+              prev_state.deep_merge(action[:data])
+            else
+              prev_state
+            end
+          else
+            prev_state
+          end
+        end
+
+        Redux::Store.preloaded_state_merge!(data_state: {})
+        Redux::Store.add_reducer(data_state: data_reducer)
+      end
+    end
+  end
+end

data/lib/isomorfeus/data/version.rb

@@ -0,0 +1,5 @@
+module Isomorfeus
+  module Data
+    VERSION = '1.0.0.delta11'
+  end
+end

data/lib/isomorfeus-data.rb

@@ -0,0 +1,48 @@
+require 'opal'
+require 'opal-autoloader'
+require 'opal-activesupport'
+require 'isomorfeus-redux'
+require 'isomorfeus-transport'
+
+require 'isomorfeus/data/config'
+require 'isomorfeus/data/props'
+require 'isomorfeus/data/prop_declaration'
+require 'lucid_node/mixin'
+require 'lucid_node/base'
+require 'lucid_edge/mixin'
+require 'lucid_edge/base'
+require 'lucid_array/mixin'
+require 'lucid_array/base'
+require 'lucid_collection/mixin'
+require 'lucid_collection/base'
+require 'lucid_graph/mixin'
+require 'lucid_graph/base'
+require 'lucid_hash/mixin'
+require 'lucid_hash/base'
+
+if RUBY_ENGINE == 'opal'
+  require 'isomorfeus/data/core_ext/hash/deep_merge'
+  require 'isomorfeus/data/reducer'
+  Isomorfeus::Data::Reducer.add_reducer_to_store
+  Opal::Autoloader.add_load_path('data')
+else
+  require 'oj'
+  require 'active_support'
+  require 'active_support/core_ext/hash'
+  require 'isomorfeus/data/handler/array_load_handler'
+  require 'isomorfeus/data/handler/collection_load_handler'
+  require 'isomorfeus/data/handler/graph_load_handler'
+  require 'isomorfeus/data/handler/hash_load_handler'
+
+  Opal.append_path(__dir__.untaint) unless Opal.paths.include?(__dir__.untaint)
+
+  require 'active_support/dependencies'
+
+  path = File.expand_path(File.join('isomorfeus', 'data'))
+
+  ActiveSupport::Dependencies.autoload_paths << path
+  # we also need to require them all, so classes are registered accordingly
+  Dir.glob("#{path}/**/*.rb").each do |file|
+    require file
+  end
+end

data/lib/lucid_array/base.rb

@@ -0,0 +1,15 @@
+module LucidArray
+  class Base
+    include LucidArray::Mixin
+
+    if RUBY_ENGINE != 'opal'
+      def self.inherited(base)
+        Isomorfeus.add_valid_array_class(base)
+
+        base.prop :pub_sub_client, default: nil
+        base.prop :session_id, default: nil
+        base.prop :current_user, default: nil
+      end
+    end
+  end
+end