syntropy 0.15.1 → 0.17

data/lib/syntropy/applets/builtin/auto_refresh/watch.sse.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# This module implements an SSE (server-sent events) route, that emits a message
+# to the client when a file has been changed. The module is signalled by the
+# running app whenever a file change, when in watch mode (`-w`). This route
+# resides by default at `/.syntropy/auto_refresh/watch.sse`.
+#
+# The complementary client-side party is implemented in a small JS script
+# residing by default at `/.syntropy/auto_refresh/watch.js`.
+
+# Returns a hash holding references to queues for ongoing `watch.sse` requests.
+def watchers
+  @watchers ||= {}
+end
+
+# Signals a file change by pushing to all watcher queues.
+def signal!
+  watchers.each_key { @machine.push(it, true) }
+end
+
+# Handles incoming requests to the `watch.sse` route. Adds a queue to the list
+# of watchers, and waits for the queue to be signalled. In the absence of file
+# change, a timeout occurs after one minute, and the request is terminated.
+def call(req)
+  queue = UM::Queue.new
+  watchers[queue] = true
+
+  req.send_headers('Content-Type' => 'text/event-stream')
+  req.send_chunk("data: \n\n")
+  @machine.timeout(60, Timeout::Error) do
+    @machine.shift(queue)
+    req.send_chunk("data: refresh\n\n")
+  end
+  req.send_chunk("retry: 0\n\n", done: true) rescue nil
+rescue Timeout::Error
+  req.send_chunk("retry: 0\n\n", done: true) rescue nil
+rescue SystemCallError
+  # ignore
+rescue => e
+  @logger&.error(
+    message: 'Unexpected error encountered while serving auto refresh watcher',
+    error: e
+  )
+  req.finish rescue nil
+ensure
+  watchers.delete(queue)
+end
+
+export self

data/lib/syntropy/applets/builtin/debug/debug.css

@@ -0,0 +1,61 @@
+debug-attachment {
+  position: relative;
+  /* display: block; */
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  /* opacity: 0; */
+  width: 100%;
+  height: 100%;
+}
+
+debug-label {
+  display: block;
+  position: absolute;
+  top: -12px;
+  left: 4px;
+  background: rgba(0, 0, 0, 0.8);
+  color: white;
+  padding: 2px 6px;
+  font-size: 11px;
+  font-family: 'Segoe UI', Roboto, monospace;
+  font-weight: 500;
+  border-radius: 3px;
+  display: block;
+  z-index: 1001;
+  cursor: pointer;
+  /* transition: all 0.2s ease; */
+  white-space: nowrap;
+  line-height: 1.2;
+
+  a, a:hover, a:visited {
+    color: white;
+  }
+
+  &:hover {
+    display: block;
+  }
+
+  &.fn {
+    display: block;
+  }
+}
+
+body *:not(script)[data-syntropy-level]:hover {
+  outline: #13630c dotted 2px;
+  outline-offset: 2px;
+
+  /* debug-label {
+    display: block;
+  }   */
+}
+
+body[data-syntropy-level="1"], body *:not(script)[data-syntropy-level="1"] {
+  outline: #2357aa dotted 2px;
+  outline-offset: 2px;
+}
+
+card {
+  display: block;
+}

data/lib/syntropy/applets/builtin/debug/debug.js

@@ -0,0 +1,57 @@
+(() => {
+  const jsURL = import.meta.url;
+  const cssURL = jsURL.replace(/\.js$/, '.css');
+
+  const head = document.querySelector('head');
+  const link = document.createElement('link');
+  link.rel = 'stylesheet';
+  link.type = 'text/css';
+  link.href = cssURL;
+  head.appendChild(link);
+
+
+
+  let lastTarget = undefined;
+  document.querySelectorAll('[data-syntropy-level]').forEach((ele) => {
+    // ele.addEventListener('mouseover', (evt) => {
+    //   if (evt.target != lastTarget) {
+
+    //   }
+    //   console.log(evt)
+    // });
+
+    // ele.addEventListener('mouseout', (evt) => {
+    //   if (evt.target == last)
+    // });
+
+    const parent = ele.parentElement;
+    const attachment = document.createElement('debug-attachment');
+    const tag = ele.tagName;
+    if (tag == 'SCRIPT' || tag == 'HEAD') return;
+  
+    const level = ele.dataset.syntropyLevel;
+    const href = ele.dataset.syntropyLoc;
+    const fn = ele.dataset.syntropyFn;
+
+    let attachToParent = false; //(tag != 'BODY');
+
+    if (level == '1') {
+      const cleanFn = fn.match(/([^\/]+)$/)[0];
+      attachment.innerHTML = `<debug-label class="fn"><a href="${href}">${cleanFn}</a></debug-label>`;
+    }
+    else {
+      attachToParent = true;
+      attachment.innerHTML = `<debug-label><a href="${href}">${tag}</a></debug-label>`;
+    }
+
+    // console.log(tag, attachToParent);
+    if (attachToParent) {
+      parent.style.position = 'relative';
+      parent.prepend(attachment);
+    }
+    else {
+      ele.style.position = 'relative';
+      ele.prepend(attachment);
+    }
+  });
+})()

