isomorfeus-data 2.5.5 → 22.9.0.rc2

data/lib/isomorfeus_data/lucid_file/mixin.rb

@@ -1,281 +0,0 @@
-module LucidFile
-  module Mixin
-    def self.included(base)
-      base.extend(Isomorfeus::Data::GenericClassApi)
-      base.include(Isomorfeus::Data::GenericInstanceApi)
-      base.include(LucidI18n::Mixin)
-
-      def changed!
-        @_changed = true
-      end
-
-      def to_transport
-        hash = {}
-        hash['revision'] = revision if revision
-        hash['data_uri'] = data_uri
-        result = { @class_name => { @key => hash }}
-        result.deep_merge!(@class_name => { @previous_key => { new_key: @key }}) if @previous_key
-        result
-      end
-
-      if RUBY_ENGINE == 'opal'
-        base.instance_exec do
-          def files_path
-          end
-
-          def files_path=(_)
-          end
-        end
-
-        def initialize(key: nil, content_type: nil, data: nil, data_uri: nil, revision: nil, _loading: false)
-          @key = key.nil? ? SecureRandom.uuid : key.to_s
-          @class_name = self.class.name
-          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
-          _update_paths
-          @_revision = revision ? revision : Redux.fetch_by_path(:data_state, :revision, @class_name, @key)
-          @_changed = false
-          @_reload = false
-          loaded = loaded?
-          @_data_uri_object = nil
-          @_data_uri_string = nil
-          if data_uri
-            self.data_uri = data_uri
-          elsif data
-            self.data = data
-            self.content_type = content_type if content_type
-          else
-            self._data('')
-            self._content_type(content_type) if content_type
-          end
-        end
-
-        def _load_from_store!
-          @_changed = false
-          @_reload = true
-        end
-
-        def _reload
-          return unless @_reload
-          @_reload = false
-          d = Redux.fetch_by_path(*@_store_path)
-          self._data_uri(d) if d
-        end
-
-        def _update_paths
-          @_store_path = [:data_state, @class_name, @key, :data_uri]
-        end
-
-        def content_type
-          _reload
-          return @_data_uri_object.content_type if @_data_uri_object
-          nil
-        end
-
-        def content_type=(c)
-          changed!
-          _content_type(c)
-        end
-
-        def _content_type(c)
-          _reload
-          @_data_uri_string = _format_data_uri(c, @_data_uri_object.data)
-          @_data_uri_object = URI::Data.new(@_data_uri_string)
-          c
-        end
-
-        def data
-          _reload
-          @_data_uri_object.data
-        end
-
-        def data=(d)
-          changed!
-          _data(d)
-        end
-
-        def _data(d)
-          _reload
-          @_data_uri_string = _format_data_uri(self.content_type, d)
-          @_data_uri_object = URI::Data.new(@_data_uri_string)
-          d
-        end
-
-        def data_uri
-          _reload
-          @_data_uri_string
-        end
-
-        def data_uri=(d)
-          changed!
-          _data_uri(d)
-        end
-
-        def _data_uri(d)
-          _reload
-          if d.class == URI::Data
-            @_data_uri_string = _format_data_uri(d.content_type, d.data)
-            @_data_uri_object = d
-          else
-            @_data_uri_string = d
-            @_data_uri_object = URI::Data.new(d)
-          end
-          @_data_uri_string
-        end
-
-        def data_uri_object
-          _reload
-          @_data_uri_object
-        end
-
-        def _format_data_uri(c, d)
-          "data:#{c};base64,#{Base64.encode64(d).chop}"
-        end
-      else # RUBY_ENGINE
-        Isomorfeus.add_valid_file_class(base) unless base == LucidFile::Base
-
-        base.instance_exec do
-          def instance_from_transport(instance_data, _included_items_data)
-            key = instance_data[self.name].keys.first
-            revision = instance_data[self.name][key].key?('revision') ? instance_data[self.name][key]['revision'] : nil
-            data_uri = instance_data[self.name][key].key?('data_uri') ? instance_data[self.name][key]['data_uri'] : nil
-            new(key: key, revision: revision, data_uri: data_uri)
-          end
-
-          def props_from_data(instance_data)
-            key = instance_data[self.name].keys.first
-            revision = instance_data[self.name][key].key?('revision') ? instance_data[self.name][key]['revision'] : nil
-            data_uri = instance_data[self.name][key].key?('data_uri') ? instance_data[self.name][key]['data_uri'] : nil
-            LucidProps.new({ key: key, revision: revision, data_uri: data_uri })
-          end
-
-          def files_path
-            @files_path ||= Isomorfeus.files_path
-          end
-
-          def files_path=(f)
-            @files_path = f
-          end
-
-          def check_and_prepare_path(key:)
-            Isomorfeus.raise_error(message: 'Invalid key (contains ".." or "\\")') if key.include?('..') || key.include?('\\')
-            elements = key.split('/')
-            Isomorfeus.raise_error(message: 'Invalid key (contains more than 2 slashes "/")') if elements.size > 3
-            file = elements.pop
-            if elements.size > 0
-              dir_path = ::File.expand_path(::File.join(files_path, *elements))
-              FileUtils.mkdir_p(dir_path) unless Dir.exist?(dir_path)
-              ::File.join(dir_path, file)
-            else
-              FileUtils.mkdir_p(files_path) unless Dir.exist?(files_path)
-              ::File.join(files_path, file)
-            end
-          end
-
-          execute_create do
-            self.save
-          end
-
-          execute_destroy do |key:|
-            file = check_and_prepare_path(key: key)
-            ::FileUtils.rm_f(file)
-            true
-          end
-
-          execute_load do |key:|
-            file = check_and_prepare_path(key: key)
-            if File.exist?(file)
-              d = ::File.binread(file)
-              instance = self.new(key: key, data: d)
-              instance
-            else
-              nil
-            end
-          end
-
-          execute_save do
-            file = self.class.check_and_prepare_path(key: self.key)
-            ::File.binwrite(file, self.data)
-            self
-          end
-        end
-
-        def initialize(key: nil, content_type: nil, data: nil, data_uri: nil, revision: nil)
-          @key = key.nil? ? SecureRandom.uuid : key.to_s
-          @class_name = self.class.name
-          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
-          @_revision = revision
-          if data_uri
-            self._data_uri(data_uri)
-          else
-            @_data = data
-            @_content_type = content_type
-          end
-          @_changed = false
-        end
-
-        def _unchange!
-          @_changed = false
-        end
-
-        def content_type
-          @_content_type = @_data_uri_object.content_type if !@_content_type && @_data_uri_object
-          @_content_type
-        end
-
-        def content_type=(c)
-          changed!
-          _content_type(c)
-        end
-
-        def _content_type(c)
-          if @_data_uri_string
-            @_data_uri_string = _format_data_uri(c, @_data_uri_object.data)
-            @_data_uri_object = URI::Data.new(@_data_uri_string)
-          end
-          @_content_type = c
-        end
-
-        def data
-          @_data = @_data_uri_object.data if !@_data && @_data_uri_object
-          @_data
-        end
-
-        def data=(d)
-          changed!
-          @_data = d
-        end
-
-        def data_uri
-          _data_uri(_format_data_uri(content_type, @_data)) if !@_data_uri_string && @_data
-          @_data_uri_string
-        end
-
-        def data_uri=(d)
-          changed!
-          _data_uri(d)
-        end
-
-        def _data_uri(d)
-          if d.class == URI::Data
-            d = '' if d.nil?
-            @_data_uri_string = _format_data_uri(d.content_type, d.data)
-            @_data_uri_object = d
-          else
-            @_data_uri_string = d
-            @_data_uri_object = URI::Data.new(d)
-          end
-          @_data_uri_string
-        end
-
-        def data_uri_object
-          _data_uri(@_data) if !@_data_uri_object && @_data
-          @_data_uri_object
-        end
-
-        def _format_data_uri(c, d)
-          "data:#{c};base64,#{Base64.encode64(d).chop}"
-        end
-      end # RUBY_ENGINE
-    end
-  end
-end

