proscenium 0.26.0-x86_64-linux-gnu

data/lib/proscenium/side_load.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module Proscenium
+  class SideLoad
+    JS_COMMENT = '<!-- [PROSCENIUM_JAVASCRIPTS] -->'
+    CSS_COMMENT = '<!-- [PROSCENIUM_STYLESHEETS] -->'
+
+    module Controller
+      def self.included(child)
+        child.class_eval do
+          class_attribute :sideload_assets_options
+          child.extend ClassMethods
+
+          append_after_action :capture_and_replace_proscenium_stylesheets,
+                              :capture_and_replace_proscenium_javascripts,
+                              if: -> { response.content_type&.include?('html') }
+        end
+      end
+
+      module ClassMethods
+        def sideload_assets(value)
+          self.sideload_assets_options = value
+        end
+      end
+
+      def capture_and_replace_proscenium_stylesheets
+        return if response_body.nil?
+        return if response_body.first.blank? || !Proscenium::Importer.css_imported?
+
+        included_comment = response_body.first.include?(CSS_COMMENT)
+        fragments = proscenium_fragment_header&.split(/[,\s]+/)
+
+        return if !fragments && !included_comment
+
+        out = []
+        Proscenium::Importer.each_stylesheet(delete: true) do |path, opts|
+          opts = opts[:css].is_a?(Hash) ? opts[:css] : {}
+          opts = opts.merge(data: opts[:data] || {})
+          opts = opts.merge(preload_links_header: false) if fragments
+
+          out << helpers.stylesheet_link_tag(path.delete_prefix('/'), extname: false, **opts)
+        end
+
+        if fragments
+          response_body.first.prepend out.join.html_safe
+        elsif included_comment
+          response_body.first.gsub! CSS_COMMENT, out.join.html_safe
+        end
+      end
+
+      def capture_and_replace_proscenium_javascripts
+        return if response_body.nil?
+        return if response_body.first.blank? || !Proscenium::Importer.js_imported?
+
+        included_comment = response_body.first.include?(JS_COMMENT)
+        fragments = proscenium_fragment_header&.split(/[,\s]+/)
+
+        return if !fragments && !included_comment
+
+        out = []
+        Proscenium::Importer.each_javascript(delete: true) do |path, opts|
+          next if opts.delete(:lazy)
+
+          opts = opts[:js].is_a?(Hash) ? opts[:js] : {}
+          opts = opts.merge(preload_links_header: false) if fragments
+
+          out << helpers.javascript_include_tag(path.delete_prefix('/'), extname: false, **opts)
+        end
+
+        if fragments
+          response_body.first.prepend out.join.html_safe
+        elsif included_comment
+          response_body.first.gsub! JS_COMMENT, out.join.html_safe
+        end
+      end
+
+      private
+
+      # Fragment rendering: phlex-rails 1.x used `X-Fragment`, phlex-rails 2.x uses `X-Fragments`.
+      # Honour both so side-loaded assets are injected into fragment responses regardless of the
+      # phlex-rails version in use. The value is only used as a presence flag (all imported assets
+      # are injected — Proscenium does not filter by fragment name), so the split delimiter is
+      # cosmetic; splitting on comma or whitespace covers both conventions (plural is comma-based).
+      def proscenium_fragment_header
+        request.headers['X-Fragment'] || request.headers['X-Fragments']
+      end
+    end
+
+    class << self
+      # Side loads assets for the class, and its super classes that respond to `.source_path`, which
+      # should return a Pathname of the class source file.
+      #
+      # Set the `abstract_class` class variable to true in any class, and it will not be side
+      # loaded.
+      #
+      # If the class responds to `.sideload`, it will be called after the regular side loading. You
+      # can use this to customise what is side loaded.
+      def sideload_inheritance_chain(obj, options)
+        return unless Proscenium.config.side_load
+
+        options = merge_options(options, obj.sideload_assets_options, obj)
+
+        css_imports = []
+
+        klass = obj.class
+        while klass.respond_to?(:source_path) && klass.source_path &&
+              (klass.respond_to?(:abstract_class) ? !klass.abstract_class : true)
+          if options[:css] == false
+            Importer.sideload klass.source_path, **options
+          else
+            Importer.sideload_js klass.source_path, **options
+            css_imports << klass.source_path
+          end
+
+          klass.sideload options if klass.respond_to?(:sideload)
+
+          klass = klass.superclass
+        end
+
+        # All regular CSS files (*.css) are ancestrally sideloaded. However, the first CSS module
+        # in the ancestry is also sideloaded in addition to the regular CSS files. This is because
+        # the CSS module digest will be different for each file, so we only sideload the first CSS
+        # module.
+        css_imports.each do |it| # rubocop:disable Style/ItAssignment
+          break if Importer.sideload_css_module(it, **options).present?
+        end
+
+        # Sideload regular CSS files in reverse order.
+        #
+        # The reason why we sideload CSS after JS is because the order of CSS is important.
+        # Basically, the layout should be loaded before the view so that CSS cascading works in the
+        # right direction.
+        css_imports.reverse_each do |it| # rubocop:disable Style/ItAssignment
+          Importer.sideload_css it, **options
+        end
+      end
+
+      # Whether `template`, rendered by `view`, should have its assets side loaded.
+      def sideloadable?(view, template)
+        Proscenium.config.side_load && view.controller.respond_to?(:sideload_assets_options) &&
+          template.respond_to?(:identifier) && template.respond_to?(:type) && template.type == :html
+      end
+
+      # Renders the block, then side loads each of `templates`, and returns what the block
+      # returned. A template's `sideload_assets` value belongs to this one render: the view's
+      # stored value is set aside before the block and put back after it, so a repeated or nested
+      # render of the same template neither inherits this one's value nor overwrites it.
+      def sideload_templates(view, templates)
+        # A layout can be `false`, meaning none, and a template can be its own layout.
+        templates = templates.select(&:itself).uniq(&:identifier)
+        # A view rendered before Proscenium::Helper is included has nowhere to store a value.
+        store = view.try(:proscenium_sideload_assets_options) || {}
+        saved = templates.to_h { |tpl| [tpl.identifier, store.delete(tpl.identifier)] }
+
+        result = yield
+        templates.each { |tpl| sideload_template tpl, view.controller, store[tpl.identifier] }
+        result
+      ensure
+        saved&.each { |id, value| value.nil? ? store.delete(id) : store[id] = value }
+      end
+
+      # Returns a new options hash: `base`, with `override` deep merged over it, or replacing it
+      # when not a Hash, and any Proc `css`/`js` value evaluated against `receiver`. A nil `base`
+      # is empty, and a nil `override` changes nothing. Keys are symbolized at every depth, before
+      # merging, so options with indifferent access merge with symbol-keyed ones.
+      #
+      # Neither input is modified, and no Hash is shared with them - `base` is usually a class
+      # attribute, so writing to it would leak one request's options into every later one. Values
+      # other than hashes are passed through as they are, not copied: `dup` on an ActiveRecord
+      # model returns a new record with no id.
+      def merge_options(base, override, receiver)
+        options = base.nil? ? {} : base
+        options = { js: options, css: options } unless options.is_a?(Hash)
+        options = options.deep_symbolize_keys
+
+        unless override.nil?
+          options = if override.is_a?(Hash)
+                      options.deep_merge(override.deep_symbolize_keys)
+                    else
+                      { js: override, css: override }
+                    end
+        end
+
+        options.to_h do |key, value|
+          value = evaluate(value, receiver) if (key in :css | :js) && value.is_a?(Proc)
+          [key, value.is_a?(Hash) ? value.deep_symbolize_keys : value]
+        end
+      end
+
+      private
+
+      # `instance_eval` passes the receiver as the block's argument, which a lambda taking none
+      # rejects. Every other proc keeps receiving it, as it always has.
+      def evaluate(value, receiver)
+        if value.lambda? && value.arity.zero?
+          receiver.instance_exec(&value)
+        else
+          receiver.instance_eval(&value)
+        end
+      end
+
+      def sideload_template(tpl, controller, override)
+        return unless (tpl_path = Pathname.new(tpl.identifier)).file?
+
+        options = merge_options(controller.sideload_assets_options, override, controller)
+        Importer.sideload tpl_path, **options
+      end
+    end
+  end
+end

