syntropy 0.38.0 → 0.39.0

data/lib/syntropy/module_loader.rb

@@ -21,7 +21,7 @@ module Syntropy
   # reference `_lib/foo` will point to a module residing in
   # `/my_site/_lib/foo.rb`.
   class ModuleLoader
-    attr_reader :modules
+    attr_reader :modules, :app_root
 
     # Instantiates a module loader
     #
@@ -30,10 +30,14 @@ module Syntropy
     # @return [void]
     def initialize(env, extensions: nil)
       @env = env
+      @machine = env[:machine]
       @app_root = env[:app_root]
       @modules = {} # maps ref to module entry
       @fn_map = {} # maps filename to ref
       @extensions = extensions
+      @loading = Set.new
+      @lock = UM::Mutex.new
+      @lock_holder = nil
     end
 
     # Loads a module (if not already loaded) and returns its export value.
@@ -41,14 +45,16 @@ module Syntropy
     # @param ref [String] module reference
     # @return [any] export value
     def load(ref, raise_on_missing: true)
-      ref = "/#{ref}" if ref !~ /^\//
-      if !(entry = @modules[ref])
-        entry = load_module(ref, raise_on_missing:)
-        return if !entry
-
-        @modules[ref] = entry
+      lock do
+        ref = "/#{ref}" if ref !~ /^\//
+        if !(entry = @modules[ref])
+          entry = load_module(ref, raise_on_missing:)
+          return if !entry
+
+          @modules[ref] = entry
+        end
+        entry[:export_value]
       end
-      entry[:export_value]
     end
 
     # Returns a list of modules found in the given relative path. The module
@@ -70,13 +76,27 @@ module Syntropy
     # @param fn [String] module filename
     # @return [void]
     def invalidate_fn(fn)
-      ref = @fn_map[fn]
-      invalidate_ref(ref) if ref
-      invalidate_collection_modules
+      lock do
+        ref = @fn_map[fn]
+        invalidate_ref(ref) if ref
+        invalidate_collection_modules
+      end
     end
 
     private
 
+    # Synchronizes access to the module loader state
+    def lock
+      return yield if @lock_holder == Fiber.current
+
+      @machine.synchronize(@lock) do
+        @lock_holder = Fiber.current
+        yield
+      ensure
+        @lock_holder = nil
+      end
+    end
+
     # Invalidates a module by its reference, normally following a change to the
     # 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
@@ -131,14 +151,21 @@ module Syntropy
         return
       end
 
+      raise Syntropy::Error, "Circular dependency detected" if @loading.include?(ref)
+      do_load_module(ref, fn, raise_on_missing:)
+    end
+
+    def do_load_module(ref, fn, raise_on_missing:)
+      @loading << ref
       @fn_map[fn] = ref
-      code = IO.read(fn)
+      code = read_file(fn)
       env = @env.merge(module_loader: self, ref: clean_ref(ref))
-      mod = Syntropy::ModuleContext.load(env, code, fn, @extensions)
+      mod = Syntropy::ModuleContext.new(env, code, fn, @extensions)
       add_dependencies(ref, mod.__dependencies__)
       export_value = transform_module_export_value(
         mod.__export_value__, fn, raise_on_missing:
       )
+      @env[:logger]&.info(message: "Loaded module at #{fn}")
 
       {
         fn: fn,
@@ -146,6 +173,19 @@ module Syntropy
         export_value: export_value,
         reverse_deps: []
       }
+    rescue StandardError, SyntaxError => e
+      env[:logger]&.error(message: "Error while loading module at #{fn}", error: e)
+      e.is_a?(SyntaxError) ? handle_syntax_error(fn, e) : (raise e)
+    ensure
+      @loading.delete(ref)
+    end
+
+    def read_file(fn)
+      @machine.open(fn, UM::O_RDONLY) { |fd|
+        buf = +''
+        res = @machine.read(fd, buf, 1 << 20)
+        buf
+      }
     end
 
     # Cleans up a module reference specifier, turning /index into /
@@ -174,6 +214,17 @@ module Syntropy
         export_value
       end
     end