data/lib/syntropy/applets/builtin/json_api.js

@@ -0,0 +1,28 @@
+class JSONAPI {
+  constructor(url) {
+    this.url = url;
+  }
+
+  async get(q, params = {}) {
+    return await this.#query('get', q, params);
+  }
+
+  async post(q, params = {}) {
+    return await this.#query('post', q, params);
+  }
+
+  async #query(method, q, params = {}) {
+    const url = `${this.url}?q=${q}`;
+    const req = fetch(url, {
+      method: method
+    });
+    const response = await req;
+    if (!response.ok)
+      throw new Error(`Response status: ${response.status}`)
+
+    const result = await response.json();
+    return result.response;
+  }
+}
+
+export default JSONAPI;

data/lib/syntropy/applets/builtin/ping.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+export ->(req) { req.respond('pong') }

data/lib/syntropy/dev_mode.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+TAG_DEBUG_PROC = ->(level, fn, line, col) {
+  {
+    'data-syntropy-level' => level,
+    'data-syntropy-fn'    => fn,
+    'data-syntropy-loc'   => "vscode://file/#{fn}:#{line}:#{col}"
+  }
+}
+
+P2::Compiler.html_debug_attribute_injector = TAG_DEBUG_PROC

data/lib/syntropy/{rpc_api.rb → json_api.rb}

@@ -5,7 +5,7 @@ require 'syntropy/errors'
 require 'json'
 
 module Syntropy
-  class RPCAPI
+  class JSONAPI
     def initialize(env)
       @env = env
     end

data/lib/syntropy/module.rb

@@ -6,15 +6,15 @@ module Syntropy
   # The ModuleLoader class implemenets a module loader. It handles loading of
   # modules, tracking of dependencies between modules, and invalidation of
   # loaded modules (following a change to the module file).
-  # 
+  #
   # A module may implement a route endpoint, a layout template, utility methods,
   # classes, or any other functionality needed by the web app.
-  # 
+  #
   # Modules are Ruby files that can import other modules as dependencies. A
   # module must export a single value, which can be a class, a template, a proc,
   # or any other Ruby object. A module can also export itself by calling `export
   # self`.
-  # 
+  #
   # Modules are referenced relative to the web app's root directory, without the
   # `.rb` extension. For example, for a site residing in `/my_site`, the
   # reference `_lib/foo` will point to a module residing in
@@ -23,7 +23,7 @@ module Syntropy
     attr_reader :modules
 
     # Instantiates a module loader
-    # 
+    #
     # @param env [Hash] environment hash
     # @return [void]
     def initialize(env)
@@ -34,7 +34,7 @@ module Syntropy
     end
 
     # Loads a module (if not already loaded) and returns its export value.
-    # 
+    #
     # @param ref [String] module reference
     # @return [any] export value
     def load(ref)
@@ -46,7 +46,7 @@ module Syntropy
     # underlying file (in order to cause reloading of the module). The module
     # will be removed from the modules map, as well as modules dependending on
     # it.
-    # 
+    #
     # @param fn [String] module filename
     # @return [void]
     def invalidate_fn(fn)
@@ -62,7 +62,7 @@ module Syntropy
     # underlying file (in order to cause reloading of the module). The module
     # will be removed from the modules map, as well as modules dependending on
     # it.
-    # 
+    #
     # @param ref [String] module reference
     # @return [void]
     def invalidate_ref(ref)