data/lib/proscenium/source_path.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Include this into any class to expose a `source_path` class and instance method, which will return
+# the absolute file system path to the current object.
+module Proscenium::SourcePath
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def source_path
+      @source_path ||= name.nil? ? nil : Pathname.new(const_source_location(name).first)
+    end
+  end
+end

data/lib/proscenium/stale_contexts.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'bundled_gems'
+require_relative 'context_map'
+require_relative 'dependency_context'
+require_relative 'cli/contexts'
+require_relative 'cli/error'
+require_relative 'cli/verify'
+
+module Proscenium
+  # Whether an adopted app's committed gem dependency contexts are what its bundle calls for
+  # (#154). A stale context resolves a gem's imports against the wrong dependency graph, so the
+  # engine refuses to build until `proscenium install` brings them up to date. Built from
+  # committed files and Bundler only; it loads nothing the `proscenium` CLI may not.
+  module StaleContexts
+    COMMAND = 'Run `bundle exec proscenium install` and commit .proscenium/packages.'
+    EDITED = 'its dependency context was edited by hand'
+    ORPHAN = '%<gem>s: its dependency context is left over, as the gem is no longer in the ' \
+             'bundle or no longer opted in'
+
+    module_function
+
+    # One line for each way the committed contexts differ from the bundle; empty when current, or
+    # before the app adopts. A context is stale when a participating gem has none, when its gem
+    # left Gemfile.lock or stopped participating, when its projection hash is not the gem's
+    # current one, or when that hash is not the one its own fields produce (a hand edit). A
+    # locked gem that is not installed (a group BUNDLE_WITHOUT excludes) keeps its context as
+    # committed.
+    def problems(root, specs = BundledGems.installed_specs, locked = BundledGems.locked_names)
+      registrar = ContextMap.registrar(root)
+      return [] unless registrar
+
+      # Only the registration in use: a Bun app does not read a pnpm-workspace.yaml left over.
+      unparsable = unparsable_workspace(root) if registrar == 'pnpm-workspace.yaml'
+      return [unparsable] if unparsable
+
+      participating = BundledGems.participating(specs, overrides: BundledGems.overrides(root))
+      contexts = CLI::Contexts.new(root, participating)
+      committed = CLI::Contexts.committed(root)
+      found = contexts.problems.map { |code, args| CLI::Error.new(code, **args).message }
+      contexts.contexts.each_value do |context|
+        problem = compare(context, committed[context.gem])
+        found << "#{context.gem}: #{problem}" if problem
+      end
+      excluded = (locked || []) - specs.map(&:name)
+      orphans = committed.keys - participating.keys - excluded
+      found + orphans.map { format(ORPHAN, gem: it) } +
+        split_peers(root, contexts.contexts.keys & committed.keys)
+    rescue BundledGems::ConfigError => e
+      [e.message]
+    end
+
+    # An app counts as adopted when a pnpm-workspace.yaml it cannot parse names the contexts, so
+    # the engine never silently switches them off; it refuses until the file parses. Not
+    # package.json: Bun reads JSON that Ruby refuses, such as a trailing comma.
+    def unparsable_workspace(root)
+      path = File.join(root, 'pnpm-workspace.yaml')
+      return unless File.exist?(path)
+
+      ContextMap.yaml_packages(ContextMap.utf8(File.read(path)).delete_prefix(ContextMap::BOM))
+      nil
+    rescue Psych::SyntaxError => e
+      "pnpm-workspace.yaml: it is not valid YAML (#{e.problem} at line #{e.line})"
+    end
+
+    # A peer meant to be shared that the gem and the app reach as two copies, as an app-only
+    # `pnpm update react` can leave it: install checks this too, and the engine repeats it for each
+    # generation.
+    def split_peers(root, gems)
+      pnpm = ContextMap.registers?(root, 'pnpm-workspace.yaml')
+      CLI::Verify.new(root, Struct.new(:name).new(pnpm ? 'pnpm' : 'bun'), gems).check_peers
+      []
+    rescue CLI::Error => e
+      [e.message]
+    end
+
+    # The committed context is projected again from the fields it holds, not taken on trust: a
+    # hand edit that kept the reported hash would build against a graph no install produced.
+    def compare(context, path)
+      return "its dependency context hasn't been written yet" unless path && File.exist?(path)
+
+      committed = ContextMap.read_json(path)
+      unless committed.is_a?(Hash) && committed['proscenium'].is_a?(Hash)
+        return 'its dependency context is not valid JSON'
+      end
+      if committed['proscenium']['projection'] != DependencyContext::PROJECTION
+        return 'its dependency context was written by a different version of Proscenium'
+      end
+
+      # Parsed, so reformatting is not an edit; whole, so its name and the other generated fields
+      # count as well as its hash.
+      edited = DependencyContext.project(context.gem, committed) != committed
+      return EDITED if edited
+      return if committed == JSON.parse(context.json)
+
+      'its NPM dependencies changed since its dependency context was written'
+    rescue JSON::ParserError
+      'its dependency context is not valid JSON'
+    end
+
+    # The build error for the app at `root`, or nil when its contexts are current. Read once per
+    # mapping generation, as ContextMap.config is.
+    def message(root, generation = 0)
+      @message ||= {}
+      key = [root, generation]
+      return @message[key] if @message.key?(key)
+
+      found = problems(root)
+      @message[key] = if found.any?
+                        "Gem dependency contexts are out of date:\n" \
+                          "#{found.map { "  - #{it}" }.join("\n")}\n#{COMMAND}"
+                      end
+    end
+
+    def reset! = @message = {}
+  end
+end

