interfacets 0.1.0 → 0.9.99

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a9fc11b77c082c02a9bb6c8defdbf12b12fac9dff56d9009c723a26719e5ffa
-  data.tar.gz: d0ae5775b216ff078d6f730cfe853aacce5bd0784c79929cf07350c78a0e5105
+  metadata.gz: 8e7e08a925c26ef4b7ee1e2aa2bbdcd716388b6f3aaa22f8d5bf9e7a51a76cee
+  data.tar.gz: 222f5f5f8129c913d19ce4f6d6331f820ad643a6198f35f63ce0b9df2743e059
 SHA512:
-  metadata.gz: 7f818487b367acd4514130b7a0426509d6c8aea7c0620407ac95d49673683b5a0e33278064d5cff90cd02964f42a708d3532ebaa5fc9446e082ffa4b1faeb27e
-  data.tar.gz: 3fd3d0db29f724a037eb84f450ed33af68b396346c9933d6492a8c67acb5f9acb372a5fd6b5275f30590394075c7c46b3566812940e432e031b914ba239a8bcb
+  metadata.gz: 68e278e17a2b033f8dc0ee6941f80a76d6ddb6bfeb0d7c79267ed24150d48b6d7e1ff54bda300cb0db5b4caa238632be5efe8b228fa018362482b7d8cea1264a
+  data.tar.gz: 3ca6b351b7089d7e9d99e513a282c937cea531a813a1ebfdfd35a514b2f34f95187f19c63ac57e1a5691c61d111f67f2dbae0b614c490c252a2f76b3dcc5006a

data/.rubocop.yml

@@ -1,8 +1,180 @@
 AllCops:
-  TargetRubyVersion: 3.0
+  NewCops: enable
+  Exclude: [ "bin/*" ]
+
+Layout/EmptyLinesAroundAttributeAccessor:
+  Enabled: false
+
+Layout/MultilineMethodCallBraceLayout:
+  Enabled: true
+  EnforcedStyle: new_line
+
+Layout/MultilineMethodCallIndentation:
+  Enabled: true
+  EnforcedStyle: indented
+
+Layout/MultilineMethodArgumentLineBreaks:
+  Enabled: true
+
+Layout/MultilineMethodParameterLineBreaks:
+  Enabled: true
+
+Layout/FirstMethodArgumentLineBreak:
+  Enabled: true
+
+Layout/FirstMethodParameterLineBreak:
+  Enabled: true
+
+Style/MethodCallWithArgsParentheses:
+  Enabled: true
+
+Layout/ArgumentAlignment:
+  Enabled: true
+  EnforcedStyle: with_fixed_indentation
+
+Lint/UnusedMethodArgument:
+  Enabled: false
+
+Style/NumberedParameters:
+  Enabled: false
+
+Style/OpenStructUse:
+  Enabled: false
+
+Lint/EmptyBlock:
+  Enabled: false
+
+Style/ExponentialNotation:
+  Enabled: false
+
+Layout/MultilineAssignmentLayout:
+  Enabled: true
+  EnforcedStyle: new_line
+
+Layout/ExtraSpacing:
+  Enabled: true
+  AllowForAlignment: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Naming/MethodParameterName:
+  Enabled: false
+
+Naming/PredicateName:
+  Enabled: false
+
+Naming/VariableNumber:
+  EnforcedStyle: snake_case
+
+Security/Eval:
+  Enabled: false
+
+Style/Alias:
+  Enabled: false
+
+Style/BlockDelimiters:
+  Enabled: false
+  EnforcedStyle: semantic
+
+Style/CaseLikeIf:
+  Enabled: false
+
+Style/CombinableLoops:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/EmptyLambdaParameter:
+  Enabled: false
+
+Style/EvenOdd:
+  Enabled: false
+
+
+Style/GuardClause:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/Lambda:
+  Enabled: false
+
+Style/ModuleFunction:
+  Enabled: false
+
+Style/MultilineBlockChain:
+  Enabled: false
+
+Style/MultilineMemoization:
+  Enabled: true
+  EnforcedStyle: braces
+
+Style/ParenthesesAroundCondition:
+  Enabled: true
+  AllowInMultilineConditions: true
+
+Style/RaiseArgs:
+  Enabled: true
+  EnforcedStyle: compact
+
+Style/RedundantParentheses:
+  Enabled: false
+
+Style/RedundantSelf:
+  Enabled: false
 
 Style/StringLiterals:
+  Enabled: true
   EnforcedStyle: double_quotes
 
 Style/StringLiteralsInInterpolation:
+  Enabled: true
   EnforcedStyle: double_quotes
+
+Style/SymbolArray:
+  Enabled: true
+  EnforcedStyle: brackets
+
+Style/TrailingCommaInArguments:
+  Enabled: true
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInArrayLiteral:
+  Enabled: true
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInHashLiteral:
+  Enabled: true
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/WordArray:
+  Enabled: true
+  EnforcedStyle: brackets
+
+Layout/LineLength:
+  Max: 100
+  AllowedPatterns: ['^(\s*#)']
+
+Style/DocumentDynamicEvalDefinition:
+  Enabled: false

