syntropy 0.13.1 → 0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dad58d19dc755d1a8ea6adb32cd7146b2228b5ace655a01b2e7932fd8abb7d23
-  data.tar.gz: 228678e0a76e67b012e52c89f5ed90c3d08e884a6424c0c51fcf9f840b2e6876
+  metadata.gz: 8fda8af32a2963e75aa4f1a600ecda8d3d9c927377d9a972314ebb28d35575fb
+  data.tar.gz: 7fe707495be32c3c72aa0d6d7019056eaac16567caa5d3b5dfe8e8541e17f234
 SHA512:
-  metadata.gz: 5ea7c453ae3e32d17f4bc35204fcf4c29f4eae7d95e9232f56b6ff65dcfaab9f3f6e41fb5562817ab3d3bd10a3ee2e5c92c440045bbdc8a51bc88d155fac7ab4
-  data.tar.gz: fb28a9011ea58505b9923589b62f0010eb97dea9f1df81e4c0483682669715c455fff5a150888f06f117e127497a98e7c93535f683d924e86ffcfeb007cf9fc5
+  metadata.gz: 266dd7fdbd8b5cb6b9a68cf6cab367c1f089ac2a59141d19368614d8bb0eda7c52d1697d1d67bb404ea35894673fea02ee2ed655d16a7cf26209bd20bcaa3b63
+  data.tar.gz: 2e31bc7fabe3e59557dbb719d7148f9a8f77cd685806fb0e9cbbd187f8ef3aedab12a1a256b915fd461e82e450b8c6b25e8b548d50b09e1d782a95351546f335

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# 0.15 2025-08-31
+
+- Implement invalidation of reverse dependencies on module file change
+
+# 0.14 2025-08-30
+
+- Tweak "boot" sequence
+- Update dependencies
+- Log errors in App#call
+- Improve module loading, add logging
+
 # 0.13 2025-08-28
 
 - Reimplement module loading

data/TODO.md

@@ -1,3 +1,30 @@
+## Immediate
+
+- [ ] Collection - treat directories and files as collections of data.
+
+  Kind of similar to the routing tree, but instead of routes it just takes a
+  bunch of files and turns it into a dataset. Each directory is a "table" and is
+  composed of zero or more files that form rows in the table. Supported file
+  formats:
+
+  - foo.md - markdown with optional front matter
+  - foo.json - JSON record
+  - foo.yml - YAML record
+
+  API:
+
+  ```ruby
+  Articles = @app.collection('_articles/*.md')
+  article = Articles.last_by(&:date)
+
+  article.title #=>
+  article.date #=>
+  article.layout #=>
+  article.render_proc #=> (load layout, apply article)
+  article.render #=> (render to HTML)
+  ...
+  ```
+
 - [ ] Improve serving of static files:
   - [ ] support for compression
   - [ ] support for caching headers

data/bin/syntropy

@@ -4,7 +4,7 @@
 require 'syntropy'
 require 'optparse'
 
