interfacets 0.1.0 → 0.9.99

data/lib/interfacets/server/assets.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Interfacets
+  module Server
+    module Assets
+      Const =
+        Data.define(:nesting, :type, :name, :parent) do
+          def full_name
+            [nesting.last&.full_name, name].compact.join("::")
+          end
+        end
+
+      class Classifier
+        class Visitor < Prism::Visitor
+          # This class just gathers up all modules and classes defined
+          attr_reader :mods
+          def initialize
+            @stack = []
+            @mods = []
+            super
+          end
+
+          def visit_module_node(node)
+            push_mod(node)
+          end
+
+          def visit_class_node(node)
+            push_mod(node)
+          end
+
+          private
+
+          def push_mod(node)
+            type = node.type == :module_node ? :module : :class
+
+            parent = (
+              if type == :class && node.child_nodes[1]
+                node.child_nodes[1].full_name
+              end
+            )
+
+            const = Const.new(
+              nesting: @stack.dup,
+              name: node.constant_path.full_name,
+              type:,
+              parent:
+            )
+            @stack << const
+            mods << @stack.dup
+            visit_child_nodes(node)
+            @stack.pop
+          end
+        end
+
+        attr_reader :code
+        def initialize(code)
+          @code = code
+        end
+
+        def consts
+          @consts ||= (
+            Prism.parse(code).value.accept(visitor)
+            visitor.mods.map(&:last)
+          )
+        end
+
+        def visitor
+          @visitor ||= Visitor.new
+        end
+      end
+
+      class Serializer
+        attr_reader :paths, :file
+        def initialize(paths:, file: File)
+          @paths = paths
+          @file = file
+        end
+
+        def as_json
+          {
+            fs_map:,
+            const_map:,
+            scaffolding:,
+          }
+        end
+
+        private
+
+        def const_map
+          @const_map ||= (
+            full_map = Hash.new { |h, k| h[k] = [] }
+
+            paths
+              .each { |path|
+                consts_by_path.fetch(path).each { |c| full_map[c.full_name] << path }
+              }
+
+            full_map.transform_values(&:uniq!)
+            full_map
+          )
+        end
+
+        def scaffolding
+          serialized = {}
+          results = []
+
+          consts.each { |const|
+            push_bootstrapper(const, results, serialized)
+          }
+
+          results
+        end
+
+        def push_bootstrapper(const, results, serialized)
+          return if serialized.key?(const.full_name)
+
+          serialized[const.full_name] = true
+
+          const.nesting.each do |nesting_const|
+            push_bootstrapper(nesting_const, results, serialized)
+          end
+
+          parent = (
+            if const.parent
+              resolve_const_name(const.nesting.last&.full_name, const.parent)
+            end
+          )
+
+          if parent.is_a?(Const)
+            push_bootstrapper(parent, results, serialized)
+          end
+
+          parent_name = parent.is_a?(Const) ? parent.full_name : parent
+
+          parent_str = "< #{parent_name}" if parent
+          results << <<~TXT
+            #{const.type} #{const.full_name} #{parent_str}
+              class << self
+                include Interfacets::Client::Assets::AutoloadHook
+              end
+            end
+          TXT
+        end
+
+        def resolve_const_name(nesting, name)
+          full_name = [nesting, name].compact.reject(&:empty?).join("::")
+          return consts_by_name[full_name] if consts_by_name.key?(full_name)
+
+          # maybe a constant that we don't handle loading for (eg, StandardError)
+          return name if nesting.nil? || nesting.empty?
+
+          resolve_const_name(nesting.split("::")[0...-1].join("::"), name)
+        end
+
+        def consts_by_name
+          @consts_by_name ||= consts.group_by(&:full_name).transform_values(&:first)
+        end
+
+        def fs_map
+          @fs_map ||= paths.map { [_1, file.read(_1)] }.to_h
+        end
+
+        def consts
+          @consts ||= consts_by_path.values.flatten
+        end
+
+        def consts_by_path
+          @consts_by_path ||= (
+            fs_map
+              .transform_values { |code| Classifier.new(code).consts }
+          )
+        end
+      end
+
+      GEM_DIRS = [
+        File.expand_path(File.join(__dir__, "../shared")),
+        File.expand_path(File.join(__dir__, "../client")),
+        File.expand_path(File.join(__dir__, "../client.rb")),
+      ].freeze
+
+      class << self
+        def bundle(dirs:, registry:, only_facets: false)
+
+          target_dirs = (
+            if only_facets
+              dirs
+            else
+              GEM_DIRS + dirs
+            end
+          )
+
+          target_dirs
+            .flat_map { paths(_1) }
+            .flatten
+            .map(&:to_s)
+            .then { Serializer.new(paths: _1).as_json }
+        end
+
+        private
+
+        def paths(path)
+          if File.file?(path)
+            [path]
+          else
+            [
+              Dir.glob(File.join(path, "*.rb")),
+              Dir.glob(File.join(path, "**/*.rb")),
+            ].flatten
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/server/basic_router.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Server
+    class BasicRouter
+      class Evaluator
+        attr_reader :bus
+        def initialize(bus:)
+          @bus = bus
+        end
+
+        def call(klass:, id:, query:, resolved_path:)
+          klass.server_entity_class
+            .find_for_basic_routing(id, query:, bus: bus)
+            .tap { _1.entity.api_path = resolved_path }
+        end
+      end
+
+      attr_reader :paths, :bus, :default
+      def initialize(bus:, paths:, default: nil)
+        @bus = bus
+        @paths = paths
+        @default = default
+      end
+
+      def call(url, query: {})
+        path = normalize(url)
+
+        if path.nil? && default
+          klass = klass_for(default)
+          return evaluator.call(klass:, id: nil, query:, resolved_path: default)
+        end
+
+        if normalized_paths.key?(path)
+          klass = klass_for(path)
+
+          evaluator.call(klass:, id: nil, query:, resolved_path: path)
+        else
+          *parts, id = path.split("/")
+          resolved_base_path = parts.join("/")
+
+          if normalized_paths.key?(resolved_base_path)
+            klass = klass_for(resolved_base_path)
+            evaluator.call(klass:, id:, query:, resolved_path: path)
+          elsif default
+            klass = klass_for(default)
+            evaluator.call(klass:, id: nil, query:, resolved_path: default)
+          else
+            raise "unhandled route: #{path}"
+          end
+        end
+      end
+
+      def evaluator
+        @evaluator ||= Evaluator.new(bus:)
+      end
+
+      def klass_for(path)
+        val = normalized_paths.fetch(normalize(path))
+
+        (val.is_a?(String) ? Object.const_get(val) : val)
+      end
+
+      def normalized_paths
+        @normalized_paths ||= (
+          paths
+            .transform_keys { normalize(_1) }
+        )
+      end
+
+      def normalize(path)
+        path
+          &.sub(/^#{bus.root_url}/, "/")
+          &.sub(/^/, "/")
+          &.sub(%r{^/*}, "/")
+        end
+    end
+  end
+end

data/lib/interfacets/server/bus.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Server
+    class Bus
+      attr_reader(
+        :root_url,
+        :asset_paths,
+        :registry,
+      )
+
+      def initialize(root_url:, asset_paths:)
+        @registry = Registry.new
+        @root_url = root_url
+        @asset_paths = asset_paths
+      end
+
+      def client_system_json(only_facets: false)
+        {
+          assets: Assets.bundle(dirs: asset_paths, registry:, only_facets:),
+          root_url:
+        }
+      end
+
+      def build(name:, store:)
+        registry.build(name, store)
+      end
+
+      def handle(name:, id:, event:)
+        registry.load(name, id).handle(event)
+      end
+    end
+  end
+end

data/lib/interfacets/server/config.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Server
+    class Config
+      attr_reader :registry
+      attr_accessor(
+        :mount_point,
+        :host,
+      )
+
+      def initialize(
+        mount_point:,
+        registry:,
+        assets:
+      )
+        @mount_point = mount_point
+        @registry = registry
+        @assets = assets
+      end
+
+      def bundled_assets
+        dirs = @assets.map(&:to_s)
+
+        facets = (
+          @registry
+            .values
+            .map { Object.const_get(_1) }
+        )
+
+        Interfacets::Server::Assets.bundle(dirs:, facets:)
+      end
+
+      def schema
+        @facet_registry
+          .values
+          .map { Object.const_get(_1) }
+          .then {
+            Interfacets::Shared::Facets::Schema::Serializer
+              .call(facets: _1)
+          }
+      end
+
+      def register_facet(name, class_or_class_name)
+        # if klass.name is nil, then just use the class reference
+        @facet_registry[name] = class_or_class_name
+      end
+
+      def all_facets
+        @facet_registry.keys.map { facet(_1) }
+      end
+
+      def default_facet
+        build_facet(facet_uid: @default_facet)
+      end
+
+      def facet(name)
+        klass_name = (
+          if @facet_registry.key?(name)
+            @facet_registry.fetch(name)
+          elsif @facet_registry.values.include?(name)
+            name
+          else
+            raise("unknown facet_class: #{name}")
+          end
+        )
+
+        klass_name.constantize
+      end
+
+      def ingest_facet(data)
+        Facets::Deserializer.call(data:, config: self)
+      end
+
+      def build_facet(facet_uid: nil, name: nil, id: nil, query: {})
+        if name
+          facet(name).build(id, query:)
+        elsif @facet_registry.key?(facet_uid)
+          facet(facet_uid).build(nil, query:)
+        else
+          *name, id = facet_uid.split("/")
+          facet(name.join("/")).build(id, query:)
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/server/facets/deserializer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Server
+    module Facets
+      class Deserializer
+        class << self
+          def call(data:, config:)
+            facet_class_name = data.fetch("facet_class")
+            attributes = data.fetch("attributes")
+
+            facet = (
+              config
+                .facet(facet_class_name)
+                .build(attributes.fetch("id"))
+            )
+
+            facet.entity.ingest(attributes)
+            facet
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/server/facets/schema/serializer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Server
+    module Facets
+      module Schema
+        class Serializer
+          def self.call(...)
+            new(...).call
+          end
+
+          private attr_reader(:facets, :schema)
+          def initialize(facets:)
+            @facets = facets
+            @schema = { views: {}, entities: {}, apis: {} }
+          end
+
+          def call
+            facets.each do |facet|
+              config = facet.client_config
+
+              schema[:views][config.view.name] = {
+                body: write_source(config.view.block),
+              }
+
+              schema[:entities][config.entity.name] = {
+                api_type: config.api.name,
+                body: write_source(config.entity.block),
+              }
+
+              schema[:apis][config.api.name] = {
+                body: write_source(config.api.block),
+              }
+            end
+
+            schema
+          end
+
+          private
+
+          def write_source(block)
+            return unless block
+
+            RubyVM::AbstractSyntaxTree
+              .of(block, keep_script_lines: true)
+              .source
+              .then { block.is_a?(UnboundMethod) ? _1 : "lambda #{_1}" }
+              .strip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/server/facets/serializer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Server
+    module Facets
+      class Serializer
+        def self.call(...)
+          new(...).call
+        end
+
+        attr_reader :facet, :mount_point
+        def initialize(facet, mount_point)
+          @facet = facet
+          @mount_point = mount_point
+        end
+
+        def call
+          {
+            id: facet.entity.id,
+            facet_class: facet.class.name,
+            attributes: facet.entity.serialize,
+          }
+        end
+
+        def attributes(entity)
+          entity
+            .attribute_specs
+            .each_with_object({}) { |(name, _attribute), json|
+              # refactor this, shouldn't be attributes...
+              # next if attribute.is_a?(Facets::Attributes::ClientEvent)
+              # next if attribute.is_a?(Facets::Attributes::ServerEvent)
+              # next if attribute.is_a?(Facets::Attributes::Inherit)
+
+              value = entity.public_send(name)
+
+              json[name] = (
+                if value.is_a?(Array)
+                  value.map { _1.is_a?(Entity) || _1.is_a?(Facet::Handler) ? attributes(_1) : _1 }
+                elsif value.is_a?(Entity) || value.is_a?(Facet::Handler)
+                  attributes(value)
+                else
+                  value
+                end
+              )
+            }
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/server/registry.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "active_support/all"
+require "ostruct"
+
+module Interfacets
+  module Server
+    class Registry
+      class Channel
+        def initialize(registry:)
+          @registry = registry
+        end
+
+        def build(...)
+          @registry.build(...)
+        end
+
+        def render_facet
+          @facet.render
+        end
+
+        def rendered?
+          @facet
+        end
+
+        def render(klass, store)
+          @facet = @registry.build(klass, store)
+        end
+      end
+
+      def build(name, store)
+        facet = name.is_a?(Module) ? name : Object.const_get(name)
+
+        Api.new(
+          registry: self,
+          name:,
+          entity: (
+            facet
+              .server_entity_class
+              .new(
+                store: store.is_a?(Hash) ? OpenStruct.new(store) : store,
+                nesting: "root",
+                parent: nil,
+                channel: Channel.new(registry: self)
+              )
+          )
+        )
+      end
+    end
+  end
+end

data/lib/interfacets/shared/basic_routable.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Shared
+    module BasicRoutable
+      extend ActiveSupport::Concern
+
+      included do
+        class << self
+          attr_accessor :bus
+
+          def build(klass, store)
+            bus.registry.build(klass, store)
+          end
+        end
+
+        # This is unfortunate, but in order to be able to do:
+
+        # build(self, ...)
+        # we need the self to be the facet.
+        # We could also update the registry to handle being passed a server
+        # entity, but I'm currently tweaking the registry. so this is a TODO.
+        facet = self
+
+        entity_base do
+          accessor(:api_path, accepted_by: :client)
+        end
+
+        server_entity(unshift: true) do
+          attr_accessor :api_path
+
+          define_singleton_method(:find) do |&block|
+            @find = block if block
+            @find
+          end
+
+          define_singleton_method(:find_for_basic_routing) do |id, query:, bus:|
+            facet.bus = bus
+            facet.instance_exec(id, query:, &find)
+          end
+        end
+      end
+    end
+  end
+end