isomorfeus-data 2.5.4 → 22.9.0.rc1

data/lib/isomorfeus_data/lucid_query/mixin.rb

@@ -1,112 +0,0 @@
-module LucidQuery
-  module Mixin
-    def self.included(base)
-      base.extend(LucidPropDeclaration::Mixin)
-      base.include(LucidI18n::Mixin)
-
-      if RUBY_ENGINE == 'opal'
-        base.instance_exec do
-          def _generate_auto_key(props_s)
-            component = nil
-            component_name = '_'
-            %x{
-              let c = Opal.Preact.active_component();
-              if (typeof c?.__ruby_instance !== 'undefined') { component = c.__ruby_instance; }
-            }
-            component_name = component.class.name if component
-            "#{component_name}:_:#{self.name}:#{props_s}"
-          end
-
-          def _should_return?(lqri, gak)
-            if on_ssr?
-              lqri.loaded?
-            else on_browser?
-              if Isomorfeus::TopLevel.hydrated
-                if Isomorfeus::TopLevel.first_pass
-                  lqri.loaded?
-                else
-                  lqri.loaded? && !gak
-                end
-              else
-                lqri.loaded? && !gak
-              end
-            end
-          end
-
-          def execute(key: nil, **props)
-            gak = key ? false : true
-            key = _generate_auto_key(`JSON.stringify(props)`) unless key
-
-            lqri = LucidQueryResult.new(key: key)
-            return lqri if _should_return?(lqri, gak)
-            props[:query_result_instance] = lqri
-            promise_execute(key: gak ? nil : key, **props)
-            lqri
-          end
-
-          def promise_execute(key: nil, **props)
-            gak = key ? false : true
-            key = _generate_auto_key(`JSON.stringify(props)`) unless key
-
-            lqri = props.delete(:query_result_instance)
-            lqri = LucidQueryResult.new(key: key) unless lqri
-            return Promise.new.resolve(lqri) if _should_return?(lqri, gak)
-
-            props.each_key do |prop_name|
-              Isomorfeus.raise_error(message: "#{self.to_s} No such query prop declared: '#{prop_name}'!") unless declared_props.key?(prop_name)
-            end
-            props = validated_props(props)
-            props[:key] = lqri.key
-            Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', self.name, :execute, props).then do |agent|
-              agent.process do
-                lqri._load_from_store!
-                Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.full_response[:data])
-                lqri
-              end
-            end
-          end
-
-          def execute_query(_); end
-        end
-      else
-        unless base == LucidQuery::Base
-          Isomorfeus.add_valid_data_class(base)
-        end
-
-        base.instance_exec do
-          def promise_execute(**props)
-            instance = self.execute(**props)
-            result_promise = Promise.new
-            result_promise.resolve(instance)
-            result_promise
-          end
-
-          def execute(**props)
-            key = props.delete(:key)
-            result_set = self.new(**props).instance_exec(&@_query_block)
-            LucidQueryResult.new(key: key, result_set: result_set)
-          end
-
-          def execute_query(&block)
-            @_query_block = block
-          end
-        end
-
-        attr_reader :props
-
-        def initialize(**props_hash)
-          props_hash = self.class.validated_props(props_hash)
-          @props = LucidProps.new(props_hash)
-        end
-
-        def current_user
-          Isomorfeus.current_user
-        end
-
-        def pub_sub_client
-          Isomorfeus.pub_sub_client
-        end
-      end
-    end
-  end
-end

data/lib/isomorfeus_data/lucid_query_result.rb