-opts = {
+env = {
   mount_path: '/',
   banner: Syntropy::BANNER,
   logger: true
@@ -15,17 +15,17 @@ parser = OptionParser.new do |o|
 
   o.on('-b', '--bind BIND', String,
        'Bind address (default: http://0.0.0.0:1234). You can specify this flag multiple times to bind to multiple addresses.') do
-    opts[:bind] ||= []
-    opts[:bind] << it
+    env[:bind] ||= []
+    env[:bind] << it
   end
 
   o.on('-s', '--silent', 'Silent mode') do
-    opts[:banner] = nil
-    opts[:logger] = nil
+    env[:banner] = nil
+    env[:logger] = nil
   end
 
   o.on('-w', '--watch', 'Watch for changed files') do
-    opts[:watch_files] = 0.1
+    env[:watch_files] = 0.1
   end
 
   o.on('-h', '--help', 'Show this help message') do
@@ -34,7 +34,7 @@ parser = OptionParser.new do |o|
   end
 
   o.on('-m', '--mount', 'Set mount path (default: /)') do
-    opts[:mount_path] = it
+    env[:mount_path] = it
   end
 
   o.on('-v', '--version', 'Show version') do
@@ -54,17 +54,21 @@ rescue StandardError => e
   exit
 end
 
-opts[:root_dir] = ARGV.shift || '.'
+env[:root_dir] = ARGV.shift || '.'
 
-if !File.directory?(opts[:root_dir])
-  puts "#{File.expand_path(opts[:root_dir])} Not a directory"
+if !File.directory?(env[:root_dir])
+  puts "#{File.expand_path(env[:root_dir])} Not a directory"
   exit
 end
 
+puts env[:banner] if env[:banner]
+env[:banner] = false
+
 
 # We set Syntropy.machine so we can reference it from anywhere
-opts[:machine] = Syntropy.machine = UM.new
-opts[:logger] = opts[:logger] && TP2::Logger.new(opts[:machine], **opts)
+env[:machine] = Syntropy.machine = UM.new
+env[:logger] = env[:logger] && TP2::Logger.new(env[:machine], **env)
 
-app = Syntropy::App.load(opts)
-TP2.run(opts) { app.call(it) }
+env[:logger]&.info(message: "Running Syntropy version #{Syntropy::VERSION}")
+app = Syntropy::App.load(env)
+TP2.run(env) { app.call(it) }

data/lib/syntropy/app.rb

@@ -15,38 +15,38 @@ require 'syntropy/routing_tree'
 module Syntropy
   class App
     class << self
-      def load(opts)
-        site_file_app(opts) || default_app(opts)
+      def load(env)
+        site_file_app(env) || default_app(env)
       end
 
       private
 
       # for apps with a _site.rb file
-      def site_file_app(opts)
-        fn = File.join(opts[:root_dir], '_site.rb')
+      def site_file_app(env)
+        fn = File.join(env[:root_dir], '_site.rb')
         return nil if !File.file?(fn)
 
-        loader = Syntropy::ModuleLoader.new(opts)
+        loader = Syntropy::ModuleLoader.new(env)
         loader.load('_site')
       end
 
       # default app
-      def default_app(opts)
-        new(**opts)
+      def default_app(env)
+        new(**env)
       end
     end
 
-    attr_reader :module_loader, :routing_tree, :root_dir, :mount_path, :opts
-    
-    def initialize(**opts)
-      @machine = opts[:machine]
-      @root_dir = opts[:root_dir]
-      @mount_path = opts[:mount_path]
-      @opts = opts
+    attr_reader :module_loader, :routing_tree, :root_dir, :mount_path, :env
 
-      @module_loader = Syntropy::ModuleLoader.new(app: self, **opts)
+    def initialize(**env)
+      @machine = env[:machine]
+      @root_dir = File.expand_path(env[:root_dir])
+      @mount_path = env[:mount_path]
+      @env = env
+
+      @module_loader = Syntropy::ModuleLoader.new(app: self, **env)
       setup_routing_tree
-      start_app
+      start
     end
 
     # Processes an incoming HTTP request. Requests are processed by first
@@ -70,8 +70,11 @@ module Syntropy
       proc = route[:proc] ||= compute_route_proc(route)
       proc.(req)
     rescue StandardError => e
-      # p e
-      # p e.backtrace
+      @env[:logger]&.error(
+        message: "Error while serving request",
+        method: req.method,
+        path: req.path
+      )
       error_handler = get_error_handler(route)
       error_handler.(req, e)
     end
@@ -84,7 +87,7 @@ module Syntropy
     # @return [void]
     def setup_routing_tree
       @routing_tree = Syntropy::RoutingTree.new(
-        root_dir: @root_dir, mount_path: @mount_path, **@opts
+        root_dir: @root_dir, mount_path: @mount_path, **@env
       )
       @router_proc = @routing_tree.router_proc
     end
@@ -138,7 +141,7 @@ module Syntropy
     end
 
     def render_markdown(route)
-      atts, md = Syntropy.parse_markdown_file(route[:target][:fn], @opts)
+      atts, md = Syntropy.parse_markdown_file(route[:target][:fn], @env)
 
       if (layout = atts[:layout])
         route[:applied_layouts] ||= {}
@@ -277,15 +280,17 @@ module Syntropy
     # watcher according to app options.
     #
     # @return [void]
-    def start_app
+    def start
       @machine.spin do
         # we do startup stuff asynchronously, in order to first let TP2 do its
         # setup tasks
         @machine.sleep 0.2
-        @opts[:logger]&.info(
-          message: "Serving from #{File.expand_path(@location)}"
+        route_count = @routing_tree.static_map.size + @routing_tree.dynamic_map.size
+        @env[:logger]&.info(
+          message: "Serving from #{@root_dir} (#{route_count} routes found)"
         )
-        file_watcher_loop if opts[:watch_files]
+
+        file_watcher_loop if @env[:watch_files]
       end
     end
 
@@ -294,10 +299,11 @@ module Syntropy
     #
     # @return [void]
     def file_watcher_loop
-      wf = @opts[:watch_files]
+      wf = @env[:watch_files]
       period = wf.is_a?(Numeric) ? wf : 0.1
       Syntropy.file_watch(@machine, @root_dir, period: period) do |event, fn|
-        @module_loader.invalidate(fn)
+        @env[:logger]&.info(message: "File change detected", fn: fn)
+        @module_loader.invalidate_fn(fn)
         debounce_file_change
       end
     rescue Exception => e

data/lib/syntropy/markdown.rb

@@ -14,7 +14,7 @@ module Syntropy
   #
   # @param path [String] file path
   # @return [Array] an tuple containing properties<Hash>, contents<String>
-  def self.parse_markdown_file(path, opts)
+  def self.parse_markdown_file(path, env)
     content = IO.read(path) || ''
     atts = {}
 
@@ -30,9 +30,9 @@ module Syntropy
       atts = atts.merge(yaml)
     end
 
-    if opts[:root_dir]
+    if env[:root_dir]
       atts[:url] = path
-                   .gsub(/#{opts[:root_dir]}/, '')
+                   .gsub(/#{env[:root_dir]}/, '')
                    .gsub(/\.md$/, '')
     end
 

data/lib/syntropy/module.rb

@@ -3,39 +3,118 @@
 require 'p2'
 
 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
+  # `/my_site/_lib/foo.rb`.
   class ModuleLoader
+    attr_reader :modules
+
+    # Instantiates a module loader
+    # 
+    # @param env [Hash] environment hash
+    # @return [void]
     def initialize(env)
       @root_dir = env[:root_dir]
       @env = env
-      @loaded = {} # maps ref to code
+      @modules = {} # maps ref to module entry
       @fn_map = {} # maps filename to ref
     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)
-      @loaded[ref] ||= load_module(ref)
+      entry = (@modules[ref] ||= load_module(ref))
+      entry[:export_value]
     end
 
-    def invalidate(fn)
+    # Invalidates a module by its filename, 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
+    # it.
+    # 
+    # @param fn [String] module filename
+    # @return [void]
+    def invalidate_fn(fn)
       ref = @fn_map[fn]
       return if !ref
 
-      @loaded.delete(ref)
-      @fn_map.delete(fn)
+      invalidate_ref(ref)
     end
 
     private
 
+    # 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
+    # it.
+    # 
+    # @param ref [String] module reference
+    # @return [void]
+    def invalidate_ref(ref)
+      entry = @modules.delete(ref)
+      return if !entry
+
+      @fn_map.delete(entry[:fn])
+      entry[:reverse_deps].each { invalidate_ref(it) }
+    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]
+    def add_dependencies(ref, deps)
+      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)
       fn = File.expand_path(File.join(@root_dir, "#{ref}.rb"))
-      @fn_map[fn] = ref
       raise Syntropy::Error, "File not found #{fn}" if !File.file?(fn)
 
+      @fn_map[fn] = ref
       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)
+      m = Syntropy::Module.load(env, code, fn)
+      add_dependencies(ref, m.__dependencies__)
+      export_value = transform_module_export_value(m.__export_value__)
+
+      {
+        fn: fn,
+        export_value: export_value,
+        reverse_deps: []
+      }
     end
 
+    # 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)
       case export_value
       when nil
@@ -50,14 +129,28 @@ module Syntropy
     end
   end
 
+  # 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.
   class Module
-    def self.load(env, code)
+    # Loads a module, returning the module instance
+    def self.load(env, code, fn)
       m = new(**env)
-      m.instance_eval(code)
-      m.__export_value__
+      m.instance_eval(code, fn)
+      env[:logger]&.info(message: "Loaded module at #{fn}")
+      m
+    rescue StandardError => e
+      env[:logger]&.error(
+          message: "Error while loading module #{fn}",
+          error: e
+      )
+      raise
     end
 
-    attr_reader 
+    # Initializes a module with the given environment hash.
+    # 
+    # @param env [Hash] environment hash
+    # @return [void]
     def initialize(**env)
       @env = env
       @machine = env[:machine]
@@ -66,16 +159,42 @@ module Syntropy
       @ref = env[:ref]
       singleton_class.const_set(:MODULE, self)
     end
-      
+
     attr_reader :__export_value__
+
+    # 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)
       @__export_value__ = v
     end
 
+    # Returns the list of module references imported by the module.
+    # 
+    # @return [Array] array of module references
+    def __dependencies__
+      @__dependencies__ ||= []
+    end
+
+    # 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)
-      @module_loader.load(ref)
+      @module_loader.load(ref).tap {
+        __dependencies__ << ref
+      }
     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
     def template(proc = nil, &block)
       proc ||= block
       raise "No template block/proc given" if !proc
@@ -83,10 +202,17 @@ module Syntropy
       P2::Template.new(proc)
     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)
       Syntropy.page_list(@env, ref)
     end
 