@@ -74,7 +74,7 @@ module Syntropy
     end
 
     # Registers reverse dependencies for the given module reference.
-    # 
+    #
     # @param ref [String] module reference
     # @param deps [Array<String>] array of dependencies for the given module
     # @return [void]
@@ -82,14 +82,14 @@ module Syntropy
       deps.each do
         entry = @modules[it]
         next if !entry
-          
+
         entry[:reverse_deps] << ref
       end
     end
 
     # Loads a module and returns a module entry. Any dependencies (using
     # `import`) are loaded as well.
-    # 
+    #
     # @param ref [String] module reference
     # @return [Hash] module entry
     def load_module(ref)
@@ -112,7 +112,7 @@ module Syntropy
 
     # Transforms the given export value. If the value is nil, an exception is
     # raised.
-    # 
+    #
     # @param export_value [any] module's export value
     # @return [any] transformed value
     def transform_module_export_value(export_value)
@@ -132,6 +132,19 @@ module Syntropy
   # The Syntropy::Module class implements a reloadable module. A module is a
   # `.rb` source file that implements a route endpoint, a template, utility
   # methods or any other functionality needed by the web app.
+  #
+  # The following instance variables are available to modules:
+  #
+  # - `@env`: the app environment hash
+  # - `@machine`: a reference to the UringMachine instance
+  # - `@module_loader`: a reference to the module loader
+  # - `@app`: a reference to the app
+  # - `@ref`: the module's logical path (path relative to the app root)
+  # - `@logger`: a reference to the app's logger
+  #
+  # In addition, the module code also has access to the `MODULE` constant which
+  # is set to `self`, and may be used to refer to various methods defined in the
+  # module.
   class Module
     # Loads a module, returning the module instance
     def self.load(env, code, fn)
@@ -148,7 +161,7 @@ module Syntropy
     end
 
     # Initializes a module with the given environment hash.
-    # 
+    #
     # @param env [Hash] environment hash
     # @return [void]
     def initialize(**env)
@@ -157,6 +170,7 @@ module Syntropy
       @module_loader = env[:module_loader]
       @app = env[:app]
       @ref = env[:ref]
+      @logger = env[:logger]
       singleton_class.const_set(:MODULE, self)
     end
 
@@ -165,7 +179,7 @@ module Syntropy
     # Exports the given value. This value will be used as the module's
     # entrypoint. It can be any Ruby value, but for a route module would
     # normally be a proc.
-    # 
+    #
     # @param v [any] export value
     # @return [void]
     def export(v)
@@ -173,7 +187,7 @@ module Syntropy
     end
 
     # Returns the list of module references imported by the module.
-    # 
+    #
     # @return [Array] array of module references
     def __dependencies__
       @__dependencies__ ||= []
@@ -181,7 +195,7 @@ module Syntropy
 
     # Imports the module corresponding to the given reference. The return value
     # is the module's export value.
-    # 
+    #
     # @param ref [String] module reference
     # @return [any] loaded dependency's export value
     def import(ref)
@@ -191,7 +205,7 @@ module Syntropy
     end
 
     # Creates and returns a P2 template created with the given block.
-    # 
+    #
     # @param proc [Proc, nil] template proc or nil
     # @param block [Proc] template block
     # @return [P2::Template] template
@@ -202,8 +216,24 @@ module Syntropy
       P2::Template.new(proc)
     end
 
+    # Creates and returns a P2 XML template created with the given block.
+    #
+    # @param proc [Proc, nil] template proc or nil
+    # @param block [Proc] template block
+    # @return [P2::Template] template
+    def template_xml(proc = nil, &block)
+      proc ||= block
+      raise "No template block/proc given" if !proc
+
+      P2::Template.new(proc, mode: :xml)
+    rescue => e
+      p e
+      p e.backtrace
+      raise
+    end
+
     # Returns a list of pages found at the given ref.
-    # 
+    #
     # @param ref [String] directory reference
     # @return [Array] array of pages found in directory
     def page_list(ref)
@@ -211,7 +241,7 @@ module Syntropy
     end
 
     # Creates and returns a Syntropy app for the given environment.
-    # 
+    #
     # @param env [Hash] environment
     def app(**env)
       Syntropy::App.new(**(@env.merge(env)))