+
+    def handle_syntax_error(fn, e)
+      $stderr.puts("\n#{e.message}") if !Syntropy.test_mode
+      m = e.message.match(/^(.+): syntax/)
+      raise e if !m
+
+      location = m[1]
+      e2 = SyntaxError.new("Syntax errors found in module at #{fn}")
+      e2.set_backtrace([location] + e.backtrace)
+      raise e2
+    end
   end
 
   # The Syntropy::ModuleContext class provides a context for loading a module. A
@@ -193,44 +244,14 @@ module Syntropy
   # is set to `self`, and may be used to refer to various methods defined in the
   # module.
   class ModuleContext
-    # Loads a module, returning the module instance
-    # @param env [Hash] app environment
-    # @param code [String] module source code
-    # @param fn [String] module file name
-    # @param extensions [Module, Array<Module>] extension module(s)
-    # @return [Syntropy::ModuleContext] created module context
-    def self.load(env, code, fn, extensions)
-      mod = new(env)
-      apply_extensions(mod, extensions)
-      mod.instance_eval(code, fn)
-      env[:logger]&.info(message: "Loaded module at #{fn}")
-      mod
-    rescue StandardError, SyntaxError => e
-      env[:logger]&.error(message: "Error while loading module at #{fn}", error: e)
-      e.is_a?(SyntaxError) ? handle_syntax_error(env, e) : (raise e)
-    end
-
-    # Applies the given extension(s) to the given module context.
-    #
-    # @param mod [Syntropy::ModuleContext] module context
-    # @param extensions [Module, Array<Module>] extension module(s)
-    def self.apply_extensions(mod, extensions)
-      case extensions
-      when Array
-        extensions.each { mod.extend(it) }
-      when Module
-        mod.extend(extensions)
-      when nil # return
-      else
-        raise Syntropy::Error, "Invalid module extensions: #{extensions.inspect}"
-      end
-    end
-
     # Initializes a module with the given environment hash.
     #
     # @param env [Hash] environment hash
+    # @param code [String] module source code
+    # @param fn [String] module filename
+    # @param extensions [Array<Module>, Module] 
     # @return [void]
-    def initialize(env)
+    def initialize(env, code, fn, extensions)
       @env = env
       @machine = env[:machine]
       @module_loader = env[:module_loader]
@@ -239,18 +260,13 @@ module Syntropy
       @logger = env[:logger]
       @__dependencies__ = []
       singleton_class.const_set(:MODULE, self)
+
+      apply_extensions(extensions)
+      instance_eval(code, fn)
     end
 
     attr_reader :__export_value__, :__dependencies__
 
-    # 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)
-      Syntropy.page_list(@env, ref)
-    end
-
     # Returns true if the module is a collection module. See also
     # #collection_module!
     #
@@ -342,15 +358,20 @@ module Syntropy
       Syntropy::App.new(**env)
     end
 
-    def handle_syntax_error(env, e)
-      $stderr.puts("\n#{e.message}") if !Syntropy.test_mode
-      m = e.message.match(/^(.+): syntax/)
-      raise e if !m
-
-      location = m[1]
-      e2 = SyntaxError.new("Syntax errors found in module #{env[:ref]}")
-      e2.set_backtrace([location] + e.backtrace)
-      raise e2
+    # Applies the given extension(s) to the given module context.
+    #
+    # @param extensions [Module, Array<Module>] extension module(s)
+    # @return [void]
+    def apply_extensions(extensions)
+      case extensions
+      when Array
+        extensions.each { extend(it) }
+      when Module
+        extend(extensions)
+      when nil # return
+      else
+        raise Syntropy::Error, "Invalid module extensions: #{extensions.inspect}"
+      end
     end
   end
 end

data/lib/syntropy/request/request_info.rb

@@ -228,6 +228,14 @@ module Syntropy
       nil
     end
 
+    # Expands a relative path based on the request's path.
+    #
+    # param rel_path [String]
+    # @return [String]
+    def rel(rel_path)
+      File.expand_path(File.join(path, rel_path))
+    end 
+
     private
 
     # Parses an accept string into an array of accepted MIME types.

data/lib/syntropy/request/response.rb

@@ -23,6 +23,7 @@ module Syntropy
     end
 
     def redirect(url, status = HTTP::FOUND)
+      url = File.expand_path(File.join(path, url)) if url =~ /^\./
       respond(nil, ':status' => status, 'Location' => url)
     end
 

data/lib/syntropy/test.rb