+    # Creates and returns a Syntropy app for the given environment.
+    # 
+    # @param env [Hash] environment
     def app(**env)
       Syntropy::App.new(**(@env.merge(env)))
     end

data/lib/syntropy/routing_tree.rb

@@ -66,32 +66,6 @@ module Syntropy
       @router_proc ||= compile_router_proc
     end
 
-    # Returns the first error handler found for the entry. If no error handler
-    # exists for the entry itself, the search continues up the tree through the
-    # entry's ancestors.
-    #
-    # @param entry [Hash] route entry
-    # @return [String, nil] filename of error handler, or nil if not found
-    def route_error_handler(entry)
-      return entry[:error] if entry[:error]
-
-      entry[:parent] && route_error_handler(entry[:parent])
-    end
-
-    # Returns a list of all hooks found up the tree from the given entry. Hooks
-    # are returned ordered from the tree root down to the given entry.
-    #
-    # @param entry [Hash] route entry
-    # @return [Array<String>] list of hook entries
-    def route_hooks(entry)
-      hooks = []
-      while entry
-        hooks.unshift(entry[:hook]) if entry[:hook]
-        entry = entry[:parent]
-      end
-      hooks
-    end
-
     # Computes a "clean" URL path for the given path. Modules and markdown are
     # stripped of their extensions, and index file paths are also converted to the
     # containing directory path. For example, the clean URL path for `/foo/bar.rb`