data/lib/proscenium/templates/rescues/build_error.html.erb

@@ -0,0 +1,32 @@
+<header>
+  <h1>
+    <%= @exception_wrapper.exception_class_name %>
+    <% if params_valid? && @request.parameters['controller'] %>
+      in <%= @request.parameters['controller'].camelize %>Controller<% if @request.parameters['action'] %>#<%= @request.parameters['action'] %><% end %>
+    <% end %>
+  </h1>
+</header>
+
+<main role="main" id="container">
+  <%= render "rescues/message_and_suggestions", exception: @exception, exception_wrapper: @exception_wrapper %>
+
+  <%# Go marshals esbuild's Message without JSON tags, so the keys are the Go field names. This
+      block read lowercase keys and had never rendered. %>
+  <% if (location = @exception.error['Location']) %>
+    <div class="source">
+      <div class="data">
+<pre>
+
+    <%= location['File'] %>:<%= location['Line'] %>:<%= location['Column'] %>
+
+<%= location['Line'].to_s.rjust 5 %> │    <%= location['LineText'] %>
+      │    <%= (location['Length'].to_i > 1 ? "~" * location['Length'] : "^").rjust(location['Column'].to_i + location['Length'].to_i) %>
+<%- if location['Suggestion'].present? %>    + │    <%= location['Suggestion'].rjust(location['Column'].to_i + 1) %>
+<% else %> <%- end %>
+</pre>
+      </div>
+    </div>
+  <% end %>
+
+  <%= render template: "rescues/_request_and_response" %>
+</main>