@@ -12,6 +12,14 @@ module Syntropy
     HTTP = Syntropy::HTTP
 
     class << self
+      def global_env=(env)
+        @@global_env = env
+      end
+
+      def global_env
+        @@global_env
+      end
+    
       # Gets/sets app environment for tests
       attr_accessor :env
     end
@@ -22,7 +30,8 @@ module Syntropy
     #
     # @return [Hash] test app environment
     def env
-      self.class.env
+      klass = self.class
+      klass.env || klass.global_env
     end
 
     # Loads and returns a module with the given reference.
@@ -122,7 +131,7 @@ module Syntropy
     #
     # @return [void]
     def setup
-      env = self.class.env
+      env = self.env
       raise 'Environment not set' if !env
 
       Syntropy.load_config(env)

data/lib/syntropy/version.rb

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

data/lib/syntropy.rb

@@ -77,7 +77,8 @@ module Syntropy
 
       loader_env = env.merge(
         app_root: env[:config_root],
-        logger: nil
+        logger: nil,
+        machine: UM.new(size: 8)
       )
       loader = ModuleLoader.new(loader_env)
       if (config = loader.load(env[:mode], raise_on_missing: false))

data/test/fixtures/app/_layout/default.rb

@@ -3,6 +3,6 @@ export template { |**props|
     h1 'Foo'
   }
   content {
-    render_yield(**props)
+    render_children(**props)
   }
 }

data/test/fixtures/app/_layout/kuku.rb

@@ -0,0 +1,8 @@
+export template { |**props|
+  header {
+    h1 'Kuku'
+  }
+  content {
+    render_children(**props)
+  }
+}

data/test/fixtures/app/_lib/circular/a.rb

@@ -0,0 +1,2 @@
+export self
+B = import './b'

data/test/fixtures/app/_lib/circular/b.rb

@@ -0,0 +1,2 @@
+export self
+C = import './c'

data/test/fixtures/app/_lib/circular/c.rb

@@ -0,0 +1,2 @@
+export self
+A = import './a'

data/test/fixtures/app/mod/concurrent.rb

@@ -0,0 +1,9 @@
+export self
+
+@machine.sleep(rand(0.001..0.01))
+
+@env[:concurrent_counter][:count] += 1
+
+def id
+  object_id
+end

data/test/test_app.rb

@@ -100,7 +100,7 @@ class AppTest < Minitest::Test
     assert_equal 'About', req.response_body.chomp
 
     req = @test_harness.request(':method' => 'GET', ':path' => '/test/about/foo')
-    assert_equal '<!DOCTYPE html><html><head><title></title></head><body><p>Hello from Markdown</p></body></html>', req.response_body.gsub(/\n/, '')
+    assert_equal '<!DOCTYPE html><html><head></head><body><p>Hello from Markdown</p></body></html>', req.response_body.gsub(/\n/, '')
 
     req = @test_harness.request(':method' => 'HEAD', ':path' => '/test/about/foo')
     assert_nil req.response_body

data/test/test_caching.rb

@@ -75,7 +75,7 @@ class CachingTest < Minitest::Test
     @adapter.serve_request
     response = read_client_side
 
-    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nCache-Control: max-age=3600\r\nEtag: #{etag}\r\nLast-Modified: #{last_modified}\r\nContent-Type: text/css\r\n\r\n#{size.to_s(16)}\r\n#{content}\r\n0\r\n\r\n"
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nCache-Control: max-age=604800\r\nEtag: #{etag}\r\nLast-Modified: #{last_modified}\r\nContent-Type: text/css\r\n\r\n#{size.to_s(16)}\r\n#{content}\r\n0\r\n\r\n"
     assert_equal expected, response
   end
 
@@ -92,7 +92,7 @@ class CachingTest < Minitest::Test
     @adapter.serve_request
     response = read_client_side
 
-    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nCache-Control: max-age=3600\r\nEtag: #{etag}\r\nLast-Modified: #{last_modified}\r\nContent-Type: text/css\r\n\r\n#{size.to_s(16)}\r\n#{content}\r\n0\r\n\r\n"
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nCache-Control: max-age=604800\r\nEtag: #{etag}\r\nLast-Modified: #{last_modified}\r\nContent-Type: text/css\r\n\r\n#{size.to_s(16)}\r\n#{content}\r\n0\r\n\r\n"
     assert_equal expected, response
 
     # good etag
@@ -118,7 +118,7 @@ class CachingTest < Minitest::Test
     @adapter.serve_request
     response = read_client_side
 
-    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nCache-Control: max-age=3600\r\nEtag: #{etag}\r\nLast-Modified: #{last_modified}\r\nContent-Type: text/css\r\n\r\n#{size.to_s(16)}\r\n#{content}\r\n0\r\n\r\n"
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nCache-Control: max-age=604800\r\nEtag: #{etag}\r\nLast-Modified: #{last_modified}\r\nContent-Type: text/css\r\n\r\n#{size.to_s(16)}\r\n#{content}\r\n0\r\n\r\n"
     assert_equal expected, response
 
     # good etag

data/test/test_markdown.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'securerandom'
+
+class MarkdownParseTest < Minitest::Test
+  def test_markdown_parse_md
+    md = <<~MD
+      ---
+      foo: bar
+      ---
+      foo *bar*
+    MD
+
+    h = {}
+    atts, md2 = Syntropy::Markdown.parse_md(h, md)
+
+    assert_equal h, atts
+    assert_equal({ foo: 'bar' }, atts)
+    assert_equal "foo *bar*\n", md2
+  end
+
+  def test_markdown_parse_file
+    FileUtils.mkdir_p('/tmp/test')
+    name = "2008-06-14-test-#{SecureRandom.hex(8)}"
+    path = "/tmp/test/#{name}.md"
+    IO.write(
+      path,
+      <<~MD
+        ---
+        bar: baz
+        ---
+        bar *baz*
+      MD
+    )
+
+    env = { app_root: '/' }
+    atts, md = Syntropy::Markdown.parse_file(path, env)
+    assert_equal "/tmp/test/#{name}", atts[:url]
+    assert_equal 'baz', atts[:bar]
+    assert_equal "bar *baz*\n", md
+
+    env = { app_root: '/tmp' }
+    atts, md = Syntropy::Markdown.parse_file(path, env)
+    assert_equal "/test/#{name}", atts[:url]
+    assert_equal 'baz', atts[:bar]
+    assert_equal "bar *baz*\n", md
+  end
+end
+
+class MarkdownControllerTest < Minitest::Test
+  HTTP = Syntropy::HTTP
+
+  def setup
+    @machine = UM.new
+    @root = File.join(__dir__, 'fixtures/app')
+    @env = { app_root: @root, machine: @machine }
+    @env[:module_loader] = Syntropy::ModuleLoader.new(@env)
+
+    @controller = nil
+    @test_harness = Syntropy::TestHarness.new(->(req) { @controller.(req) })
+  end
+  
+  def test_markdown_renderer_no_layout
+    md = <<~MD
+      foo *bar*
+    MD
+
+    atts = { foo: 'bar', title: 'Title' }
+
+    @controller = Syntropy::Markdown.make_controller(@env, atts, md)
+    req = @test_harness.request(':method' => 'GET', ':path' => '/')
+
+    assert_equal HTTP::OK, req.response_status
+    assert_equal(
+      "<!DOCTYPE html><html><head><title>Title</title></head><body><p>foo <em>bar</em></p>\n</body></html>",
+      req.response_body
+    )
+  end
+
+  def test_markdown_renderer_with_layout
+    src = <<~MD
+      ---
+      layout: kuku
+      ---
+      ## Bar
+    MD
+
+    atts, md = Syntropy::Markdown.parse_md({}, src)
+    assert_equal 'kuku', atts[:layout]
+
+    @controller = Syntropy::Markdown.make_controller(@env, atts, md)
+    req = @test_harness.request(':method' => 'GET', ':path' => '/')
+
+    assert_equal HTTP::OK, req.response_status
+    assert_equal(
+      "<header><h1>Kuku</h1></header><content><h2 id=\"bar\">Bar</h2>\n</content>",
+      req.response_body
+    )
+  end
+
+  def test_markdown_renderer_with_missing_module_loader
+    src = <<~MD
+      ---
+      layout: kuku
+      ---
+      ## Bar
+    MD
+
+    @env[:module_loader] = nil
+    atts, md = Syntropy::Markdown.parse_md({}, src)
+    assert_equal 'kuku', atts[:layout]
+
+    @controller = Syntropy::Markdown.make_controller(@env, atts, md)
+    assert_raises(Syntropy::Error) {
+      req = @test_harness.request(':method' => 'GET', ':path' => '/')
+    }
+  end
+
+  def test_markdown_renderer_with_invalid_layout
+    src = <<~MD
+      ---
+      layout: nunu
+      ---
+      ## Bar
+    MD
+
+    atts, md = Syntropy::Markdown.parse_md({}, src)
+    assert_equal 'nunu', atts[:layout]
+
+    @controller = Syntropy::Markdown.make_controller(@env, atts, md)
+    assert_raises(Syntropy::Error) {
+      req = @test_harness.request(':method' => 'GET', ':path' => '/')
+    }
+  end
+
+  def test_markdown_renderer_with_code_snipet
+    md = <<~MD
+      foo
+
+      ```ruby
+      foo { bar }
+      ```
+
+      bar
+    MD
+
+    atts = { foo: 'bar' }
+
+    @controller = Syntropy::Markdown.make_controller(@env, atts, md)
+    req = @test_harness.request(':method' => 'GET', ':path' => '/')
+
+    assert_equal HTTP::OK, req.response_status
+    assert_equal(
+      (
+        <<~HTML.chomp
+        <!DOCTYPE html><html><head></head><body><p>foo</p>
+
+        <div class=\"language-ruby highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"n\">foo</span> <span class=\"p\">{</span> <span class=\"n\">bar</span> <span class=\"p\">}</span>
+        </code></pre></div></div>
+
+        <p>bar</p>
+        </body></html>
+        HTML
+      ),
+      req.response_body
+    )
+  end
+
+  def test_markdown_renderer_with_embedded_papercraft_simple
+    md = <<~MD
+      foo
+
+      ```ruby
+      # render: true
+      foo { bar }
+      ```
+
+      bar
+    MD
+
+    atts = { foo: 'bar' }
+
+    @controller = Syntropy::Markdown.make_controller(@env, atts, md)
+    req = @test_harness.request(':method' => 'GET', ':path' => '/')
+
+    assert_equal HTTP::OK, req.response_status
+    assert_equal(
+      (
+        <<~HTML.chomp
+        <!DOCTYPE html><html><head></head><body><p>foo</p>
+
+        <foo><bar></bar></foo>
+        <p>bar</p>
+        </body></html>
+        HTML
+      ),
+      req.response_body
+    )
+  end
+
+  def test_markdown_renderer_with_embedded_papercraft_env
+    md = <<~MD
+      ```ruby
+      # render: true
+      h3 @env[:app_root]
+      ```
+      bar
+    MD
+
+    atts = { foo: 'bar' }
+
+    @controller = Syntropy::Markdown.make_controller(@env, atts, md)
+    req = @test_harness.request(':method' => 'GET', ':path' => '/')
+
+    assert_equal HTTP::OK, req.response_status
+    assert_equal(
+      (
+        <<~HTML.chomp
+        <!DOCTYPE html><html><head></head><body><h3>#{@env[:app_root]}</h3>
+        <p>bar</p>
+        </body></html>
+        HTML
+      ),
+      req.response_body
+    )
+  end
+
+  def test_markdown_renderer_with_embedded_papercraft_dynamic
+    md = <<~MD
+      ```ruby
+      # render: true
+      @env[:count] ||= 0
+      h3 (@env[:count] += 1)
+      ```
+      bar
+    MD
+
+    atts = { foo: 'bar' }
+
+    @controller = Syntropy::Markdown.make_controller(@env, atts, md)
+    req = @test_harness.request(':method' => 'GET', ':path' => '/')
+    assert_equal HTTP::OK, req.response_status
+    assert_equal(
+      (
+        <<~HTML.chomp
+        <!DOCTYPE html><html><head></head><body><h3>1</h3>
+        <p>bar</p>
+        </body></html>
+        HTML
+      ),
+      req.response_body
+    )
+
+    req = @test_harness.request(':method' => 'GET', ':path' => '/')
+    assert_equal HTTP::OK, req.response_status
+    assert_equal(
+      (
+        <<~HTML.chomp
+        <!DOCTYPE html><html><head></head><body><h3>2</h3>
+        <p>bar</p>
+        </body></html>
+        HTML
+      ),
+      req.response_body
+    )
+  end
+end