@@ -233,7 +207,7 @@ module Syntropy
       case
       when (m = fn.match(/\/index(\+)?(\.(?:rb|md))$/))
         make_index_module_route(m:, parent:, path: abs_path, fn:)
-        
+
       # index.html
       when fn.match(/\/index\.html$/)
         set_index_route_target(parent:, path: abs_path, kind: :static, fn:)
@@ -256,7 +230,7 @@ module Syntropy
     # (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

data/lib/syntropy/utils.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
- 
+
 module Syntropy
   # Utilities for use in modules
   module Utilities
-    # Returns a request handler that routes request according to 
+    # 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, '*')]
@@ -17,7 +17,7 @@ module Syntropy
       # 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)
@@ -36,6 +36,6 @@ module Syntropy
 
     def app(**env)
       Syntropy::App.new(**env)
-    end    
+    end
   end
 end

data/lib/syntropy/version.rb

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

data/syntropy.gemspec

@@ -26,8 +26,8 @@ Gem::Specification.new do |s|
   s.add_dependency 'p2',            '2.8'
   s.add_dependency 'papercraft',    '1.4'
   s.add_dependency 'qeweney',       '0.22'
-  s.add_dependency 'tp2',           '0.14.1'
-  s.add_dependency 'uringmachine',  '0.16'
+  s.add_dependency 'tp2',           '0.15'
+  s.add_dependency 'uringmachine',  '0.18'
 
   s.add_dependency 'listen',        '3.9.0'
   s.add_dependency 'logger',        '1.7.0'

data/test/app/_lib/dep.rb

@@ -0,0 +1,7 @@
+Foo = import '_lib/self'
+
+def bar
+  Foo.foo
+end
+
+export self