data/.tmp

@@ -0,0 +1,5 @@
+import { Test } from 
+
+export const registry = {
+  Test,
+};

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Pete Kinnecom
+
+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/Rakefile

@@ -3,10 +3,12 @@
 require "bundler/gem_tasks"
 require "minitest/test_task"
 
-Minitest::TestTask.create
-
-require "rubocop/rake_task"
-
-RuboCop::RakeTask.new
-
-task default: %i[test rubocop]
+Minitest::TestTask.create do |t|
+  t.warning = false
+  t.test_globs = (
+    Rake::FileList["test/**/test_*.rb", "test/**/*_test.rb"]
+    .exclude("test/fixtures/**/*")
+  )
+end
+
+task default: :test

data/lib/interfacets/client/actor.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    class Actor
+      attr_reader :registry, :facet
+      def initialize(registry:, channels:)
+        @registry = registry
+      end
+
+      def build_facet(name)
+        @facet = registry.build(name)
+      end
+
+      def render
+        facet.render(channels)
+      end
+    end
+  end
+end

data/lib/interfacets/client/assets.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/MissingRespondToMissing
+original_verbose = $VERBOSE
+$VERBOSE = nil
+
+TOP_LEVEL_BINDING = self.binding
+DEFAULT_LOG_LEVEL = ENV.fetch("DEFAULT_LOG_LEVEL", "debug").to_sym
+
+class InterfacetsLogger
+  class << self
+    def main
+      @main ||= new(level: DEFAULT_LOG_LEVEL)
+    end
+  end
+
+  LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    fatal: 4
+  }.freeze
+
+  attr_accessor :level
+  def initialize(level: :info)
+    @level = LEVELS[level] || LEVELS[:info]
+  end
+
+  # Meta-program the logging methods
+  LEVELS.each do |method_name, level_value|
+    define_method(method_name) do |message|
+      puts "#{method_name.to_s.upcase}: #{message}" if level_value >= @level
+    end
+  end
+
+end
+
+$VERBOSE = original_verbose
+
+module Interfacets
+  module Client
+    module Assets
+      class << self
+        attr_reader :loader
+
+        def logger
+          $asset_logger ||= InterfacetsLogger.main
+        end
+
+        def bootstrap(assets)
+          @loader = Loader.new(assets)
+          Assets.logger.debug("bootstrapping")
+
+          assets
+            .fetch("scaffolding")
+            .reject { _1.match(/SecureRandom/) } #total hack, bake this into image
+            .join("\n")
+            .then { TOP_LEVEL_BINDING.eval(_1) }
+
+          Assets.logger.debug("done bootstrapping")
+
+          assets.fetch("fs_map").each_key do |path|
+            Assets.logger.debug("planned load: #{path}")
+            @loader.load_path(path)
+          end
+        end
+      end
+
+      class Loader
+        attr_reader :assets
+        def initialize(assets)
+          @assets = assets
+          @loaded_classes = {}
+          @loaded_paths = {}
+        end
+
+        def path_loaded?(path)
+          @loaded_paths.key?(path)
+        end
+
+        def load_path(path)
+          return if @loaded_paths.key?(path)
+
+          @loaded_paths[path] = true
+
+          Assets.logger.debug("loading: #{path}")
+
+          TOP_LEVEL_BINDING.eval(fs_map.fetch(path), path)
+          Assets.logger.debug("done loading: #{path}")
+        end
+
+        def loaded?(klass)
+          @loaded_classes.key?(klass)
+        end
+
+        def load(klass)
+          return if loaded?(klass)
+
+          @loaded_classes[klass] = true
+
+          return if klass.name.nil?
+
+          return unless const_map.key?(klass.name)
+
+          const_map
+            .fetch(klass.name)
+            .each {
+              Assets.logger.debug("klass caused load: #{_1}")
+              load_path(_1)
+            }
+        end
+
+        private
+
+        def scaffolding
+          @scaffolding ||= assets.fetch("scaffolding")
+        end
+
+        def fs_map
+          @fs_map ||= assets.fetch("fs_map")
+        end
+
+        def const_map
+          @const_map ||= assets.fetch("const_map")
+        end
+      end
+
+      module AutoloadHook
+        def extend_object(o)
+          if Assets.loader.loaded?(self)
+            super
+          else
+            Assets.loader.load(self)
+            send(:extend_object, o)
+          end
+        end
+
+        def inherited(mod)
+          if Assets.loader.loaded?(self)
+            super
+          else
+            Assets.loader.load(self)
+            send(:inherited, mod)
+          end
+        end
+
+        def append_features(mod)
+          if Assets.loader.loaded?(self)
+            super
+          else
+            Assets.loader.load(self)
+            send(:append_features, mod)
+          end
+        end
+
+        # def included(mod)
+          # Assets.logger.debug("included: #{self.name} into #{mod.name}")
+        #   unless Assets.loader.loaded?(self)
+        #     Assets.loader.load(self)
+        #     send(:included, mod)
+        #   else
+        #     super
+        #   end
+        # end
+
+        # def extended(mod)
+          # Assets.logger.debug("extended: #{mod.name}")
+        #   unless Assets.loader.loaded?(self)
+          #   Assets.logger.debug("loaded: #{self}, now extending")
+        #     Assets.loader.load(self)
+        #     send(:extended, mod)
+        #   else
+          #   Assets.logger.debug("already loaded: #{self}, not extending")
+        #     super
+        #   end
+        # end
+
+        # def prepended(mod)
+        #   unless Assets.loader.loaded?(self)
+        #     Assets.loader.load(self)
+        #     send(:prepended, mod)
+        #   else
+        #     super
+        #   end
+        # end
+
+        # don't think this is needed
+        # def const_missing(const_name)
+        #   if Assets.loader.loaded?(self)
+        #     super
+        #   else
+        #     Assets.loader.load(self)
+        #     const_get(const_name)
+        #   end
+        # end
+
+        def method_missing(meth, *a, **p, &)
+          if Assets.loader.loaded?(self)
+            super
+          else
+            Assets.loader.load(self)
+            send(meth, *a, **p, &)
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Style/MissingRespondToMissing