data/lib/syntropy/p2_extensions.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'p2'
+
+P2.extension(
+  'auto_refresh_watch!': ->(loc = '/.syntropy') {
+    script(src: File.join(loc, 'auto_refresh/watch.js'), type: 'module')
+  },
+  'debug_template!': ->(loc = '/.syntropy') {
+    script(src: File.join(loc, 'debug/debug.js'), type: 'module')
+  }
+)

data/lib/syntropy/routing_tree.rb

@@ -55,15 +55,13 @@ module Syntropy
       @dynamic_map = {}
       @env = env
       @root = compute_tree
-      @static_map.freeze
-      @dynamic_map.freeze
     end
 
     # Returns the generated router proc for the routing tree
     #
     # @return [Proc] router proc
     def router_proc
-      @router_proc ||= compile_router_proc
+      @router_proc ||= generate_router_proc
     end
 
     # Computes a "clean" URL path for the given path. Modules and markdown are
@@ -93,6 +91,17 @@ module Syntropy
       fn.sub(/^#{Regexp.escape(@root_dir)}\//, '').sub(/\.[^\.]+$/, '')
     end
 
+    # Mounts the given applet on the routng tree at the given (absolute) mount
+    # path. This method must be called before the router proc is generated.
+    #
+    # @param path [String] absolute mount path for the applet
+    # @param applet [Syntropy::App, Proc] applet
+    # @return [void]
+    def mount_applet(path, applet)
+      path = rel_mount_path(path)
+      mount_applet_on_tree(@root, path, applet)
+    end
+
     private
 
     # Maps extensions to route kind.
@@ -136,6 +145,66 @@ module Syntropy
       compute_route_directory(dir: @root_dir, rel_path: '/', parent: nil)
     end
 
+    # Converts the given absolute path to a relative one (relative to the
+    # routing tree's mount path).
+    #
+    # @param path [String] absolute mount path
+    # @return [String] relative mount path
+    def rel_mount_path(path)
+      if @mount_path == '/'
+        path.sub(/^\//, '')
+      else
+        path.sub(/^#{Regexp.escape(@mount_path)}\//, '')
+      end
+    end
+
+    # Mounts the given applet as a child of the given entry. If the given
+    # (relative) path is nested, drills down the given entry's subtree and
+    # automatically creates intermediate children entries. If a child entry
+    # already exists for the given path, an error is raised. The given applet
+    # may be an instance of `Syntropy::App` or a proc.
+    #
+    # @param entry [Hash] route entry on which to mount the applet
+    # @param path [String] relative path
+    # @param applet [Syntropy::App, Proc] applet
+    # @return [void]
+    def mount_applet_on_tree(entry, path, applet)
+      if (m = path.match(/^([^\/]+)\/(.+)$/))
+        child_entry = find_or_create_child_entry(entry, m[1])
+        mount_applet_on_tree(child_entry, m[2], applet)
+      else
+        child_entry = entry[:children] && entry[:children][path]
+        raise Syntropy::Error, "Could not mount applet, entry already exists" if child_entry
+
+        applet_path = File.join(entry[:path], path)
+        applet_entry = {
+          parent: entry,
+          path: applet_path,
+          handle_subtree: true,
+          target: { kind: :module },
+          proc: applet
+        }
+
+        (entry[:children] ||= {})[path] = applet_entry
+        @dynamic_map[applet_path] = applet_entry
+      end
+    end
+
+    # Finds or creates a child entry with the given name on the given parent
+    # entry.
+    #
+    # @param parent [Hash] parent entry
+    # @param name [String] child's name
+    # @return [Hash] child entry
+    def find_or_create_child_entry(parent, name)
+      parent[:children] ||= {}
+      parent[:children][name] ||= {
+        parent: parent,
+        path: File.join(parent[:path], name),
+        children: {}
+      }
+    end
+
     # Computes a route entry for a directory.
     #
     # @param dir [String] directory path
@@ -341,10 +410,13 @@ module Syntropy
       entry[:param] ? '[]' : File.basename(entry[:path]).gsub(/\+$/, '')
     end
 
-    # Generates and returns a router proc based on the routing tree.
+    # Freezes the static and dynamic maps, generates and returns a router proc
+    # based on the routing tree.
     #
     # @return [Proc] router proc
-    def compile_router_proc
+    def generate_router_proc
+      @static_map.freeze
+      @dynamic_map.freeze
       code = generate_routing_tree_code
       eval(code, binding, '(router)', 1)
     end

data/lib/syntropy/utils.rb

@@ -37,5 +37,16 @@ module Syntropy
     def app(**env)
       Syntropy::App.new(**env)
     end
+
+    BUILTIN_APPLET_ROOT_DIR = File.expand_path(File.join(__dir__, 'applets/builtin'))
+    def builtin_applet(env, mount_path: '/.syntropy')
+      app(
+        machine:    env[:machine],
+        root_dir:   BUILTIN_APPLET_ROOT_DIR,
+        mount_path: mount_path,
+        builtin_applet_path: nil,
+        watch_files: nil
+      )
+    end
   end
 end

data/lib/syntropy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Syntropy
-  VERSION = '0.15.1'
+  VERSION = '0.17'
 end

data/lib/syntropy.rb

@@ -4,7 +4,6 @@ require 'qeweney'
 require 'uringmachine'
 require 'tp2'
 require 'p2'
-require 'papercraft'
 
 require 'syntropy/app'
 require 'syntropy/connection_pool'
@@ -12,8 +11,9 @@ require 'syntropy/errors'
 require 'syntropy/markdown'
 require 'syntropy/module'
 require 'syntropy/request_extensions'
+require 'syntropy/p2_extensions'
 require 'syntropy/routing_tree'
-require 'syntropy/rpc_api'
+require 'syntropy/json_api'
 require 'syntropy/side_run'
 require 'syntropy/utils'
 
@@ -47,7 +47,7 @@ module Syntropy
     "  #{GREEN}ooooo\n"\
     "  #{GREEN} ooo vvv       #{CLEAR}Syntropy - a web framework for Ruby\n"\
     "  #{GREEN}  o vvvvv     #{CLEAR}--------------------------------------\n"\
-    "  #{GREEN}  #{YELLOW}|#{GREEN}  vvv o    #{CLEAR}https://github.com/noteflakes/syntropy\n"\
+    "  #{GREEN}  #{YELLOW}|#{GREEN}  vvv o    #{CLEAR}https://github.com/digital-fabric/syntropy\n"\
     "  #{GREEN} :#{YELLOW}|#{GREEN}:::#{YELLOW}|#{GREEN}::#{YELLOW}|#{GREEN}:\n"\
     "#{YELLOW}+++++++++++++++++++++++++++++++++++++++++++++++++++++++++\e[0m\n\n"
 end

data/syntropy.gemspec

@@ -9,11 +9,11 @@ Gem::Specification.new do |s|
   s.email         = 'sharon@noteflakes.com'
   s.files         = `git ls-files`.split
 
-  s.homepage      = 'https://github.com/noteflakes/syntropy'
+  s.homepage      = 'https://github.com/digital-fabric/syntropy'
   s.metadata      = {
-    'homepage_uri' => 'https://github.com/noteflakes/syntropy',
+    'homepage_uri' => 'https://github.com/digital-fabric/syntropy',
     'documentation_uri' => 'https://www.rubydoc.info/gems/syntropy',
-    'changelog_uri' => 'https://github.com/noteflakes/syntropy/blob/master/CHANGELOG.md'
+    'changelog_uri' => 'https://github.com/digital-fabric/syntropy/blob/master/CHANGELOG.md'
   }
   s.rdoc_options  = ['--title', 'Extralite', '--main', 'README.md']
   s.extra_rdoc_files = ['README.md']
@@ -23,10 +23,9 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'extralite',     '2.13'
   s.add_dependency 'json',          '2.13.2'
-  s.add_dependency 'p2',            '2.8'
-  s.add_dependency 'papercraft',    '1.4'
+  s.add_dependency 'p2',            '2.13'
   s.add_dependency 'qeweney',       '0.22'
-  s.add_dependency 'tp2',           '0.15'
+  s.add_dependency 'tp2',           '0.16'
   s.add_dependency 'uringmachine',  '0.18'
 
   s.add_dependency 'listen',        '3.9.0'

data/test/app/api+.rb

@@ -1,4 +1,4 @@
-class API < Syntropy::RPCAPI
+class API < Syntropy::JSONAPI
   def initialize(env)
     super(env)
     @count = 0

data/test/app/rss.rb

@@ -0,0 +1,3 @@
+export template_xml {
+  link 'foo'
+}