data/lib/proscenium/utils.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Proscenium
+  module Utils
+    module_function
+
+    # A filesystem path in the slash form everything it is matched against - Rails.root, the public
+    # path, a gem's full_gem_path - already uses. Paths produced outside Ruby arrive in the form
+    # the platform produced: esbuild's metafile, and every path Bun hands the test harness. On
+    # Windows that is backslashes, so a plain `start_with?`/`delete_prefix` against Rails.root
+    # misses, and nothing raises - the path just falls through to whatever handles "not ours".
+    #
+    # Windows only, because a backslash is a legal character in a file name everywhere else.
+    #
+    # @param path [String] an absolute filesystem path.
+    # @return [String]
+    def fs_path(path)
+      Gem.win_platform? ? path.tr('\\', '/') : path
+    end
+
+    # Returns a short digest for the given `value`, intended for CSS module class name suffixes.
+    #
+    # @param value [#to_s] The value to create the digest from. This will usually be the absolute
+    #   file system file path.
+    # @return [String] digest of the given value.
+    def css_module_digest(value)
+      Digest::SHA1.hexdigest(value.to_s)[..7]
+    end
+
+    # The path a CSS module's class-name suffix is built from: the file's path under the app root.
+    #
+    # Where there is no such path - a gem on another drive than the app, which is RubyInstaller's
+    # default - it is the absolute path itself. relative_path_from raised there, and failed every
+    # view using the module. The absolute path is what esbuild falls back to when it builds the
+    # stylesheet's class names (MakePrettyPaths keeps the path it could not relativise), and
+    # internal/plugin/css.go does the same, so all three agree.
+    #
+    # @param abs_path [String] absolute file system path of the CSS module.
+    # @return [Pathname, String]
+    def css_module_relative_path(abs_path)
+      Pathname.new(abs_path).relative_path_from(Rails.root)
+    rescue ArgumentError
+      abs_path
+    end
+
+    # Returns the readable part of a CSS module class name: the given path, made safe to use in a
+    # class name.
+    #
+    # This is a port of `CssLocalAppendice` in esbuild-internal, which builds the class names in the
+    # stylesheet. The two must agree byte for byte or the style silently does not apply, so change
+    # them together (test/css_module_suffixes.json is checked against both). The rules: drop the
+    # file extension, turn `/`, `\` and `.` into `-`, turn any other character outside
+    # `A-Z a-z 0-9 - _` into `_`, and start with `_` if the result would start with a digit.
+    #
+    # Go works in runes, so the path is read as UTF-8 whatever its tag: the FFI hands paths back as
+    # ASCII-8BIT, where each byte of a multibyte character would become a `_` of its own. A byte
+    # that is not valid UTF-8 becomes one `_`, as it does in Go.
+    #
+    # @param path [#to_s] path of the CSS module file, relative to the app root.
+    # @return [String]
+    def css_module_suffix(path)
+      path.to_s
+          .dup.force_encoding(Encoding::UTF_8)
+          .scrub { |bytes| '_' * bytes.bytesize }
+          .sub(%r{\.[^./]*\z}, '')
+          .gsub(%r{[/\\.]}, '-')
+          .gsub(/[^A-Za-z0-9_-]/, '_')
+          .sub(/\A(?=\d)/, '_')
+    end
+
+    # Merges the given array of attribute `name`'s into the `kw_arguments`. A bang attribute is one
+    # that ends with an exclamation mark or - in Ruby parlance - a "bang", and has a boolean value.
+    # Modifies the given `kw_attributes`, and only attribute names in `allowed` will be merged.
+    #
+    # @param names [Array(Symbol)] of argument names
+    # @param kw_attributes [Hash] attributes to be merged with
+    # @param allowed [Array(Symbol)] attribute names allowed to be merged as bang attributes
+    #
+    # Example:
+    #
+    #   def tab(name, *args, href:, **attributes)
+    #     Hue::Utils.merge_bang_attributes!(args, attributes, [:current])
+    #   end
+    #
+    # Allowing you to use either of the following API's:
+    #
+    #   tab 'Tab 1', required: true
+    #   tab 'Tab 1', :required!
+    #
+    def merge_bang_attributes!(names, kw_attributes, allowed)
+      allowed.each do |name|
+        sym_name = name.to_sym
+        bang_name = :"#{sym_name}!"
+
+        next unless names.include?(bang_name)
+
+        names.delete(bang_name)
+
+        # Keyword arguments should override the bang.
+        kw_attributes[sym_name] = true unless kw_attributes.key?(sym_name)
+      end
+    end
+  end
+end