data/lib/interfacets/client/bus.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# This pipes messages through channels. This allows channel authors to intercept
+# and incoming and outgoing messages and dropping/ignoring/updating their own state
+
+module Interfacets
+  module Client
+    class Bus
+      attr_reader(
+        :id,
+        :channels,
+        :channel_index,
+        :registry,
+        :entity,
+        :root_url,
+      )
+
+      def initialize(
+        id:,
+        channels:,
+        root_url:
+      )
+        @id = id
+        @channels = channels
+        @registry = Registry.new
+        @channel_index = channels.map { [_1.id, _1] }.to_h
+        @root_url = root_url
+      end
+
+      def url_for(path)
+        [
+          root_url,
+          path,
+        ]
+          .map { _1.sub(%r{/$}, "").sub(%r{^/}, "") }
+          .join("/")
+      end
+
+      def channel(name)
+        channel_index.fetch(name.to_s)
+      end
+
+      def handle(event)
+        channel_id = event.dig("destination", "channel")
+        raise("unknown event: #{event.inspect}") unless channel_id
+        channel = channel_index.fetch(channel_id)
+
+        channel.handle(
+          entity: @entity,
+          event: event.fetch("payload"),
+          build_entity: ->(name, id) {
+            @entity = registry.build(name, id)
+            channel_index.values.each { _1.prepare(@entity) }
+            @entity
+          }
+        )
+
+        channel_index.values.each { _1.prepare(entity) }
+
+        entity.class.view.new.render(entity:, channels: channel_index)
+
+        {
+          type: "interfacets:bus:render",
+          id: id,
+          payload: (
+            channel_index
+              .map { |name, chann| { id: name, payload: chann.result } }
+          )
+        }
+      end
+    end
+  end
+end

data/lib/interfacets/client/channels/api.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Channels
+      class Api
+        include Channels::Base
+
+        class Builder
+          attr_accessor :request, :entity
+
+          def render(path)
+            raise("only one submission per action") if request
+
+            System.logger.debug("Getting #{path}")
+
+            request_id = SecureRandom.uuid
+
+            self.request = {
+              url: Client::System.current_bus.url_for(path),
+              method: "get",
+            }
+          end
+
+          def submit(meth, nesting: )
+            raise("only one submission per action") if request
+
+            System.logger.debug("submitting #{meth}")
+
+            request_id = SecureRandom.uuid
+
+            self.request = {
+              url: (
+                if entity.respond_to?(:api_path)
+                  Client::System.current_bus.url_for(entity.api_path)
+                end
+              ),
+              method: "put",
+              body: {
+                event: {
+                  id: request_id,
+                  type: "interfacets:api:submit",
+                  payload: (
+                    Shared::Entities::Bus
+                      .new(entity:)
+                      .serialize(
+                        to: "server" ,
+                        action: meth,
+                        nesting:
+                      )
+                  )
+                },
+              },
+            }
+          end
+        end
+
+        type("interfacets:api")
+
+        def prepare(entity)
+          # must persist builder here
+          # probably all channels need to persist their
+          # builder. Because the bus calls "handle" before
+          # the "prepare" call. Perhaps these should be
+          # reversed?
+          @builder ||= Builder.new
+          @builder.entity = entity
+        end
+
+        def builder(stream = "default")
+          @builder
+        end
+
+        def result
+          {
+            streams: {
+              default: @builder.request,
+            },
+          }.tap { @builder.request = nil }
+        end
+
+        def handle(event:, entity:, build_entity:)
+          facet_name = event.fetch("facet")
+          id = event.dig(
+            "payload",
+            "payload",
+            "attributes",
+            "internal_entity_id"
+          )
+
+          entity = build_entity.(facet_name, id)
+
+          Shared::Entities::Bus
+            .new(entity:)
+            .handle(
+              event: event.fetch("payload")
+            )
+        end
+      end
+    end
+  end
+end