data/lib/isomorfeus_data/lucid_object/base.rb

@@ -1,10 +0,0 @@
-module LucidObject
-  class Base
-    def self.inherited(base)
-      base.include LucidObject::Mixin
-      if RUBY_ENGINE != 'opal'
-        Isomorfeus.add_valid_data_class(base)
-      end
-    end
-  end
-end

data/lib/isomorfeus_data/lucid_object/mixin.rb

@@ -1,250 +0,0 @@
-module LucidObject
-  module Mixin
-    def self.included(base)
-      base.include(Isomorfeus::Data::FieldSupport)
-      base.extend(Isomorfeus::Data::GenericClassApi)
-      base.include(Isomorfeus::Data::GenericInstanceApi)
-      base.include(LucidI18n::Mixin)
-
-      base.instance_exec do
-        def escape_string(s)
-          s.gsub(/([\\\&\:\(\)\[\]\{\}\!\"\~\^\|\<\>\=\*\?\+\-\s])/, '\\\\\1')
-        end
-      end
-
-      def [](name)
-        send(name)
-      end
-
-      def []=(name, val)
-        send("#{name}=".to_sym, val)
-      end
-
-      def changed!
-        @_changed = true
-      end
-
-      def to_transport
-        hash = { 'fields' => _get_selected_fields }
-        hash['revision'] = revision if revision
-        result = { @class_name => { @key => hash }}
-        result.deep_merge!(@class_name => { @previous_key => { new_key: @key }}) if @previous_key
-        result
-      end
-
-      def included_items_to_transport
-        f = fields
-        data_hash = {}
-        self.class.field_types.each do |field, type|
-          if type == :object
-            v = f[field]
-            if v
-              if v.is_a?(LucidObject::Mixin)
-                data_hash.deep_merge!(v.to_transport)
-                data_hash.deep_merge!(v.included_items_to_transport) if v.respond_to?(:included_items_to_transport)
-              elsif v.is_a?(Array)
-                v.each do |e|
-                  if e
-                    data_hash.deep_merge!(e.to_transport)
-                    data_hash.deep_merge!(e.included_items_to_transport) if e.respond_to?(:included_items_to_transport)
-                  end
-                end
-              end
-            end
-          end
-        end
-        data_hash
-      end
-
-      if RUBY_ENGINE == 'opal'
-        def initialize(key: nil, revision: nil, fields: nil, _loading: false, attributes: nil)
-          @key = key.nil? ? SecureRandom.uuid : key.to_s
-          @class_name = self.class.name
-          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
-          _update_paths
-          @_revision = revision ? revision : Redux.fetch_by_path(:data_state, :revision, @class_name, @key)
-          @_objects = {}
-          @_changed = false
-          loaded = loaded?
-          fields = attributes if attributes
-          if loaded
-            raw_fields = Redux.fetch_by_path(*@_store_path)
-            if `raw_fields === null`
-              if fields
-                _validate_fields(fields)
-                @_changed_fields = fields
-              else
-                @_changed_fields = {}
-              end
-            elsif raw_fields && fields && ::Hash.new(raw_fields) != fields
-              _validate_fields(fields)
-              @_changed_fields = fields
-            else
-              @_changed_fields = {}
-            end
-          else
-            fields = {} unless fields
-            _validate_fields(fields) unless _loading
-            @_changed_fields = fields
-          end
-        end
-
-        def _load_from_store!
-          @_changed_fields = {}
-          @_objects = {}
-          @_changed = false
-        end
-
-        def _update_paths
-          @_store_path = [:data_state, @class_name, @key, :fields]
-        end
-
-        def each(&block)
-          fields.each(&block)
-        end
-      else # RUBY_ENGINE
-        Isomorfeus.add_valid_data_class(base) unless base == LucidObject::Base
-
-        base.instance_exec do
-          def _instance_from_transport_sid(sid, included_items_data, _already_loaded)
-            o_class_name = sid[0]
-            raise "invalid data class #{o_class_name}" unless Isomorfeus.valid_data_class_name?(o_class_name)
-            o_class = Isomorfeus.cached_data_class(o_class_name)
-            o_data = { o_class_name => { sid[1] => included_items_data[o_class_name][sid[1]] }}
-            o_class.instance_from_transport(o_data, included_items_data, _already_loaded)
-          end
-
-          def instance_from_transport(instance_data, included_items_data, _already_loaded = {})
-            key = instance_data[self.name].keys.first
-            ref_s = gen_ref_s(key)
-            return _already_loaded[ref_s] if _already_loaded.key?(ref_s)
-            revision = instance_data[self.name][key].key?('revision') ? instance_data[self.name][key]['revision'] : nil
-            data_obj = new(key: key, revision: revision)
-            _already_loaded[ref_s] = data_obj
-            fields = instance_data[self.name][key].key?('fields') ? instance_data[self.name][key]['fields'].transform_keys(&:to_sym) : nil
-            if fields
-              field_types.each do |field, type|
-                if type == :object
-                  sid_or_array = fields[field]
-                  if sid_or_array&.any?
-                    if sid_or_array[0].is_a? String
-                      fields[field] = _instance_from_transport_sid(sid_or_array, included_items_data, _already_loaded)
-                    elsif sid_or_array[0].is_a? Array
-                      v = sid_or_array.map { |e_sid| _instance_from_transport_sid(e_sid, included_items_data, _already_loaded) }
-                      v.compact!
-                      fields[field] = v
-                    end
-                  end
-                end
-              end
-            end
-            data_obj._validate_fields(fields)
-            data_obj.fields.merge!(fields)
-            data_obj
-          end
-
-          def props_from_data(instance_data)
-            key = instance_data[self.name].keys.first
-            revision = instance_data[self.name][key].key?('revision') ? instance_data[self.name][key]['revision'] : nil
-            fields = instance_data[self.name][key].key?('fields') ? instance_data[self.name][key]['fields'].transform_keys!(&:to_sym) : nil
-            LucidProps.new({ key: key, revision: revision }.merge!(fields))
-          end
-
-          def object_accelerator
-            @object_accelerator ||= Isomorfeus::Data::ObjectAccelerator.new(self)
-          end
-
-          def each(&block)
-            if block_given?
-              self.object_accelerator.each do |fields|
-                block.call self.new(key: fields.delete(:key), fields: fields)
-              end
-            else
-              Enumerator.new do |yielder|
-                self.object_accelerator.each do |fields|
-                  yielder << self.new(key: fields.delete(:key), fields: fields)
-                end
-              end
-            end
-          end
-          alias to_enum each
-
-          def search(field = nil, val = nil, options = {}, query: nil)
-            if field && !self.field_options[field]&.fetch(:index) == :yes
-              raise "Can only search indexed #{self.field_types{field}}s, but #{self.field_types{field}} :#{field} is not indexed!"
-            end
-            objs = []
-            query = query ? query : "#{field}:#{val}"
-            self.object_accelerator.search_each(query, options) do |id|
-              fields = self.object_accelerator.load_object(id: id)
-              objs << self.new(key: fields.delete(:key), fields: fields)
-            end
-            objs
-          end
-
-          execute_create do |_already_saved: {}|
-            self.key = SecureRandom.uuid unless self.key
-            unless _already_saved.key?(self.ref_s)
-              _already_saved[self.ref_s] = self
-              self.class.object_accelerator.create_object(self.key, fields, _already_saved)
-            end
-            self
-          end
-
-          execute_destroy do |key:|
-            self.object_accelerator.destroy_object(key.to_s)
-            true
-          end
-
-          execute_load do |key:, _already_loaded: {}|
-            ref_s = self.gen_ref_s(@key)
-            if _already_loaded.key?(ref_s)
-              _already_loaded[ref_s]
-            else
-              _already_loaded[ref_s] = true
-              fields = self.object_accelerator.load_object(key: key.to_s, already_loaded: _already_loaded)
-              obj = fields ? self.new(key: fields.delete(:key), fields: fields) : nil
-              _already_loaded[ref_s] = obj
-            end
-          end
-
-          execute_save do |_already_saved: {}|
-            self.key = SecureRandom.uuid unless self.key
-            unless _already_saved.key?(self.ref_s)
-              _already_saved[self.ref_s] = true
-              self.class.object_accelerator.save_object(self.key, fields, _already_saved)
-            end
-            self
-          end
-        end
-
-        def initialize(key: nil, revision: nil, fields: nil, attributes: nil)
-          @key = key.nil? ? SecureRandom.uuid : key.to_s
-          @class_name = self.class.name
-          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
-          @_revision = revision
-          @_changed = false
-          fields = attributes if attributes
-          fields = {} unless fields
-          _validate_fields(fields) if fields
-          @_raw_fields = fields
-        end
-
-        def _unchange!
-          @_changed = false
-        end
-
-        def each(&block)
-          @_raw_fields.each(&block)
-        end
-
-        def reload
-          new_instance = self.class.load(key: @key)
-          @_raw_fields = new_instance.fields
-          _unchange!
-          self
-        end
-      end # RUBY_ENGINE
-    end
-  end
-end

data/lib/isomorfeus_data/lucid_query/base.rb

@@ -1,10 +0,0 @@
-module LucidQuery
-  class Base
-    def self.inherited(base)
-      base.include LucidQuery::Mixin
-      if RUBY_ENGINE != 'opal'
-        Isomorfeus.add_valid_data_class(base)
-      end
-    end
-  end
-end

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