interfacets 0.1.0 → 0.9.9

data/lib/interfacets/server/api.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Server
+    class Api
+      class Channel
+        attr_reader :klass, :store
+
+        def rendered?
+          @rendered
+        end
+
+        def render(klass, store)
+          @rendered = true
+          @klass = klass
+          @store = store
+        end
+      end
+
+      attr_reader :entity, :name, :registry
+      def initialize(entity:, name:, registry:)
+        @entity = entity
+        @name = name
+        @registry = registry
+      end
+
+      def handle(event)
+        channel = Channel.new
+
+        entity.channel = channel
+        Shared::Entities::Bus
+          .new(entity:)
+          .handle(event:)
+
+        if entity.channel.rendered?
+          registry.build(
+            channel.klass,
+            channel.store,
+          ).render
+        else
+          emit("after_#{event.fetch("action")}")
+        end
+      end
+
+      def render
+        emit("after_load")
+      end
+
+      private
+
+      def emit(action)
+        {
+          facet: name,
+          payload: (
+            Shared::Entities::Bus
+              .new(entity:)
+              .serialize(to: "client", action:, nesting: ["root"])
+          )
+        }
+      end
+
+    end
+  end
+end

data/lib/interfacets/server/assets/facet.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Server
+    module Assets
+      class Facet
+        def self.register(klass:, assets:)
+          assets[klass.name] = new(klass).code
+        end
+
+        attr_reader :klass
+        def initialize(klass)
+          @klass = klass
+        end
+
+        def code
+          # nest it all so names resolve
+          *mods, klass_name = klass.name.split("::")
+
+          headers = []
+          footers = []
+
+          current_mod = ""
+          mods.each do |mod_name|
+            current_mod += "::#{mod_name}"
+            type = current_mod.constantize.is_a?(Module) ? :module : :class
+            headers << "#{type} #{mod_name}"
+            footers << "end"
+          end
+
+          headers << "class #{klass_name} < Interfacets::Client::Facet"
+          footers << "end"
+
+          <<~TXT
+            #{headers.join("\n")}
+
+              include Interfacets::Client::Facets::Schema
+
+              view_spec #{write_source(klass.client_config.view.block)}
+
+              entity_spec #{write_source(klass.client_config.api.block)}
+
+              client_spec #{write_source(klass.client_config.entity.block)}
+            #{footers.join("\n")}
+          TXT
+        end
+
+        private
+
+        def write_source(block)
+          return unless block
+
+          RubyVM::AbstractSyntaxTree
+            .of(block, keep_script_lines: true)
+            .source
+            .strip
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/server/assets.rb

@@ -0,0 +1,210 @@
+# 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(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.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
+          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:)
+
+          registry.serialize
+
+          (dirs + GEM_DIRS + [registry.build_dir])
+            .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_routable.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Server
+    module BasicRoutable
+      extend ActiveSupport::Concern
+
+      included do
+        attach(self)
+      end
+
+
+      class_methods do
+        def attach(mod)
+          mod.shared do
+            accessor(:api_path, accepted_by: :client)
+          end
+
+          mod.server do
+            attr_accessor :api_path
+          end
+        end
+
+        def inherited(mod)
+          attach(mod)
+        end
+
+        attr_accessor :bus
+        def find(&block)
+          @find = block if block_given?
+          @find
+        end
+
+        def build(klass, store)
+          bus.registry.build(klass, store)
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/server/basic_router.rb

@@ -0,0 +1,74 @@
+# 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.bus = bus
+          klass
+            .find
+            .call(id, query:)
+            .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: {})
+        if url.nil? && default
+          klass = klass_for(default)
+          evaluator.call(klass:, id: nil, query:, resolved_path: default)
+        end
+
+        path = url.sub(/^#{bus.root_url}/, "/").sub(/^/, "/").sub(%r{^/*}, "/")
+
+        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(path)
+
+        (val.is_a?(String) ? Object.const_get(val) : val)
+      end
+
+      def normalized_paths
+        @normalized_paths ||= (
+          paths
+            .transform_keys { _1.start_with?("/") ? _1 : "/#{_1}" }
+        )
+      end
+    end
+  end
+end

data/lib/interfacets/server/bus.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Server
+    class Bus
+      attr_reader(
+        :root_url,
+        :asset_paths,
+        :registry,
+      )
+
+      def initialize(
+        root_url:,
+        asset_paths:,
+        facets:,
+        build_dir:
+      )
+        @registry = Registry.new(facets:, build_dir:)
+        @root_url = root_url
+        @asset_paths = asset_paths
+      end
+
+      def client_system_json
+        {
+          assets: Assets.bundle(dirs: asset_paths, registry:),
+          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::Server::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/facet.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require "active_support/concern"
+
+module Interfacets
+  module Server
+    module Facet
+      extend ActiveSupport::Concern
+
+      class Actor
+        def initialize(entity:, facet:)
+          @entity = entity
+          @facet = facet
+        end
+      end
+
+      class_methods do
+        def view(&block)
+          views << block
+        end
+
+        def views
+          @views ||= []
+        end
+
+        def client(&block)
+          clients << block
+        end
+
+        def clients
+          @clients ||= []
+        end
+
+        def shared(&block)
+          shareds << block
+        end
+
+        def shareds
+          @shareds ||= []
+        end
+
+        def server(&block)
+          servers << block
+        end
+
+        def servers
+          @servers ||= []
+        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