RubyGems - confinement - Versions diffs - 0.0.1 → 0.0.2 - Mend

confinement 0.0.1 → 0.0.2

Files changed (6) hide show

checksums.yaml CHANGED

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e85abea697c0437610597a3c221c833d97931bace819ba66ebb7c02d48ed6c20
-  data.tar.gz: b611ce215a7c6057fe2e874707e314b0644f7f0732229810127cd7c7702fb572
+  metadata.gz: a991bdb8646d092772f6ae7154bc34c7c89ac4faf8d51822e7b1361ed8f7ec05
+  data.tar.gz: 073003314b979b4bbf03dc3baf487030e6a07199feef361b5addad3928a7b06c
 SHA512:
-  metadata.gz: bdc4a25ecacc5d1c378f589d28cef55e63cfd3bbd6353ba9b1cf2439ae08f7bc219f2f77f2257d4bcf887fb7e85c8a6d659097f4a7052c5e47b72d7727b9cbde
-  data.tar.gz: 17527d0a0f6307a5c2dc2b7b2ae445294c03afe5ffea69f20f3dabd3a6ac0a432181d82a8be7985666e01c875ff03f128aacc7add2a6968bda4770b17512c8a4
+  metadata.gz: 72cffafd98539f4655a039c674d9324e998ef508610bad89f9f6e21a5d06cd158487413b60bdeb6b961d76f338c44013bb4ff9f35ea0733ffba74856f01046d8
+  data.tar.gz: 1d6076cc1b834d0a3bf3cd9fcaee3dc7cabd6e048e3f5dc298a7d201c6b60d44f63f0a5f164378c0a9883d9a19e6c83e422a0b9b07d2727164e6e7f2a2493343

data/Gemfile.lock CHANGED

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    confinement (0.0.1)
+    confinement (0.0.2)
       erubi
 GEM

data/exe/confinement CHANGED

@@ -91,7 +91,7 @@ module Confinement
         root = Pathname.new(argv.first).expand_path
-        templates = DATA.read.split(/^==> /)[1..-1]
+        templates = data.split(/^==> /)[1..-1]
         templates = templates.filter_map do |template|
           path, *body = template.lines
           body = body.join("")
@@ -109,8 +109,6 @@ module Confinement
         end
         Dir.chdir(root) do
-          run(["yarn", "init", "--yes"])
           run(["yarn", "add", "--dev", "parcel@nightly"])
         end
       end
@@ -165,6 +163,11 @@ module Confinement
         /^y/i.match?(answer)
       end
+      def data
+        contents = File.read(__FILE__)
+        contents.split(/^__END__$/)[1]
+      end
     end
   end
 end
@@ -177,7 +180,7 @@ require "confinement"
 Confinement.root = __dir__