data/test/test_module.rb

@@ -44,4 +44,14 @@ class ModuleTest < Minitest::Test
     assert_equal @loader, mod.module_loader
     assert_equal 42, mod.app
   end
+
+  def test_dependency_invalidation
+    mod = @loader.load('_lib/dep')
+    assert_equal ['_lib/self', '_lib/dep'], @loader.modules.keys
+
+    self_fn = @loader.modules['_lib/self'][:fn]
+    @loader.invalidate_fn(self_fn)
+
+    assert_equal [], @loader.modules.keys
+  end
 end

data/test/test_routing_tree.rb

@@ -288,58 +288,6 @@ class RoutingTreeTest < Minitest::Test
     assert_equal 'foo', params['id']
   end
 
-  def test_route_error_handler
-    e = @rt.dynamic_map['/docs/[org]']
-    target = @rt.route_error_handler(e)
-    assert_kind_of Hash, target
-    assert_equal :module, target[:kind]
-    assert_equal File.join(@rt.root_dir, '_error.rb'), target[:fn]
-
-    e = @rt.dynamic_map['/docs/api+']
-    target = @rt.route_error_handler(e)
-    assert_equal :module, target[:kind]
-    assert_equal File.join(@rt.root_dir, '_error.rb'), target[:fn]
-
-    e = @rt.dynamic_map['/docs/[org]/[repo]']
-    target = @rt.route_error_handler(e)
-    assert_equal :module, target[:kind]
-    assert_equal File.join(@rt.root_dir, '[org]/[repo]/_error.rb'), target[:fn]
-  end
-
-  def test_route_hooks
-    e = @rt.dynamic_map['/docs/[org]']
-    hooks = @rt.route_hooks(e)
-    assert_equal [
-      { kind: :module, fn: File.join(@rt.root_dir, '_hook.rb') }
-    ], hooks
-
-    e = @rt.dynamic_map['/docs/api+']
-    hooks = @rt.route_hooks(e)
-    assert_equal [
-      { kind: :module, fn: File.join(@rt.root_dir, '_hook.rb') }
-    ], hooks
-
-    e = @rt.dynamic_map['/docs/[org]/[repo]']
-    hooks = @rt.route_hooks(e)
-    assert_equal [
-      { kind: :module, fn: File.join(@rt.root_dir, '_hook.rb') }
-    ], hooks
-
-    e = @rt.dynamic_map['/docs/[org]/[repo]/issues']
-    hooks = @rt.route_hooks(e)
-    assert_equal [
-      { kind: :module, fn: File.join(@rt.root_dir, '_hook.rb') },
-      { kind: :module, fn: File.join(@rt.root_dir, '[org]/[repo]/issues/_hook.rb') }
-    ], hooks
-
-    e = @rt.dynamic_map['/docs/[org]/[repo]/issues/[id]']
-    hooks = @rt.route_hooks(e)
-    assert_equal [
-      { kind: :module, fn: File.join(@rt.root_dir, '_hook.rb') },
-      { kind: :module, fn: File.join(@rt.root_dir, '[org]/[repo]/issues/_hook.rb') }
-    ], hooks
-  end
-
   def test_routing_root_mounted
     rt = Syntropy::RoutingTree.new(root_dir: File.join(@root_dir, 'site'), mount_path: '/')
     router = rt.router_proc

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: syntropy
 version: !ruby/object:Gem::Version
-  version: 0.13.1
+  version: '0.15'
 platform: ruby
 authors:
 - Sharon Rosner
@@ -85,28 +85,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.14.1
+        version: '0.15'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.14.1
+        version: '0.15'
 - !ruby/object:Gem::Dependency
   name: uringmachine
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '0.16'
+        version: '0.18'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '0.16'
+        version: '0.18'
 - !ruby/object:Gem::Dependency
   name: listen
   requirement: !ruby/object:Gem::Requirement
@@ -221,6 +221,7 @@ files:
 - test/app/_hook.rb
 - test/app/_layout/default.rb
 - test/app/_lib/callable.rb
+- test/app/_lib/dep.rb
 - test/app/_lib/env.rb
 - test/app/_lib/klass.rb
 - test/app/_lib/missing-export.rb