data/lib/proscenium/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Proscenium
+  VERSION = '0.26.0'
+end

data/lib/proscenium/yaml_tree.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Proscenium
+  # YAML read from Psych's parse tree, never built into Ruby objects (#154): no alias can make it
+  # slow, and no tag or date can raise. Shared by the engine and the `proscenium` CLI, so it loads
+  # nothing the CLI may not.
+  module YamlTree
+    module_function
+
+    # The node a root mapping's last `key` holds, aliases resolved, and the document's anchors; nil
+    # when the document is not a mapping or has no such key. A key the root inherits through a
+    # merge key (`<<: *defaults`) counts, as pnpm reads it. Raises Psych::SyntaxError.
+    def value(text, key)
+      root = Psych.parse_stream(text).children.first&.root
+      return unless root.is_a?(Psych::Nodes::Mapping)
+
+      anchors = root.each.grep_v(Psych::Nodes::Alias).select(&:anchor).to_h { [it.anchor, it] }
+      [lookup(root, key, anchors), anchors]
+    end
+
+    # `key`'s node in `mapping`: its own last one, else the first merged mapping's, following
+    # merges until one is already being looked in.
+    def lookup(mapping, key, anchors, merging = [])
+      return unless mapping.is_a?(Psych::Nodes::Mapping) && merging.none? { it.equal?(mapping) }
+
+      pairs = mapping.children.each_slice(2).map { |name, value| [node(name, anchors), value] }
+      _, found = pairs.reverse_each.find { |name, _| scalar?(name, key) }
+      return node(found, anchors) if found
+
+      merges = pairs.filter_map { |name, value| node(value, anchors) if scalar?(name, '<<') }
+      merges.each do |merged|
+        sources = merged.is_a?(Psych::Nodes::Sequence) ? merged.children : [merged]
+        sources.each do |source|
+          inherited = lookup(node(source, anchors), key, anchors, [*merging, mapping])
+          return inherited if inherited
+        end
+      end
+      nil
+    end
+
+    def scalar?(node, value) = node.is_a?(Psych::Nodes::Scalar) && node.value == value
+
+    # The node an alias names, or the node itself.
+    def node(node, anchors) = node.is_a?(Psych::Nodes::Alias) ? anchors[node.anchor] : node
+  end
+end

data/lib/proscenium.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require_relative 'proscenium/error'
+
+module Proscenium
+  extend ActiveSupport::Autoload
+
+  # Default paths for Rails assets. Used by the `compute_asset_path` helper to maintain Rails
+  # default conventions of where JS and CSS files are located.
+  DEFAULT_RAILS_ASSET_PATHS = {
+    stylesheet: 'app/assets/stylesheets/',
+    javascript: 'app/javascript/'
+  }.freeze
+
+  FILE_EXTENSIONS = ['js', 'mjs', 'ts', 'jsx', 'tsx', 'css', 'js.map', 'mjs.map', 'jsx.map',
+                     'ts.map', 'tsx.map', 'css.map'].freeze
+  # A gem dependency context's own node_modules holds the copy of a package the linker nested
+  # there, when the gem pins a version the app's does not satisfy (#154).
+  ALLOWED_DIRECTORIES = 'app,lib,config,node_modules,.proscenium/packages/*/node_modules'
+  VENDOR_PATH_GLOB = '/vendor/**.{js,css}'
+  APP_PATH_GLOB = "/{#{ALLOWED_DIRECTORIES}}/**.{#{FILE_EXTENSIONS.join(',')}}".freeze
+  GEMS_PATH_GLOB = "/node_modules/@rubygems/**.{#{FILE_EXTENSIONS.join(',')}}".freeze
+  CHUNKS_PATH = %r{^/_asset_chunks/}
+
+  # Environment variables that should always be passed to the builder.
+  DEFAULT_ENV_VARS = Set['RAILS_ENV', 'NODE_ENV'].freeze
+
+  autoload :SourcePath
+  autoload :Utils
+  autoload :Monkey
+  autoload :Middleware
+  autoload :Manifest
+  autoload :EnsureLoaded
+  autoload :SideLoad
+  autoload :CssModule
+  autoload :Helper
+  autoload :Builder
+  autoload :Importer
+  autoload :Resolver
+  autoload :BundledGems
+  autoload :ContextMap
+  autoload :StaleContexts
+  autoload :MappingGeneration
+
+  class Deprecator
+    def deprecation_warning(name, message, _caller_backtrace = nil)
+      msg = "`#{name}` is deprecated and will be removed in a near future release of Proscenium"
+      msg << " (#{message})" if message
+      Kernel.warn msg
+    end
+  end
+
+  class MissingAssetError < Error
+    def initialize(path)
+      super
+      @path = path
+    end
+
+    def message
+      "The asset '#{@path}' was not found."
+    end
+  end
+
+  class PathResolutionFailed < Error
+    def initialize(path)
+      @path = path
+      super
+    end
+
+    def message
+      "Path #{@path.inspect} cannot be resolved"
+    end
+  end
+
+  class << self
+    def config
+      @config ||= Railtie.config.proscenium
+    end
+
+    def root
+      Railtie.root
+    end
+  end
+end
+
+require 'proscenium/railtie'