-Confinement.site = Confinement::Builder.new(
+Confinement.site = Confinement::Site.new(
   root: Confinement.root,
   assets: "assets",
   contents: "contents",
@@ -190,48 +193,50 @@ Confinement.site = Confinement::Builder.new(
 ==> build.rb
 require_relative "boot"
-using Confinement::Easier
-Confinement.site.contents do |contents, layouts, dest|
-  dest["/"] = Confinement::Content.new(
-    layout: layouts.join("default.html.erb"),
-    input_path: contents.join("index.html.erb"),
-    renderers: [Confinement::Renderer::Erb.new]
-  )
-end
-Confinement.site.assets do |assets, dest|
-  dest["/assets/application.js"] = Confinement::Asset.new(
-    input_path: assets.join("application.js"),
-    entrypoint: true,
-  )
+Confinement.site.build do |assets:, layouts:, contents:, routes:|
+  assets.init("application.js", entrypoint: true)
+  assets.init("application.css", entrypoint: false)
-  dest["/assets/application.css"] = Confinement::Asset.new(
-    input_path: assets.join("application.css"),
-    entrypoint: false,
-  )
-end
+  layouts.init("default.html.erb")
-Confinement.site.layouts do |layouts, dest|
-  dest[layouts.join("default.html.erb")] = Confinement::Layout.new(
-    renderers: [Confinement::Renderer::Erb.new]
-  )
+  routes["/"] = contents.init("index.html.erb") do |content|
+    content.layout = layouts["default.html.erb"]
+  end
 end
 ==> write.rb
 require_relative "build"
-Confinement::Publish
-  .new(Confinement.site)
-  .write(Confinement.root.join("public"))
+Confinement::Publish.new(Confinement.site).write
+==> package.json
+{
+  "name": "website",
+  "version": "1.0.0",
+  "license": "UNLICENSED",
+  "devDependencies": {
+  },
+  "dependencies": {
+  }
+}
 ==> assets/application.js
 import "./application.css";
 ==> assets/application.css
+body { color: blue }
 ==> layouts/default.html.erb
+<!DOCTYPE HTML>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <link rel="stylesheet" href="<%= assets["application.css"].url_path %>" charset="utf-8">
+  </head>
+  <body>
+    <%= yield %>
+  </body>
+</html>
 ==> contents/index.html.erb
+hello!

data/lib/confinement.rb CHANGED

@@ -14,6 +14,7 @@ require "yaml"
 # gems
 require "erubi"
+require "erubi/capture_end"
 # internal
 require_relative "confinement/version"
@@ -58,7 +59,7 @@ module Confinement
         return [{}, self] if matches["frontmatter"].nil?
-        frontmatter = YAML.safe_load(matches["frontmatter"])
+        frontmatter = YAML.load(matches["frontmatter"], symbolize_names: true)
         body = matches["body"] || ""
         body = body.strip if strip
@@ -66,6 +67,10 @@ module Confinement
       rescue ArgumentError
         [{}, self]
       end
+      def normalize_for_route
+        "/#{self}".squeeze("/")
+      end
     end
   end
@@ -88,12 +93,24 @@ module Confinement
     end
   end
-  class Builder
-    def initialize(root:, assets:, contents:, layouts:, config: {})
+  class Site
+    def initialize(
+      root:,
+      assets:,
+      contents:,
+      layouts:,
+      view_context_helpers: [],
+      guesses: Renderer.guesses,
+      config: {}
+    )
       @root = root
       @assets = assets
       @contents = contents
       @layouts = layouts
+      @view_context_helpers = view_context_helpers
+      @guessing_registry = guesses
       @config = {
         index: config.fetch(:index, "index.html")
       }
@@ -101,167 +118,204 @@ module Confinement
       @output_root = root.concat(config.fetch(:destination_root, "public"))
       @assets_root = @output_root.concat(config.fetch(:assets_subdirectory, "assets"))
-      @representation = Representation.new
+      @route_identifiers = RouteIdentifiers.new
+      @asset_blobs = Blobs.new(scoped_root: assets_path, file_abstraction_class: Asset)
+      @content_blobs = Blobs.new(scoped_root: contents_path, file_abstraction_class: Content)
+      @layout_blobs = Blobs.new(scoped_root: layouts_path, file_abstraction_class: Layout)
     end
     attr_reader :root
     attr_reader :output_root
     attr_reader :assets_root
-    attr_reader :representation
     attr_reader :config
-    def contents_path
-      @contents_path ||= @root.concat(@contents)
-    end
+    attr_reader :route_identifiers
+    attr_reader :asset_blobs
+    attr_reader :content_blobs
+    attr_reader :layout_blobs
-    def layouts_path
-      @layouts_path ||= @root.concat(@layouts)
-    end
+    attr_reader :view_context_helpers
+    attr_reader :guessing_registry
-    def assets_path
-      @assets_path ||= @root.concat(@assets)
-    end
+    def build
+      yield(
+        assets: @asset_blobs,
+        layouts: @layout_blobs,
+        contents: @content_blobs,
+        routes: @route_identifiers
+      )
-    def layouts
-      if !layouts_path.exist?
-        raise PathDoesNotExist, "Layouts path doesn't exist: #{layouts_path}"
-      end
+      guesser = Rendering::Guesser.new(guessing_registry)
+      guess_renderers(guesser, @layout_blobs)
+      guess_renderers(guesser, @content_blobs)
+      @asset_blobs.done!
+      @layout_blobs.done!
+      @content_blobs.done!
+      @route_identifiers.done!
-      yield(layouts_path, @representation.layouts)
+      nil
     end
-    def assets
-      if !assets_path.exist?
-        raise PathDoesNotExist, "Assets path doesn't exist: #{assets_path}"
+    private
+    def guess_renderers(guesser, blobs)
+      blobs.send(:lookup).values.each do |blob|
+        blob.renderers = blob.renderers.flat_map do |renderer|
+          if renderer == :guess
+            guesser.call(blob.input_path)
+          else
+            renderer
+          end
+        end
       end
+    end
-      yield(assets_path, @representation.assets)
+    def contents_path
+      @contents_path ||= @root.concat(@contents).cleanpath
     end
-    def contents
-      if !contents_path.exist?
-        raise PathDoesNotExist, "Contents path doesn't exist: #{contents_path}"
-      end
+    def layouts_path
+      @layouts_path ||= @root.concat(@layouts).cleanpath
+    end
-      yield(contents_path, layouts_path, @representation.contents)
+    def assets_path
+      @assets_path ||= @root.concat(@assets).cleanpath
     end
   end
-  class Representation
-    include Enumerable
+  # RouteIdentifiers is called such because it doesn't hold the actual
+  # content's route. The content's own `url_path` does.
+  #
+  # This is mainly so that assets could be referenced internally with a static
+  # identifier even though it could have a hashed route.
+  class RouteIdentifiers
     def initialize
-      @lookup = {}
-      @layouts_lookup = {}
-      @only_assets = []
-      @only_contents = []
+      self.lookup = {}
+    end
+    def done!
+      @done = true
     end
-    attr_reader :only_assets
-    attr_reader :layouts_lookup
-    attr_reader :only_contents
+    def [](route)
+      route = route.normalize_for_route
-    def fetch(key)
-      if !@lookup.key?(key)
-        raise "Not represented!"
+      if !lookup.key?(route)
+        raise "Route is not defined"
       end
-      @lookup[key]
+      self.lookup[route]
     end
-    def each
-      if !block_given?
-        return enum_for(:each)
-      end
+    def []=(route, content)
+      raise "Can't add more routes after initial setup" if @done
-      @lookup.each do |identifier, page|
-        yield(identifier, page)
+      route = route.normalize_for_route
+      if lookup.key?(route)
+        raise "Route already defined!"
       end
+      content.url_path = route
+      lookup[route] = content
     end
-    def layouts
-      Setter.new(@layouts_lookup) do |path, layout|
-        layout.input_path = path
-      end
+    private
+    attr_accessor :lookup
+  end
+  class Blobs
+    def initialize(scoped_root:, file_abstraction_class:)
+      self.scoped_root = scoped_root
+      self.file_abstraction_class = file_abstraction_class
+      self.lookup = {}
+      @done = false
     end
-    def assets
-      Setter.new(@lookup) do |identifier, asset|
-        @only_assets.push(asset)
-        asset.url_path = identifier
-      end
+    def done!
+      @done = true
     end
-    def contents
-      Setter.new(@lookup) do |identifier, content|
-        @only_contents.push(content)
-        content.url_path = identifier
+    def [](relpath)
+      abspath = into_abspath(relpath)
+      if !lookup.key?(abspath)
+        raise "Don't know about this blob: #{abspath.inspect}"
       end
-    end
-    def routes_getter
-      LookupGetter.new(@lookup)
+      lookup[abspath]
     end
-    def layouts_getter
-      LookupGetter.new(@layouts_lookup)
+    def init(relpath, **initializer_options)
+      raise "Can't add more #{file_abstraction_class}s after the initial setup!" if @done
+      abspath = into_abspath(relpath)
+      lookup[abspath] ||= file_abstraction_class.new(input_path: abspath, **initializer_options)
+      yield lookup[abspath] if block_given?
+      lookup[abspath]
     end
-    class Setter
-      def initialize(lookup, &block)
-        @lookup = lookup
-        @block = block
+    def init_many(pattern)
+      files_lookup.filter_map do |relpath, abspath|
+        if pattern.match?(relpath)
+          lookup[abspath.to_s] ||= file_abstraction_class.new(input_path: abspath)
+        end
       end
+    end
-      def []=(key, value)
-        @block&.call(key, value)
+    private
-        @lookup[key] = value
-      end
+    def into_abspath(relpath)
+      scoped_root.concat(relpath).cleanpath
     end
-    class LookupGetter
-      def initialize(lookup)
-        @lookup = lookup
-      end
-      def [](key)
-        @lookup.fetch(key)
-      end
+    def files_lookup
+      @files_lookup ||=
+        scoped_root
+        .glob("**/*")
+        .map { |path| [path.relative_path_from(scoped_root).to_s, path] }
+        .to_h
     end
+    attr_accessor :scoped_root
+    attr_accessor :file_abstraction_class
+    attr_accessor :lookup
   end
   module Blob
     attr_accessor :input_path
+  end
+  module RouteableBlob
     attr_accessor :output_path
     attr_reader :url_path
-    def url_path=(path)
-      if path.nil?
-        @url_path = nil
-        return
-      end
+    def url_path=(new_url_path)
+      @url_path = new_url_path.normalize_for_route
+    end
+  end
-      path = path.to_s
-      if path[0] != "/"
-        path = "/#{path}"
-      end
+  module RenderableBlob
+    attr_reader :renderers
-      @url_path = path
+    def renderers=(new_renderers)
+      @renderers = Array(new_renderers)
     end
   end
   class Asset
     include Blob
+    include RouteableBlob
     def initialize(input_path:, entrypoint:)
       self.input_path = input_path
       @entrypoint = entrypoint
-      @url_path = nil
     end
-    attr_accessor :rendered_body
+    attr_accessor :body
     def entrypoint?
       !!@entrypoint
@@ -270,48 +324,90 @@ module Confinement
   class Content
     include Blob
+    include RouteableBlob
+    include RenderableBlob
-    def initialize(layout: nil, input_path: nil, locals: {}, renderers: [])
+    def initialize(input_path:, layout: nil, locals: {}, renderers: :guess)
       self.input_path = input_path
-      @layout = layout
-      @locals = locals
-      @renderers = renderers
+      self.layout = layout
+      self.locals = locals
+      self.renderers = renderers
     end
-    attr_reader :locals
-    attr_reader :renderers
-    attr_reader :layout
+    attr_accessor :locals
+    attr_accessor :layout
+    def body
+      parse_body_and_frontmatter
+      @body
+    end
+    def frontmatter
+      parse_body_and_frontmatter
+      @frontmatter
+    end
+    private
-    attr_accessor :rendered_body
+    def parse_body_and_frontmatter
+      return if defined?(@frontmatter) && defined?(@body)
+      @frontmatter, @body = input_path.read.frontmatter_and_body
+    end
   end
   class Layout
-    def initialize(renderers:)
-      @renderers = renderers
+    include Blob
+    include RenderableBlob
+    def initialize(input_path:, renderers: :guess)
+      self.input_path = input_path
+      self.renderers = renderers
     end
-    attr_reader :renderers
-    attr_accessor :input_path
+    def body
+      @body ||= input_path.read
+    end
   end
   class Renderer
+    def self.guesses
+      @guesses ||= {
+        "erb" => -> { Erb.new }
+      }
+    end
     class Erb
-      def call(source, view_context, &block)
-        method_name = "_#{Digest::MD5.hexdigest(source)}"
+      def call(source, view_context, path:, &block)
+        method_name =
+          if path
+            "_#{Digest::MD5.hexdigest(source)}__#{path.to_s.tr("^A-Za-z", "_")}"
+          else
+            "_#{Digest::MD5.hexdigest(source)}"
+          end
-        compile(method_name, source, view_context)
+        compile(method_name, source, view_context, path: path)
         view_context.public_send(method_name, &block)
       end
       private
-      def compile(method_name, source, view_context)
+      def compile(method_name, source, view_context, path:)
         if !view_context.respond_to?(method_name)
-          compiled_erb = Erubi::Engine.new(source).src
+          compiled_erb =
+            Erubi::CaptureEndEngine
+            .new(source, bufvar: :@_buf, ensure: true, yield_returns_buffer: true)
+            .src
+          eval_location =
+            if path
+              [path.to_s, 0]
+            else
+              []
+            end
-          view_context.instance_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          view_context.instance_eval(<<~RUBY, *eval_location)
             def #{method_name}
               #{compiled_erb}
             end
@@ -322,56 +418,73 @@ module Confinement
   end
   class Rendering
+    class Guesser
+      def initialize(guessing_registry)
+        @guessing_registry = guessing_registry
+      end
+      def call(path)
+        basename = path.basename.to_s
+        extensions = basename.split(".")[1..-1]
+        extensions.reverse.filter_map do |extension|
+          next if !@guessing_registry.key?(extension)
+          guess = @guessing_registry[extension]
+          guess = guess.call if guess.is_a?(Proc)
+          guess
+        end
+      end
+    end
     class ViewContext
-      def initialize(routes:, layouts:, locals:, frontmatter:, contents_path:, layouts_path:)
+      def initialize(routes:, layouts:, assets:, contents:, locals:, frontmatter:)
         @routes = routes
         @layouts = layouts
+        @assets = assets
+        @contents = contents
         @locals = locals
         @frontmatter = frontmatter
-        @contents_path = contents_path
-        @layouts_path = layouts_path
       end
       attr_reader :routes
       attr_reader :layouts
+      attr_reader :assets
+      attr_reader :contents
       attr_reader :locals
       attr_reader :frontmatter
-      attr_reader :contents_path
-      attr_reader :layouts_path
-      def render(path = nil, inline: nil, layout: nil, renderers:, &block)
-        body =
-          if inline
-            inline
-          elsif path
-            path.read
-          else
-            raise %(Must pass in either a Pathname or `inline: 'text'`)
-          end
+      def capture
+        original_buffer = @_buf
+        @_buf = +""
+        yield
+        @_buf
+      ensure
+        @_buf = original_buffer
+      end
+      def render(blob, layout: nil, &block)
         render_chain = RenderChain.new(
-          body: body,
-          layout: layout,
-          renderers: renderers,
+          body: blob.body,
+          path: blob.input_path,
+          renderers: blob.renderers,
           view_context: self
         )
-        rendered_body = render_chain.call(&block)
-        if layout
-          layout =
-            if layout.is_a?(Layout)
-              layout
-            elsif layout.is_a?(Pathname)
-              layouts[layout]
-            else
-              raise "Expected layout to be a Layout or Pathname"
+        rendered_body =
+          if block_given?
+            render_chain.call do
+              capture { yield }
             end
+          else
+            render_chain.call
+          end
+        if layout
           layout_render_chain = RenderChain.new(
-            body: layout.input_path.read,
-            layout: nil,
+            body: layout.body,
+            path: layout.input_path,
             renderers: layout.renderers,
             view_context: self
           )
@@ -386,22 +499,22 @@ module Confinement
     end
     class RenderChain
-      def initialize(body:, layout:, renderers:, view_context:)
+      def initialize(body:, path:, renderers:, view_context:)
         @body = body
-        @layout = layout
+        @path = path
         @renderers = renderers
         @view_context = view_context
       end
       def call(&block)
         @renderers.reduce(@body) do |memo, renderer|
-          renderer.call(memo, @view_context, &block)
+          renderer.call(memo, @view_context, path: @path, &block)
         end
       end
     end
   end
-  class HesitantCompiler
+  class Compiler
     def initialize(site)
       @site = site
       @lock = Mutex.new
@@ -414,8 +527,8 @@ module Confinement
       # to worry about deadlocks or anything
       @lock.synchronize do
         # Assets first since it's almost always a dependency of contents
-        compile_assets(site.representation.only_assets)
-        compile_contents(site.representation.only_contents)
+        compile_assets(site.asset_blobs.send(:lookup))
+        compile_contents(site.route_identifiers.send(:lookup).values)
       end
     end
@@ -424,79 +537,73 @@ module Confinement
     PARCEL_FILES_OUTPUT_REGEX = /^✨[^\n]+\n\n(.*)Done in(?:.*)\z/m
     PARCEL_FILE_OUTPUT_REGEX = /^(?<page>.*?)\s+(?<size>[0-9\.]+\s*[A-Z]?B)\s+(?<time>[0-9\.]+[a-z]?s)$/
-    def compile_assets(assets)
-      if assets_dirty?
-        out, status = Open3.capture2(
-          "yarn",
-          "run",
-          "parcel",
-          "build",
-          "--dist-dir", site.assets_root.to_s,
-          "--public-url", site.assets_root.basename.to_s,
-          *assets.select(&:entrypoint?).map(&:input_path).map(&:to_s)
-        )
-        if !status.success?
-          raise "Asset compilation failed"
-        end
+    def compile_assets(asset_files)
+      asset_paths = asset_files.values
+      out, status = Open3.capture2(
+        "yarn",
+        "run",
+        "parcel",
+        "build",
+        "--no-cache",
+        "--dist-dir", site.assets_root.to_s,
+        "--public-url", site.assets_root.basename.to_s,
+        *asset_paths.select(&:entrypoint?).map(&:input_path).map(&:to_s)
+      )
-        matches = PARCEL_FILES_OUTPUT_REGEX.match(out)[1]
+      if !status.success?
+        raise "Asset compilation failed"
+      end
-        if !matches
-          raise "Asset parsing failed"
-        end
+      matches = PARCEL_FILES_OUTPUT_REGEX.match(out)[1]
-        processed_file_paths = matches.split("\n\n")
+      if !matches
+        raise "Asset compilation output parsing failed"
+      end
-        representation_by_input_path =
-          site.representation.only_assets.filter_map do |page|
-            next if page.input_path.nil?
+      processed_file_paths = matches.split("\n\n")
-            [page.input_path, page]
-          end
-          .to_h
+      processed_file_paths.map do |file|
+        output_file, *input_files = file.strip.split(/\n(?:└|├)── /)
-        processed_file_paths.map do |file|
-          output_file, input_file = file.strip.split("\n└── ")
+        output_path = site.root.concat(output_file[PARCEL_FILE_OUTPUT_REGEX, 1])
-          output_path = site.root.concat(output_file[PARCEL_FILE_OUTPUT_REGEX, 1])
+        input_files.each do |input_file|
           input_path = site.root.concat(input_file[PARCEL_FILE_OUTPUT_REGEX, 1])
-          if !representation_by_input_path.key?(input_path)
+          if !asset_files.key?(input_path)
             next
           end
           url_path = output_path.relative_path_from(site.output_root)
-          representation_by_input_path[input_path].url_path = url_path.to_s
-          representation_by_input_path[input_path].output_path = output_path
-          representation_by_input_path[input_path].rendered_body = output_path.read
+          asset_files[input_path].url_path = url_path.to_s
+          asset_files[input_path].output_path = output_path
+          asset_files[input_path].body = output_path.read
         end
       end
     end
-    def compile_content(content)
-      if content.rendered_body
-        return
+    def compile_contents(contents)
+      contents.each do |content|
+        compile_content(content)
       end
+    end
-      content_body = content.input_path.read
-      frontmatter, content_body = content_body.frontmatter_and_body
+    def compile_content(content)
       view_context = Rendering::ViewContext.new(
-        routes: site.representation.routes_getter,
-        layouts: site.representation.layouts_getter,
+        routes: site.route_identifiers,
+        layouts: site.layout_blobs,
+        assets: site.asset_blobs,
+        contents: site.content_blobs,
         locals: content.locals,
-        frontmatter: frontmatter,
-        contents_path: site.contents_path,
-        layouts_path: site.layouts_path
+        frontmatter: content.frontmatter
       )
-      content.rendered_body = view_context.render(
-        inline: content_body,
-        layout: content.layout,
-        renderers: content.renderers
-      )
-      content.rendered_body ||= ""
+      site.view_context_helpers.each do |helper|
+        view_context.extend(helper)
+      end
+      rendered_body = view_context.render(content, layout: content.layout) || ""
       content.output_path =
         if content.url_path[-1] == "/"
@@ -506,7 +613,7 @@ module Confinement
         end
       if content.output_path.exist?
-        if content.output_path.read == content.rendered_body
+        if content.output_path.read == rendered_body
           return
         end
       end
@@ -519,38 +626,20 @@ module Confinement
         content.output_path.dirname.mkpath
       end
-      content.output_path.write(content.rendered_body)
+      content.output_path.write(rendered_body)
       nil
     end
-    def compile_contents(contents)
-      return if !contents_dirty?
-      contents.each do |content|
-        compile_content(content)
-      end
-    end
-    private
-    def contents_dirty?
-      true
-    end
-    def assets_dirty?
-      true
-    end
   end
   class Publish
     def initialize(site)
       @site = site
-      @compiler = HesitantCompiler.new(@site)
+      @compiler = Compiler.new(@site)
     end
-    def write(path)
-      find_or_raise_or_mkdir(path)
+    def write
+      find_or_raise_or_mkdir(@site.output_root)
       @compiler.compile_everything
     end

data/lib/confinement/version.rb CHANGED

@@ -1,3 +1,3 @@
 module Confinement
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

metadata CHANGED

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: confinement
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Zach Ahn
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-03-29 00:00:00.000000000 Z
+date: 2020-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler