syntropy 0.12 → 0.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 18d6c37aa12dcf2315d95bc656d1cbf196ada1dd0e2309b0f1bf1ca8b65a1cbb
-  data.tar.gz: 04f12a324d704814f45d9218e6e02d0d38469dbed753dc8202009568f447d400
+  metadata.gz: dad58d19dc755d1a8ea6adb32cd7146b2228b5ace655a01b2e7932fd8abb7d23
+  data.tar.gz: 228678e0a76e67b012e52c89f5ed90c3d08e884a6424c0c51fcf9f840b2e6876
 SHA512:
-  metadata.gz: c62d9b26c9754c23bfc53dd25c1d698733e1d01b703d580db17cfeed1505c36f3f382fcd762ef0e91e641505cda26af03a328e549a840f9f7af4b2ab7c582bc0
-  data.tar.gz: 0577b8d2fda40cb40c81419c31c7f515230f7948ab49158a7ca2d647fe71a323d51b176003d976b1e5428fe4ead6415064321340c0e20b5c84806d1e52266ce0
+  metadata.gz: 5ea7c453ae3e32d17f4bc35204fcf4c29f4eae7d95e9232f56b6ff65dcfaab9f3f6e41fb5562817ab3d3bd10a3ee2e5c92c440045bbdc8a51bc88d155fac7ab4
+  data.tar.gz: fb28a9011ea58505b9923589b62f0010eb97dea9f1df81e4c0483682669715c455fff5a150888f06f117e127497a98e7c93535f683d924e86ffcfeb007cf9fc5

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 0.13 2025-08-28
+
+- Reimplement module loading
+- Refactor RoutingTree
+
 # 0.12 2025-08-28
 
 - Add routing info to request: `#route`, `#route_params`

data/TODO.md

@@ -1,3 +1,8 @@
+- [ ] Improve serving of static files:
+  - [ ] support for compression
+  - [ ] support for caching headers
+  - [ ] add `Request#render_static_file(route, fn)
+
 ## Support for applets
 
 - can be implemented as separate gems

data/lib/syntropy/app.rb

@@ -23,10 +23,10 @@ module Syntropy
 
       # for apps with a _site.rb file
       def site_file_app(opts)
-        site_fn = File.join(opts[:root_dir], '_site.rb')
-        return nil if !File.file?(site_fn)
+        fn = File.join(opts[:root_dir], '_site.rb')
+        return nil if !File.file?(fn)
 
-        loader = Syntropy::ModuleLoader.new(opts[:root_dir], opts)
+        loader = Syntropy::ModuleLoader.new(opts)
         loader.load('_site')
       end
 
@@ -37,13 +37,14 @@ module Syntropy
     end
 
     attr_reader :module_loader, :routing_tree, :root_dir, :mount_path, :opts
-    def initialize(root_dir:, mount_path:, **opts)
+    
+    def initialize(**opts)
       @machine = opts[:machine]
-      @root_dir = root_dir
-      @mount_path = mount_path
+      @root_dir = opts[:root_dir]
+      @mount_path = opts[:mount_path]
       @opts = opts
 
-      @module_loader = Syntropy::ModuleLoader.new(@root_dir, opts)
+      @module_loader = Syntropy::ModuleLoader.new(app: self, **opts)
       setup_routing_tree
       start_app
     end
@@ -69,6 +70,8 @@ module Syntropy
       proc = route[:proc] ||= compute_route_proc(route)
       proc.(req)
     rescue StandardError => e
+      # p e
+      # p e.backtrace
       error_handler = get_error_handler(route)
       error_handler.(req, e)
     end

data/lib/syntropy/module.rb

@@ -4,8 +4,8 @@ require 'p2'
 
 module Syntropy
   class ModuleLoader
-    def initialize(root, env)
-      @root = root
+    def initialize(env)
+      @root_dir = env[:root_dir]
       @env = env
       @loaded = {} # maps ref to code
       @fn_map = {} # maps filename to ref
@@ -26,27 +26,20 @@ module Syntropy
     private
 
     def load_module(ref)
-      fn = File.expand_path(File.join(@root, "#{ref}.rb"))
+      fn = File.expand_path(File.join(@root_dir, "#{ref}.rb"))
       @fn_map[fn] = ref
-      raise "File not found #{fn}" if !File.file?(fn)
-
-      mod_body = IO.read(fn)
-      mod_ctx = Class.new(Syntropy::Module)
-      mod_ctx.prepare(loader: self, env: @env, ref: ref)
-      mod_ctx.module_eval(mod_body, fn, 1)
+      raise Syntropy::Error, "File not found #{fn}" if !File.file?(fn)
 
-      export_value = mod_ctx.__export_value__
-      wrap_module(mod_ctx, export_value)
+      code = IO.read(fn)
+      env = @env.merge(module_loader: self, ref: ref)
+      export_value = Syntropy::Module.load(env, code)
+      transform_module_export_value(export_value)
     end
 
-    def wrap_module(mod_ctx, export_value)
+    def transform_module_export_value(export_value)
       case export_value
       when nil
-        raise 'No export found'
-      when Symbol
-        o = mod_ctx.new(@env)
-        # TODO: verify export_value denotes a valid method
-        ->(req) { o.send(export_value, req) }
+        raise Syntropy::Error, 'No export found'
       when String
         ->(req) { req.respond(export_value) }
       when Class
@@ -58,74 +51,44 @@ module Syntropy
   end
 
   class Module
-    def initialize(env)
-      @env = env
+    def self.load(env, code)
+      m = new(**env)
+      m.instance_eval(code)
+      m.__export_value__
     end
 
-    class << self
-      def prepare(loader:, env:, ref:)
-        @loader = loader
-        @env = env
-        @machine = env[:machine]
-        @ref = ref
-        const_set(:MODULE, self)
-      end
-
-      attr_reader :__export_value__
-
-      def import(ref)
-        @loader.load(ref)
-      end
-
-      def export(ref)
-        @__export_value__ = ref
-      end
+    attr_reader 
+    def initialize(**env)
+      @env = env
+      @machine = env[:machine]
+      @module_loader = env[:module_loader]
+      @app = env[:app]
+      @ref = env[:ref]
+      singleton_class.const_set(:MODULE, self)
+    end
+      
+    attr_reader :__export_value__
+    def export(v)
+      @__export_value__ = v
+    end
 
-      def template(proc = nil, &block)
-        proc ||= block
-        raise "No template block/proc given" if !proc
+    def import(ref)
+      @module_loader.load(ref)
+    end
 
-        P2::Template.new(proc)
-      end
-      alias_method :html, :template
-
-      def route_by_host(map = nil)
-        root = @env[:root_dir]
-        sites = Dir[File.join(root, '*')]
-                .reject { File.basename(it) =~ /^_/ }
-                .select { File.directory?(it) }
-                .each_with_object({}) { |fn, h|
-                  name = File.basename(fn)
-                  opts = @env.merge(root_dir: fn)
-                  h[name] = Syntropy::App.new(**opts)
-                }
-
-        map&.each do |k, v|
-          sites[k] = sites[v]
-        end
-
-        lambda { |req|
-          site = sites[req.host]
-          site ? site.call(req) : req.respond(nil, ':status' => Status::BAD_REQUEST)
-        }
-      end
+    def template(proc = nil, &block)
+      proc ||= block
+      raise "No template block/proc given" if !proc
 
-      def page_list(ref)
-        full_path = File.join(@env[:root_dir], ref)
-        raise 'Not a directory' if !File.directory?(full_path)
+      P2::Template.new(proc)
+    end
 
-        Dir[File.join(full_path, '*.md')].sort.map {
-          atts, markdown = Syntropy.parse_markdown_file(it, @env)
-          { atts:, markdown: }
-        }
-      end
+    def page_list(ref)
+      Syntropy.page_list(@env, ref)
+    end
 
-      def app(root_dir = nil, mount_path = nil)
-        root_dir ||= @env[:root_dir]
-        mount_path ||= @env[:mount_path]
-        opts = @env.merge(root_dir:, mount_path:)
-        Syntropy::App.new(**opts)
-      end
+    def app(**env)
+      Syntropy::App.new(**(@env.merge(env)))
     end
   end
 end

data/lib/syntropy/routing_tree.rb

@@ -149,8 +149,13 @@ module Syntropy
     #
     # The routing tree is complemented with two maps:
     #
-    # - `static_map` - maps URL paths to the corresponding static route entries.
-    # - `dynamic_map` - maps URL paths to the corresponding dynamic route entries.
+    # - `static_map` - maps URL paths to the corresponding static route entries,
+    #   which includes all non-parametric routes, as well as all static files.
+    # - `dynamic_map` - maps URL paths to the corresponding parametric route
+    #   entries.
+    #
+    # The reason we use two separate maps is to prevent accidentally hitting a
+    # false lookup for a a URL with segments containing square brackets!
     #
     # @return [Hash] root entry
     def compute_tree
@@ -165,9 +170,9 @@ module Syntropy
     def compute_route_directory(dir:, rel_path:, parent: nil)
       param = (m = File.basename(dir).match(/^\[(.+)\]$/)) ? m[1] : nil
       entry = {
-        parent:     parent,
+        parent:,
         path:       rel_path_to_abs_path(rel_path),
-        param:      param,
+        param:,
         hook:       find_aux_module_entry(dir, '_hook.rb'),
         error:      find_aux_module_entry(dir, '_error.rb')
       }
@@ -185,7 +190,7 @@ module Syntropy
     # @return [String, nil] file path if found
     def find_aux_module_entry(dir, name)
       fn = File.join(dir, name)
-      File.file?(fn) ? ({ kind: :module, fn: fn }) : nil
+      File.file?(fn) ? ({ kind: :module,  fn: }) : nil
     end
 
     # Returns a hash mapping file/dir names to route entries.
@@ -223,76 +228,51 @@ module Syntropy
     # @return [void]
     def compute_route_file(fn:, rel_path:, parent:)
       abs_path = rel_path_to_abs_path(rel_path)
-      case
+
       # index.rb, index+.rb, index.md
+      case
       when (m = fn.match(/\/index(\+)?(\.(?:rb|md))$/))
-        # Index files (modules or markdown) files) are applied as targets to the
-        # immediate containing directory. A + suffix indicates this route
-        # handles requests to its subtree
-        plus, ext = m[1..2]
-        kind = FILE_TYPE[ext]
-        handle_subtree = (plus == '+') && (kind == :module)
-        set_index_route_target(parent:, path: abs_path, kind:, fn:, handle_subtree:)
-
+        make_index_module_route(m:, parent:, path: abs_path, fn:)
+        
       # index.html
       when fn.match(/\/index\.html$/)
-        # HTML index files are applied as targets to the immediate containing
-        # directory. It is considered static and therefore not added to the
-        # routing tree.
         set_index_route_target(parent:, path: abs_path, kind: :static, fn:)
 
       # foo.rb, foo+.rb, foo.md, [foo].rb, [foo]+.rb
       when (m = fn.match(/\/(\[)?([^\]\/\+]+)(\])?(\+)?(\.(?:rb|md))$/))
-        # Module and markdown route targets. A + suffix indicates the module
-        # also handles requests to the subtree. For example, `/foo/bar.rb` will
-        # handle requests to `/foo/bar`, but `/foo/bar+.rb` will also handle
-        # requests to `/foo/bar/baz/bug`.
-        #
-        # parametric, or wildcard, routes convert segments of the URL path into
-        # parameters that are added to the HTTP request. Parametric routes are
-        # denoted using square brackets around the file/directory name. For
-        # example, `/api/posts/[id].rb`` will handle requests to
-        # `/api/posts/42`, and will extract the parameter `posts => 42` to add
-        # to the incoming request.
-        #
-        # A + suffix indicates the module also handles the subtree, so e.g.
-        # `/api/posts/[id]+.rb` will also handle requests to
-        # `/api/posts/42/fans` etc.
-        ob, param, cb, plus, ext = m[1..5]
-        kind = FILE_TYPE[ext]
-        make_route_entry(
-          parent:,
-          path: abs_path,
-          param: ob && cb ? param : nil,
-          target: make_route_target(kind:, fn:),
-          handle_subtree: (plus == '+') && (kind == :module)
-        )
-
-      # foo.html
-      when (m = fn.match(/\/[^\/]+\.html$/))
-        # HTML files are routed by their clean URL, i.e. without the `.html`
-        # extension. Those are considered as static routes, and do not have
-        # entries in the routing tree. Instead they are stored in the static
-        # map.
-        make_route_entry(
-          parent: parent,
-          path:   abs_path,
-          target: make_route_target(kind: :static, fn:)
-        )
+        make_module_route(m:, parent:, path: abs_path, fn:)
 
       # everything else
       else
         # static files resolved using the static map, and are not added to the
-        # routing tree, which is used for resolving dynamic routes.
-        make_route_entry(
-          parent: parent,
-          path: abs_path,
-          target: { kind: :static, fn: fn }
-        )
+        # routing tree, which is used for resolving dynamic routes. HTML files
+        # are routed by their clean URL, i.e. without the `.html` extension.
+        target = { kind: :static, fn: }
+        make_route_entry(parent:, path: abs_path, target:)
       end
     end
 
-    # Sets an index route target for the given parent entry.
+    # Creates a route entry for an index module (ruby/markdown). Index files
+    # (modules or markdown) files) are applied as targets to the immediate
+    # containing directory. A + suffix indicates this route handles requests to
+    # its subtree
+    # 
+    # @param m [MatchData] path match data
+    # @param parent [Hash] parent route entry
+    # @param path [String] route path
+    # @param fn [String] route target filename
+    # @return [nil] (prevents addition of an index route)
+    def make_index_module_route(m:, parent:, path:, fn:)
+      plus, ext = m[1..2]
+      kind = FILE_TYPE[ext]
+      handle_subtree = (plus == '+') && (kind == :module)
+      set_index_route_target(parent:, path:, kind:, fn:, handle_subtree:)
+    end
+
+
+    # Sets an index route target for the given parent entry. Index files are
+    # applied as targets to the immediate containing directory. HTML index files
+    # are considered static and therefore not added to the routing tree.
     #
     # @param parent [Hash] parent route entry
     # @param path [String] route path
@@ -303,12 +283,12 @@ module Syntropy
     def set_index_route_target(parent:, path:, kind:, fn:, handle_subtree: nil)
       if is_parametric_route?(parent) || handle_subtree
         @dynamic_map[path] = parent
-        parent[:target] = make_route_target(kind:, fn:)
+        parent[:target] = { kind:, fn: }
         parent[:handle_subtree] = handle_subtree
       else
         @static_map[path] = {
           parent: parent[:parent],
-          path: path,
+          path:,
           target: { kind:, fn: },
           # In case we're at the tree root, we need to copy over the hook and
           # error refs.
@@ -319,6 +299,36 @@ module Syntropy
       nil
     end
 
+    # Creates a route entry for normal module and markdown files. A + suffix
+    # indicates the module also handles requests to the subtree. For example,
+    # `/foo/bar.rb` will handle requests to `/foo/bar`, but `/foo/bar+.rb` will
+    # also handle requests to `/foo/bar/baz/bug`.
+    #
+    # parametric, or wildcard, routes convert segments of the URL path into
+    # parameters that are added to the HTTP request. Parametric routes are
+    # denoted using square brackets around the file/directory name. For example,
+    # `/api/posts/[id].rb`` will handle requests to `/api/posts/42`, and will
+    # extract the parameter `posts => 42` to add to the incoming request.
+    #
+    # A + suffix indicates the module also handles the subtree, so e.g.
+    # `/api/posts/[id]+.rb` will also handle requests to `/api/posts/42/fans`
+    # etc.
+    #
+    # @param m [MatchData] path match data
+    # @param parent [Hash] parent route entry
+    # @param path [String] route path
+    # @param fn [String] route target filename
+    # @return [Hash] route entry
+    def make_module_route(m:, parent:, path:, fn:)
+      ob, param, cb, plus, ext = m[1..5]
+      kind = FILE_TYPE[ext]
+      make_route_entry(
+        parent:, path:, param: ob && cb ? param : nil,
+        target: { kind:, fn: },
+        handle_subtree: (plus == '+') && (kind == :module)
+      )
+    end
+
     # Creates a new route entry, registering it in the static or dynamic map,
     # according to its type.
     #
@@ -357,19 +367,6 @@ module Syntropy
       entry[:param] ? '[]' : File.basename(entry[:path]).gsub(/\+$/, '')
     end
 
-    # Returns a hash representing a route target for the given route target kind
-    # and file name.
-    #
-    # @param kind [Symbol] route target kind
-    # @param fn [String] filename
-    # @return [Hash] route target hash
-    def make_route_target(kind:, fn:)
-      {
-        kind: kind,
-        fn: fn
-      }
-    end
-
     # Generates and returns a router proc based on the routing tree.
     #
     # @return [Proc] router proc

data/lib/syntropy/utils.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+ 
+module Syntropy
+  # Utilities for use in modules
+  module Utilities
+    # Returns a request handler that routes request according to 
+    def route_by_host(env, map = nil)
+      root = env[:root_dir]
+      sites = Dir[File.join(root, '*')]
+              .reject { File.basename(it) =~ /^_/ }
+              .select { File.directory?(it) }
+              .each_with_object({}) { |fn, h|
+                name = File.basename(fn)
+                h[name] = Syntropy::App.new(**env.merge(root_dir: fn))
+              }
+
+      # copy over map refs
+      map&.each { |k, v| sites[k] = sites[v] }
+
+      # 
+      lambda { |req|
+        site = sites[req.host]
+        site ? site.call(req) : req.respond(nil, ':status' => Status::BAD_REQUEST)
+      }
+    end
+
+    def page_list(env, ref)
+      full_path = File.join(env[:root_dir], ref)
+      raise 'Not a directory' if !File.directory?(full_path)
+
+      Dir[File.join(full_path, '*.md')].sort.map {
+        atts, markdown = Syntropy.parse_markdown_file(it, env)
+        { atts:, markdown: }
+      }
+    end
+
+    def app(**env)
+      Syntropy::App.new(**env)
+    end    
+  end
+end

data/lib/syntropy/version.rb

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

data/lib/syntropy.rb

@@ -15,10 +15,13 @@ require 'syntropy/request_extensions'
 require 'syntropy/routing_tree'
 require 'syntropy/rpc_api'
 require 'syntropy/side_run'
+require 'syntropy/utils'
 
 module Syntropy
   Status = Qeweney::Status
 
+  extend Utilities
+
   class << self
     attr_accessor :machine
 

data/test/app/_lib/callable.rb

@@ -10,4 +10,4 @@ def bar
   @env[:baz]
 end
 
-export :call
+export self

data/test/app/_lib/env.rb

@@ -0,0 +1,21 @@
+def env
+  @env
+end
+
+def machine
+  @machine
+end
+
+def module_loader
+  @module_loader
+end
+
+def app
+  @app
+end
+
+def module_const
+  MODULE
+end
+
+export MODULE

data/test/app/tmp.rb

@@ -3,4 +3,4 @@
 def call(req)
   req.respond('foo')
 end
-export :call
+export self

data/test/app_multi_site/_site.rb

@@ -1 +1 @@
-export route_by_host
+export Syntropy.route_by_host(@env)

data/test/test_module.rb

@@ -6,8 +6,8 @@ class ModuleTest < Minitest::Test
   def setup
     @machine = UM.new
     @root = File.join(__dir__, 'app')
-    @env = { baz: 42 }
-    @loader = Syntropy::ModuleLoader.new(@root, @env)
+    @env = { root_dir: @root, baz: 42, machine: @machine, app: 42 }
+    @loader = Syntropy::ModuleLoader.new(@env)
   end
 
   def test_module_loading
@@ -15,11 +15,11 @@ class ModuleTest < Minitest::Test
     assert_equal :bar, mod.foo
     assert_equal 42, mod.bar
 
-    assert_raises(RuntimeError) { @loader.load('_lib/foo') }
-    assert_raises(RuntimeError) { @loader.load('_lib/missing-export') }
+    assert_raises(Syntropy::Error) { @loader.load('_lib/missing-module') }
+    assert_raises(Syntropy::Error) { @loader.load('_lib/missing-export') }
 
     mod = @loader.load('_lib/callable')
-    assert_kind_of Proc, mod
+    assert_kind_of Syntropy::Module, mod
     assert_equal 'barbarbar', mod.call(3)
     assert_raises(NoMethodError) { mod.foo(2) }
 
@@ -34,4 +34,14 @@ class ModuleTest < Minitest::Test
     assert_kind_of Syntropy::Module, mod
     assert_equal :bar, mod.foo
   end
+
+  def test_module_env
+    mod = @loader.load('_lib/env')
+
+    assert_equal mod, mod.module_const
+    assert_equal @env.merge(module_loader: @loader, ref: '_lib/env'), mod.env
+    assert_equal @machine, mod.machine
+    assert_equal @loader, mod.module_loader
+    assert_equal 42, mod.app
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: syntropy
 version: !ruby/object:Gem::Version
-  version: '0.12'
+  version: 0.13.1
 platform: ruby
 authors:
 - Sharon Rosner
@@ -215,11 +215,13 @@ files:
 - lib/syntropy/routing_tree.rb
 - lib/syntropy/rpc_api.rb
 - lib/syntropy/side_run.rb
+- lib/syntropy/utils.rb
 - lib/syntropy/version.rb
 - syntropy.gemspec
 - test/app/_hook.rb
 - test/app/_layout/default.rb
 - test/app/_lib/callable.rb
+- test/app/_lib/env.rb
 - test/app/_lib/klass.rb
 - test/app/_lib/missing-export.rb
 - test/app/_lib/self.rb