@@ -1,113 +0,0 @@
-class LucidQueryResult
-  attr_reader :key
-
-  def [](accessor_name)
-    self.send(accessor_name.to_sym)
-  end
-
-  def sid
-    [@class_name, @key]
-  end
-
-  def sid_s
-    "[#{@class_name}|#{@key}]"
-  end
-
-  if RUBY_ENGINE == 'opal'
-    def initialize(key: nil, result_set: nil, _loading: false)
-      @class_name = 'LucidQueryResult'
-      @key = key ? key.to_s : self.object_id.to_s
-      @result_set = result_set
-    end
-
-    def _load_from_store!
-      @result_set = nil
-    end
-
-    def loaded?
-      Redux.fetch_by_path(:data_state, @class_name, @key) ? true : false
-    end
-
-    def key?(k)
-      if @result_set
-        @result_set.key?(k)
-      else
-        stored_results = Redux.fetch_by_path(:data_state, @class_name, @key)
-        return false unless stored_results
-        `Object.hasOwnProperty(stored_results, k)`
-      end
-    end
-    alias has_key? key?
-
-    def method_missing(accessor_name, *args, &block)
-      sid_or_array = if @result_set
-                       @result_set[accessor_name]
-                     else
-                       stored_results = Redux.fetch_by_path(:data_state, @class_name, @key)
-                       stored_results.JS[accessor_name] if stored_results
-                     end
-      return nil unless sid_or_array
-      if stored_results.JS['_is_array_']
-        sid_or_array.map { |sid| Isomorfeus.instance_from_sid(sid) }
-      else
-        Isomorfeus.instance_from_sid(sid_or_array)
-      end
-    end
-  else
-    def initialize(key: nil, result_set: nil)
-      @class_name = 'LucidQueryResult'
-      @key = key ? key.to_s : self.object_id.to_s
-      @result_set = result_set.nil? ? {} : result_set
-      @result_set.transform_keys!(&:to_sym)
-    end
-
-    def loaded?
-      @result_set.any?
-    end
-
-    def key?(k)
-      @result_set.key?(k)
-    end
-    alias has_key? key?
-
-    def method_missing(accessor_name, *args, &block)
-      Isomorfeus.raise_error(message: "#{@class_name}: no such thing '#{accessor_name}' in the results!") unless @result_set.key?(accessor_name)
-      @result_set[accessor_name]
-    end
-
-    def to_transport
-      sids_hash = {}
-      @result_set.each do |key, value_or_array|
-        if value_or_array.class == Array
-          sids_hash[key.to_s] = value_or_array.map(&:sid)
-          sids_hash[:_is_array_] = true
-        else
-          sids_hash[key.to_s] = value_or_array.nil? ? nil : value_or_array.sid
-        end
-      end
-      { @class_name => { @key => sids_hash }}
-    end
-
-    def included_items_to_transport
-      data_hash = {}
-      @result_set.each_value do |value|
-        if value.class == Array
-          value.each do |v|
-            data_hash.deep_merge!(v.to_transport)
-            if v.respond_to?(:included_items_to_transport)
-              data_hash.deep_merge!(v.included_items_to_transport)
-            end
-          end
-        else
-          unless value.nil?
-            data_hash.deep_merge!(value.to_transport)
-            if value.respond_to?(:included_items_to_transport)
-              data_hash.deep_merge!(value.included_items_to_transport)
-            end
-          end
-        end
-      end
-      data_hash
-    end
-  end
-end

data/opal/iso_uri.rb

@@ -1,29 +0,0 @@
-require "uri/common"
-require "uri/generic"
-
-module URI
-  @@schemes = {}
-
-  class InvalidURIError < Exception
-  end
-  
-  def self.parse(url)
-      # scheme://conn_data/path?query#hash
-      match = url.match(%r[(\w+)://([^/]+)([^\?]+)(\?[^\#]+)?(\#.*)?])
-
-      _, scheme, connection_data, path, query, fragment = match.to_a
-
-      connection_data = connection_data.split(/@/)
-      userinfo = connection_data.size > 1 ? connection_data.first : nil
-      host, port = connection_data.last.split(/:/)
-
-      port = port.to_i
-      query = query[1..-1] if query
-
-      registry = opaque = nil
-
-      Generic.new(scheme, userinfo, host, port,
-                  registry, path, opaque, query,
-                  fragment)
-  end
-end

data/opal/uri/common.rb

@@ -1,18 +0,0 @@
-module Kernel
-
-  #
-  # Returns +uri+ converted to a URI object.
-  #
-  def URI(uri)
-    if uri.is_a?(URI::Generic)
-      uri
-    elsif uri = String.try_convert(uri)
-      URI.parse(uri)
-    else
-      raise ArgumentError,
-        "bad argument (expected URI object or URI string)"
-    end
-  end
-  module_function :URI
-end
-

data/opal/uri/generic.rb

@@ -1,47 +0,0 @@
-module URI
-  class Generic
-    attr_reader :scheme, :userinfo, :user, :password, :host, :port, :path,
-      :query, :fragment, :opaque, :registry
-
-    #
-    # An Array of the available components for URI::Generic
-    #
-    COMPONENT = [
-      :scheme,
-      :userinfo, :host, :port, :registry,
-      :path, :opaque,
-      :query,
-      :fragment
-    ]
-
-    def initialize(scheme,
-                   userinfo, host, port, registry,
-                   path, opaque,
-                   query,
-                   fragment,
-                   parser = nil,
-                   arg_check = false)
-      @scheme = scheme
-      @userinfo = userinfo
-      @host = host
-      @port = port
-      @path = path
-      @query = query
-      @fragment = fragment
-      @user, @password = userinfo.split(/:/) if userinfo
-    end
-
-    def ==(other)
-      self.class == other.class &&
-        component_ary == other.component_ary
-    end
-
-    protected
-
-    def component_ary
-      self.class::COMPONENT.collect do |x|
-        self.send(x)
-      end
-    end
-  end
-end