munge 0.11.1 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f0e20dc4cac02d09e72094542c9b723b2b6af0ee
-  data.tar.gz: c405bf6eb3312c99c234a5efaa0fdb5257c8788b
+  metadata.gz: b3e1eb8424b81b08cb185b26e80273a94ff027f5
+  data.tar.gz: eb0dbd0f3a65fbd4ce2ab8b5e8aacc48158ee03c
 SHA512:
-  metadata.gz: b6e966358fe33155bed90bead4ca941d3de8dd612b8069ba699fa852941de7ff44e7116626999e1a368c0adda7435ced90462b63554878fe42c6f0295bda8862
-  data.tar.gz: 0827edc6fdd1d45682c0f9a22cac978fd7b8f1e6e69c50b6b3deae01f587411a1d0e559a1c3a18c37a37cf0a2a8dc5bd4b8cd10802742d0d9a92e5cf39053e3c
+  metadata.gz: fc9abaedb2d419a05eb69b45e14702e88438162df849749daa1b968b3617a6f271e5a4c89985a65adcf0c2ec2bebf5dc32298940bf9ac9e2bde95637eb8dd8e3
+  data.tar.gz: 814114a8a51a3e298687569cc7effde92cfb872304761633cf0df035c06f71734a7b4f6e672c009c0333627f2ea18f79c8cfc0147eb06b3bfb53806efda4f1cb

data/lib/munge/application.rb

@@ -1,31 +1,49 @@
 module Munge
+  # This class is one of the main interfaces users would interact with. This
+  # provides methods to create and iterate through items.
   class Application
     def initialize(system)
       @system = system
     end
 
+    # @return [Array<Item>]
     def items
       @system.items
     end
 
+    # @return [Array<Item>]
     def nonrouted
       items.select { |item| item.route.nil? }
     end
 
+    # @return [Array<Item>]
     def routed
       items.select(&:route)
     end
 
+    # Builds an Item
+    #
+    # @return [Item]
     def build_virtual_item(relpath, content, **frontmatter)
       @system.items.build(relpath: relpath, content: content, frontmatter: frontmatter)
     end
 
+    # Creates an Item and inserts it into the registry of Items.
+    #
+    # @see #build_virtual_item
+    # @param relpath [String]
+    # @param content [String]
+    # @param frontmatter [Hash]
+    # @return [Array<Item>]
     def create(*args)
       item = build_virtual_item(*args)
       @system.items.push(item)
       [item]
     end
 
+    # Returns parts of System
+    #
+    # @private
     def vomit(component_name)
       @system.public_send(component_name)
     end

data/lib/munge/bootloader.rb

@@ -1,5 +1,7 @@
 module Munge
+  # This class is useful for loading the application.
   class Bootloader
+    # @param root_path [String] Absolute path to munge directory
     def initialize(root_path:)
       @root_path   = root_path
       @config_path = File.join(root_path, "config.yml")
@@ -8,6 +10,7 @@ module Munge
       @config      = Munge::Util::Config.read(@config_path)
     end
 
+    # @return [Munge::Init]
     def init
       @init ||=
         Init.new(

data/lib/munge/cli/commands/build.rb

@@ -1,7 +1,12 @@
 module Munge
   module Cli
     module Commands
+      # This class is used by the CLI to build and calculate output
       class Build
+        # @param bootloader [Munge::Bootloader]
+        # @param dry_run [true, false]
+        # @param reporter [Munge::Reporters]
+        # @param build_root [String, nil]
         def initialize(bootloader, dry_run:, reporter:, verbosity:, build_root: nil)
           destination_root = bootloader.root_path
           config           = bootloader.config
@@ -12,7 +17,7 @@ module Munge
             Munge::Runner.new(
               items: app.vomit(:items),
               router: app.vomit(:router),
-              alterant: app.vomit(:alterant),
+              processor: app.vomit(:processor),
               writer: writer(dry_run),
               formatter: formatter(reporter),
               verbosity: verbosity.to_sym,

data/lib/munge/cli/commands/update.rb

@@ -0,0 +1,24 @@
+module Munge
+  module Cli
+    module Commands
+      class Update
+        include Thor::Base
+        include Thor::Actions
+
+        def self.source_root
+          File.expand_path("../../../../../seeds", __FILE__)
+        end
+
+        def initialize(_bootloader, path)
+          self.options = {}
+          self.destination_root = File.expand_path(path)
+        end
+
+        def call
+          directory("config", File.expand_path("config", destination_root))
+          copy_file("setup.rb")
+        end
+      end
+    end
+  end
+end

data/lib/munge/cli/commands/view.rb

@@ -27,7 +27,12 @@ require "rack"
 module Munge
   module Cli
     module Commands
+      # This class starts up a webserver useful for development
       class View
+        # @param bootloader [Munge::Bootloader]
+        # @param host [String]
+        # @param port [Numeric]
+        # @param build_root [String, nil]
         def initialize(bootloader, host:, port:, build_root: nil)
           config = bootloader.config
           @host  = host

data/lib/munge/cli/dispatch.rb

@@ -1,5 +1,6 @@
 module Munge
   module Cli
+    # This class directs commandline flags to appropriate classes
     class Dispatch < Thor
       desc "init PATH", "Create new site at PATH"
       def init(path)
@@ -33,7 +34,14 @@ module Munge
         Commands::Server.new(bootloader).call
       end
 
-      desc "version", "Print version"
+      desc "update", "Use with caution: override local configs with pristine version (useful after bumping version in Gemfile)"
+      def update
+        ENV["MUNGE_ENV"] ||= "development"
+
+        Commands::Update.new(bootloader, current_working_directory).call
+      end
+
+      desc "version", "Print version (v#{Munge::VERSION})"
       map %w(-v --version) => "version"
       def version
         puts "munge #{Munge::VERSION}"

data/lib/munge/cli.rb

@@ -5,6 +5,7 @@ require "munge/cli/commands/init"
 require "munge/cli/commands/build"
 require "munge/cli/commands/view"
 require "munge/cli/commands/server"
+require "munge/cli/commands/update"
 require "munge/cli/dispatch"
 
 require "munge/formatters/default"

data/lib/munge/formatters/dots.rb

@@ -2,17 +2,8 @@ module Munge
   module Formatters
     class Dots
       def initialize
-        @counts = {
-          new:       0,
-          changed:   0,
-          identical: 0
-        }
-
-        @relpaths = {
-          new:       [],
-          changed:   [],
-          identical: []
-        }
+        @counts = Hash.new { 0 }
+        @relpaths = Hash.new { [] }
 
         @dots = {
           new:       Rainbow("W").green,
@@ -29,7 +20,7 @@ module Munge
         @counts[write_status] += 1
 
         if should_print
-          @relpaths[write_status].push(relpath)
+          @relpaths[write_status] += [relpath]
         end
 
         print @dots[write_status]

data/lib/munge/go/sass.rb

@@ -5,10 +5,19 @@ module Munge
   module Go
     module_function
 
+    # Appends a path to Sass's load paths. To append multiple paths, call the
+    # function multiple times.
+    #
+    # @param paths [Array<String>, String] path or components of path
+    # @return [void]
     def add_sass_load_path!(*paths)
       Sass.load_paths << File.join(*paths)
     end
 
+    # Sets {Munge::System} for use with plugins
+    #
+    # @param system [Munge::System]
+    # @return [void]
     # rubocop:disable Style/AccessorMethodName
     def set_sass_system!(system)
       Sass::Script::Functions.send(:define_method, :system) do
@@ -17,6 +26,10 @@ module Munge
     end
     # rubocop:enable Style/AccessorMethodName
 
+    # Includes methods into Sass functions scope
+    #
+    # @param asset_roots [Module]
+    # @return [void]
     def add_sass_functions!(asset_roots)
       Sass::Script::Functions.send(:include, asset_roots)
     end

data/lib/munge/helpers/capture.rb

@@ -6,13 +6,13 @@ module Munge
           original_erbout = block.binding.local_variable_get(:_erbout)
           block.binding.local_variable_set(:_erbout, "")
 
-          captured_text = block.call
+          captured_text = yield
 
           block.binding.local_variable_set(:_erbout, original_erbout)
 
           captured_text
         else
-          block.call
+          yield
         end
       end
 

data/lib/munge/helpers/find.rb

@@ -2,11 +2,11 @@ module Munge
   module Helpers
     module Find
       def items
-        @items
+        system.items
       end
 
       def layouts
-        @layouts
+        system.layouts
       end
     end
   end

data/lib/munge/helpers/link.rb

@@ -1,33 +1,28 @@
 module Munge
   module Helpers
     module Link
-      def path_to(item)
-        @router.route(item)
+      def path_to(itemish)
+        item =
+          if item.is_a?(String)
+            system.items[itemish]
+          else
+            itemish
+          end
+
+        system.router.route(item)
       end
 
-      def link_to(item, text = nil, opts = {})
-        link = path_to(item)
+      def link_to(itemish, text = nil, opts = {})
+        link = path_to(itemish)
 
         if text.is_a?(Hash)
           opts = text
           text = nil
         end
 
-        optstr = opts.map { |key, val| %(#{key}="#{val}") }
-
-        parts =
-          [
-            [
-              "<a",
-              %(href="#{link}"),
-              optstr
-            ].flatten.join(" "),
-            ">",
-            text || link,
-            "</a>"
-          ]
+        href_with_options = { href: link }.merge(opts)
 
-        parts.join
+        content_tag(:a, text || link, href_with_options)
       end
     end
   end

data/lib/munge/helpers/rendering.rb

@@ -27,15 +27,11 @@ module Munge
 
         output =
           engines
-            .inject(content) do |memo, engine|
-              options  = @tilt_options[engine]
-              template = engine.new(template_name, options) { memo }
-
-              if inner
-                template.render(self, data) { inner }
-              else
-                template.render(self, data)
-              end
+            .reduce(content) do |memoized_content, engine|
+              options  = tilt_options[engine]
+              template = engine.new(template_name, options) { memoized_content }
+
+              template.render(self, data) { inner }
             end
 
         if block_given?
@@ -62,19 +58,16 @@ module Munge
 
       def merged_data(*data)
         hash_with_string_and_symbol_keys =
-          data.inject(@global_data) do |merged, datum|
+          data.reduce(system.global_data) do |merged, datum|
             merged.merge(datum)
           end
 
-        hash_with_string_and_symbol_keys
-          .each_with_object({}) do |(key, value), memo|
-            memo[key.to_sym] = value
-          end
+        Munge::Util::SymbolHash.deep_convert(hash_with_string_and_symbol_keys)
       end
 
       def resolve_layout(item_or_string)
         if item_or_string.is_a?(String)
-          @layouts[item_or_string]
+          system.layouts[item_or_string]
         else
           item_or_string
         end

data/lib/munge/helpers/tag.rb

@@ -32,7 +32,7 @@ module Munge
       end
 
       def h(string)
-        CGI.escape_html(string)
+        CGI.escape_html(string.to_s)
       end
     end
   end

data/lib/munge/init.rb

@@ -1,5 +1,8 @@
 module Munge
+  # This class loads the user rules, as well as provides some useful methods
+  # for setup.
   class Init
+    # Initializing loads up the user's `setup.rb` and `rules.rb`.
     def initialize(root_path:,
                    config:,
                    setup_path:,
@@ -21,10 +24,14 @@ module Munge
       @app.items.freeze
     end
 
+    # @return [String] path to user's `config/` directory
     def config_path
       File.join(root_path, "config")
     end
 
+    # Loads file into current scope. Similar to `load "filename.rb"`
+    #
+    # @return [void]
     def import(file_path)
       absolute_file_path = File.expand_path(file_path, root_path)
       contents           = File.read(absolute_file_path)

data/lib/munge/item.rb

@@ -1,4 +1,5 @@
 module Munge
+  # Items are the core data object for building and manipulating pages.
   class Item
     def initialize(type:,
                    relpath:,
@@ -25,63 +26,88 @@ module Munge
 
     attr_reader :layout, :transforms
 
+    # @return [String] dirname without leading "."
     def dirname
-      if File.dirname(@relpath) == "."
-        ""
-      else
-        File.dirname(@relpath)
-      end
+      Munge::Util::Path.dirname(@relpath)
     end
 
+    # @return [String] filename
     def filename
-      File.basename(@relpath)
+      Munge::Util::Path.basename(@relpath)
     end
 
+    # @return [String] filename before the first "."
     def basename
-      filename.split(".").first
+      Munge::Util::Path.basename_no_extension(@relpath)
     end
 
+    # @return [Array<String>] extensions (everything following the first ".")
     def extensions
-      filename.split(".")[1..-1]
+      Munge::Util::Path.extnames(@relpath)
     end
 
+    # @param key [String]
     def [](key)
       @frontmatter[key]
     end
 
+    # @param key [String]
     def []=(key, value)
       @frontmatter[key] = value
     end
 
+    # @param new_route [String] the compiled route to this item
+    # @return [String] sanitized version of input
     def route=(new_route)
       @route = remove_surrounding_slashes(new_route)
     end
 
+    # @return [String, nil] absolute route to this item, if set
     def route
       if @route
         "/#{@route}"
       end
     end
 
+    # Runs a regex match to see if item was found in the specified directory.
+    # Do not query with any slashes. Each argument will automatically be joined
+    # by slashes. Note though that the string will be converted into a regex.
+    #
+    # @param *subdir_patterns [Array<String>]
+    # @return [true, false] whether or not this item was found in specified
+    #   subdirectory
     def relpath?(*subdir_patterns)
       regexp = generate_regex(subdir_patterns)
-      regexp === @relpath
+      Munge::Util::BooleanRegex.match?(regexp, @relpath)
     end
 
-    # do not query with slashes
+    # Runs a regex match to see if the item matches a route. See #relpath?
+    #
+    # @param *subdir_patterns [Array<String>]
+    # @return [true, false] whether or not this route belongs to specified
+    #   subdirectory
     def route?(*subdir_patterns)
       regexp = generate_regex(subdir_patterns)
-      regexp === @route
+      Munge::Util::BooleanRegex.match?(regexp, @route)
     end
 
+    # @param new_layout [String] layout to apply onto this item
+    # @return [String] sanitized version of the input
     def layout=(new_layout)
       @layout = remove_surrounding_slashes(new_layout)
     end
 
+    # @param transformer [Symbol] name of transformer to apply onto item when
+    #   building
+    # @param *args
+    # @return [void]
     def transform(transformer = :tilt, *args)
       @transforms.push([transformer, args])
     end
 
+    # Deep freeze. Freezes all instance variables as well as itself.
+    #
+    # @return [void]
     def freeze
       freeze_all_instance_variables
 

data/lib/munge/runner.rb

@@ -1,9 +1,9 @@
 module Munge
   class Runner
-    def initialize(items:, router:, alterant:, writer:, formatter:, verbosity:, destination:)
+    def initialize(items:, router:, processor:, writer:, formatter:, verbosity:, destination:)
       @items         = items
       @router        = router
-      @alterant      = alterant
+      @processor     = processor
       @writer        = writer
       @reporter      = Munge::Reporter.new(formatter: formatter, verbosity: verbosity)
       @write_manager = Munge::WriteManager.new(driver: File)
@@ -25,7 +25,7 @@ module Munge
     def render_and_write(item)
       relpath = @router.filepath(item)
       abspath = File.join(@destination, relpath)
-      content = @alterant.transform(item)
+      content = @processor.transform(item)
 
       write_status = @write_manager.status(abspath, content)
 

data/lib/munge/system/collection.rb

@@ -1,8 +1,11 @@
 module Munge
   class System
+    # This class is effectively an Array of Items
     class Collection
       include Enumerable
 
+      # @param [System::ItemFactory] item_factory
+      # @param [Array<Hash>] items
       def initialize(item_factory:,
                      items:)
         @item_factory = item_factory
@@ -14,14 +17,25 @@ module Munge
             .to_h
       end
 
+      # @see System::ItemFactory#build
+      # @param relpath [String]
+      # @param content [String]
+      # @param frontmatter [Hash]
+      # @param stat [File::Stat]
       def build(**args)
         @item_factory.build(**prune_args(args))
       end
 
+      # @see System::ItemFactory#parse
+      # @param relpath [String]
+      # @param content [String]
+      # @param stat [File::Stat]
       def parse(**args)
         @item_factory.parse(**prune_args(args))
       end
 
+      # @yield [Item]
+      # @return [Enumerator]
       def each
         return enum_for(:each) unless block_given?
 
@@ -30,19 +44,24 @@ module Munge
         end
       end
 
-      def push(virtual_item)
-        key = virtual_item.id
-        @items[key] = virtual_item
+      # @param item [Item]
+      # @return [void]
+      def push(item)
+        if @items.key?(item.id)
+          raise "item with id `#{item.id}` already exists"
+        else
+          @items[item.id] = item
+        end
       end
 
+      # @param id [String] ID of item
+      # @return [Item]
       def [](id)
-        found_item = @items[id]
-
-        if found_item.nil?
+        if @items.key?(id)
+          @items[id]
+        else
           raise "item not found (#{id})"
         end
-
-        found_item
       end
 
       def freeze

data/lib/munge/system/item_factory.rb

@@ -1,17 +1,25 @@
 module Munge
   class System
     class ItemFactory
+      # @param text_extensions [Array<String>]
+      # @param ignore_extensions [Array<String>] Strings are converted to regex
       def initialize(text_extensions:,
                      ignore_extensions:)
         @text_extensions = Set.new(text_extensions)
         @item_identifier = ItemIdentifier.new(remove_extensions: ignore_extensions)
       end
 
+      # Builds an Item
+      #
+      # @param relpath [String]
+      # @param content [String]
+      # @param frontmatter [Hash]
+      # @param stat [File::Stat]
       def build(relpath:,
                 content:,
                 frontmatter: {},
                 stat: nil)
-        type = compute_file_type(relpath)
+        type = item_file_type(relpath)
 
         id = @item_identifier.call(relpath)
 
@@ -25,28 +33,28 @@ module Munge
         )
       end
 
+      # Parses frontmatter and builds an Item, given a text string
+      #
+      # @param relpath [String]
+      # @param content [String]
+      # @param stat [File::Stat]
       def parse(relpath:,
                 content:,
                 stat: nil)
-        type = compute_file_type(relpath)
+        normalized_content, normalized_frontmatter =
+          if item_file_type(relpath) == :text
+            parsed = ContentParser.new(content)
+            [parsed.content, parsed.frontmatter]
+          else
+            [content, {}]
+          end
 
-        if type == :text
-          parsed = ContentParser.new(content)
-
-          build(
-            relpath: relpath,
-            content: parsed.content,
-            frontmatter: parsed.frontmatter,
-            stat: stat
-          )
-        else
-          build(
-            relpath: relpath,
-            content: content,
-            frontmatter: {},
-            stat: stat
-          )
-        end
+        build(
+          relpath: relpath,
+          content: normalized_content,
+          frontmatter: normalized_frontmatter,
+          stat: stat
+        )
       end
 
       private
@@ -56,7 +64,7 @@ module Munge
         Set.new(extensions)
       end
 
-      def compute_file_type(abspath)
+      def item_file_type(abspath)
         exts = file_extensions(abspath)
 
         if exts.intersect?(@text_extensions)

data/lib/munge/system/{alterant.rb → processor.rb}

@@ -1,15 +1,22 @@
 module Munge
   class System
-    class Alterant
+    class Processor
       def initialize
         @registry = {}
       end
 
+      # Register tranformer
+      #
+      # @see Munge::Transformers::Tilt
       def register(transformer)
         register_manually(transformer.name, transformer)
       end
 
-      # name should be snake_case Symbol
+      # Register transformer manually
+      #
+      # @see Munge::Transformers::Tilt
+      # @param name [Symbol] Snake case name
+      # @param transformer [#call]
       def register_manually(name, transformer)
         if @registry.key?(name)
           raise "already registered transformer `#{name}`"
@@ -18,10 +25,13 @@ module Munge
         end
       end
 
+      # Transforms the given item's content
+      #
+      # @param item [Item]
       def transform(item)
         item.transforms
           .map { |name, args| [get_transformer(name), args] }
-          .inject(item.content) do |content, params|
+          .reduce(item.content) do |content, params|
             transformer, args = params
 
             transformer.call(item, content, *args)

data/lib/munge/system/readers/filesystem.rb

@@ -1,13 +1,17 @@
 module Munge
   class System
     module Readers
+      # Enumerable list of {Munge::Item}s
       class Filesystem
         include Enumerable
 
+        # @param source_path [String]
         def initialize(source_path)
           @source_path = source_path
         end
 
+        # @yield [Item]
+        # @return [Enumerator]
         def each
           return enum_for(:each) unless block_given?
 

data/lib/munge/system/router/itemish.rb

@@ -4,13 +4,13 @@ module Munge
       class Itemish
         extend Forwardable
 
-        def initialize(item, alterant)
-          @item     = item
-          @alterant = alterant
+        def initialize(item, processor)
+          @item      = item
+          @processor = processor
         end
 
         def compiled_content
-          @compiled_content ||= @alterant.transform(@item)
+          @compiled_content ||= @processor.transform(@item)
         end
 
         def_delegators :@item, *%i(type relpath id frontmatter stat layout)

data/lib/munge/system/router.rb

@@ -1,9 +1,9 @@
 module Munge
   class System
     class Router
-      def initialize(alterant:)
+      def initialize(processor:)
         @registries = { route: [], filepath: [] }
-        @alterant = alterant
+        @processor = processor
       end
 
       def register(router)
@@ -35,11 +35,11 @@ module Munge
           raise "item `#{item.relpath}` has no route"
         end
 
-        itemish = Itemish.new(item, @alterant)
+        itemish = Itemish.new(item, @processor)
 
         @registries[method_name]
           .select { |router| router.type == method_name }
-          .inject(initial_route || item.route) do |route, router|
+          .reduce(initial_route || item.route) do |route, router|
             if router.match?(route, itemish)
               router.call(route, itemish)
             else

data/lib/munge/system.rb

@@ -1,25 +1,19 @@
 module Munge
   class System
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     def initialize(root_path, config)
-      source_path  = File.expand_path(config[:source], root_path)
-      layouts_path = File.expand_path(config[:layouts], root_path)
-      data_path    = File.expand_path(config[:data], root_path)
+      @root_path = root_path
+      @config = config
+    end
 
-      @global_data = YAML.load_file(data_path) || {}
+    def items
+      return @items if @items
 
-      @config = config
+      source_path = File.expand_path(@config[:source], @root_path)
 
       source_item_factory =
         ItemFactory.new(
-          text_extensions: config[:text_extensions] + config[:bintext_extensions],
-          ignore_extensions: config[:dynamic_extensions]
-        )
-
-      layouts_item_factory =
-        ItemFactory.new(
-          text_extensions: config[:text_extensions] + config[:bintext_extensions],
-          ignore_extensions: %w(.+)
+          text_extensions: @config[:text_extensions] + @config[:bintext_extensions],
+          ignore_extensions: @config[:dynamic_extensions]
         )
 
       @items =
@@ -27,27 +21,44 @@ module Munge
           item_factory: source_item_factory,
           items: Readers::Filesystem.new(source_path)
         )
+    end
+
+    def layouts
+      return @layouts if @layouts
+
+      layouts_path = File.expand_path(@config[:layouts], @root_path)
 
-      @layouts =
+      layouts_item_factory =
+        ItemFactory.new(
+          text_extensions: @config[:text_extensions] + @config[:bintext_extensions],
+          ignore_extensions: %w(.+)
+        )
+
+      @layouts ||=
         Collection.new(
           item_factory: layouts_item_factory,
           items: Readers::Filesystem.new(layouts_path)
         )
+    end
 
-      @alterant =
-        Alterant.new
+    def processor
+      @processor ||= Processor.new
+    end
 
-      @router =
+    def router
+      @router ||=
         Router.new(
-          alterant: @alterant
+          processor: processor
         )
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-    attr_accessor :alterant
-    attr_accessor :config
-    attr_accessor :global_data
-    attr_accessor :router
-    attr_accessor :items
+    def global_data
+      return @global_data if @global_data
+
+      data_path = File.expand_path(@config[:data], @root_path)
+      @global_data = YAML.load_file(data_path) || {}
+    end
+
+    attr_reader :config
   end
 end

data/lib/munge/transformers/tilt_transformer.rb

@@ -1,10 +1,10 @@
 module Munge
   module Transformers
     class TiltTransformer
-      def initialize(scope)
-        @pristine_scope = scope
-        @registry       = []
-        @demands        = Hash.new { Hash.new }
+      def initialize(system)
+        @system = system
+        @registry = []
+        @demands = Hash.new { Hash.new }
       end
 
       def name
@@ -12,11 +12,10 @@ module Munge
       end
 
       def call(item, content = nil, renderer = nil)
-        scope = @pristine_scope.dup
-        scope.instance_variable_set(:@renderer, @renderer)
-        dirty_scope = extend_with_helpers(scope)
-        dirty_scope.instance_variable_set(:@tilt_options, @demands)
-        dirty_scope.render_with_layout(item, content_engines: renderer, content_override: content)
+        scope = Scope.new(@system.clone, @demands)
+        @registry.each { |helpers| scope.extend(helpers) }
+
+        scope.render_with_layout(item, content_engines: renderer, content_override: content)
       end
 
       def register(helper)
@@ -27,11 +26,14 @@ module Munge
         @demands[tilt_template] = @demands[tilt_template].merge(options)
       end
 
-      private
+      class Scope
+        def initialize(system, tilt_options)
+          @system = system
+          @tilt_options = tilt_options
+        end
 
-      def extend_with_helpers(scope)
-        @registry
-          .inject(scope) { |a, e| a.extend(e) }
+        attr_reader :system
+        attr_reader :tilt_options
       end
     end
   end

data/lib/munge/util/boolean_regex.rb

@@ -0,0 +1,13 @@
+module Munge
+  module Util
+    class BooleanRegex
+      def self.match?(pattern, string)
+        if pattern =~ string
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/munge/util/path.rb

@@ -2,26 +2,29 @@ module Munge
   module Util
     class Path
       def self.dirname(path)
-        path_parts = path.split("/")
-        path_parts[0..-2].join("/")
+        if File.dirname(path) == "."
+          ""
+        else
+          File.dirname(path)
+        end
       end
 
       def self.extname(path)
-        basename = File.basename(path)
-        basename_parts = basename.split(".")
+        filename = basename(path)
+        filename_parts = filename.split(".")
 
-        if basename_parts.length > 1
-          basename_parts[-1]
+        if filename_parts.length > 1
+          filename_parts[-1]
         else
           ""
         end
       end
 
       def self.extnames(path)
-        basename = File.basename(path)
-        basename_parts = basename.split(".")
+        filename = basename(path)
+        filename_parts = filename.split(".")
 
-        basename_parts[1..-1]
+        filename_parts[1..-1]
       end
 
       def self.basename(path)
@@ -29,10 +32,10 @@ module Munge
       end
 
       def self.basename_no_extension(path)
-        basename = File.basename(path)
-        basename_parts = basename.split(".")
+        filename = basename(path)
+        filename_parts = filename.split(".")
 
-        basename_parts[0] || ""
+        filename_parts[0] || ""
       end
 
       def self.path_no_extension(path)

data/lib/munge/version.rb

@@ -1,3 +1,3 @@
 module Munge
-  VERSION = "0.11.1".freeze
+  VERSION = "0.12.0".freeze
 end

data/lib/munge/write_manager.rb

@@ -1,10 +1,15 @@
 module Munge
+  # This class decides whether an item needs to be written.
   class WriteManager
+    # @param driver [#exist?, #read]
     def initialize(driver:)
       @driver      = driver
       @write_paths = []
     end
 
+    # @param path [String] absolute path to file
+    # @param content [String] new content of file
+    # @return [Symbol] `:double_write_error`, `:identical`, `:different`
     def status(path, content)
       if @write_paths.include?(path)
         return :double_write_error

data/lib/munge/writers/filesystem.rb

@@ -1,6 +1,13 @@
 module Munge
   module Writers
+    # Filesystem driver for writing files. These drivers can be defined however
+    # you wish, as long as the `#write` method accepts an abspath and content.
     class Filesystem
+      # Writes content to abspath. Nonexistent directories will be created
+      # automatically.
+      #
+      # @param abspath [String]
+      # @param content [String]
       def write(abspath, content)
         FileUtils.mkdir_p(File.dirname(abspath))
 

data/lib/munge/writers/noop.rb

@@ -1,6 +1,11 @@
 module Munge
   module Writers
+    # NoOp driver for writing files. This is used to compute dry-runs.
     class Noop
+      # Pretends to write, but actually does nothing
+      #
+      # @param _abspath [String]
+      # @param _content [String]
       def write(_abspath, _content)
       end
     end

data/lib/munge.rb

@@ -19,6 +19,7 @@ require "munge/item"
 require "munge/util/path"
 require "munge/util/symbol_hash"
 require "munge/util/config"
+require "munge/util/boolean_regex"
 require "munge/system/router"
 require "munge/system/router/itemish"
 require "munge/system/item_factory"
@@ -26,7 +27,7 @@ require "munge/system/item_factory/content_parser"
 require "munge/system/item_factory/item_identifier"
 require "munge/system/collection"
 require "munge/system/readers/filesystem"
-require "munge/system/alterant"
+require "munge/system/processor"
 require "munge/system"
 require "munge/writers/filesystem"
 require "munge/writers/noop"

data/munge.gemspec

@@ -36,6 +36,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "timecop", "~> 0.8"
   spec.add_development_dependency "codeclimate-test-reporter", "~> 0.4"
   spec.add_development_dependency "simplecov", "~> 0.10"
+  spec.add_development_dependency "yard", "~> 0.9.0"
 
   spec.add_runtime_dependency "adsf", "~> 1.2"
   spec.add_runtime_dependency "listen", "~> 3.0", "< 3.1"
@@ -43,4 +44,8 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "rainbow", ">= 1.99.1", "< 3.0"
   spec.add_runtime_dependency "tilt", "~> 2.0"
   spec.add_runtime_dependency "sass", "~> 3.4"
+
+  if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.3")
+    spec.add_runtime_dependency "rack", ">= 1.0", "< 2.0"
+  end
 end

data/seeds/config/view_helpers.rb

@@ -8,4 +8,4 @@ tilt_transformer.register(Munge::Helpers::AssetPaths)
 tilt_transformer.register(Munge::Helpers::AssetTags)
 tilt_transformer.register(AssetRoots)
 
-system.alterant.register(tilt_transformer)
+system.processor.register(tilt_transformer)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: munge
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 0.12.0
 platform: ruby
 authors:
 - Zach Ahn
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-06-09 00:00:00.000000000 Z
+date: 2016-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -178,6 +178,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
 - !ruby/object:Gem::Dependency
   name: adsf
   requirement: !ruby/object:Gem::Requirement
@@ -274,7 +288,27 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
-description: Documentation for this release is located in https://github.com/zachahn/munge/blob/v0.11.1/README.md
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Documentation for this release is located in https://github.com/zachahn/munge/blob/v0.12.0/README.md
 email:
 - zach.ahn@gmail.com
 executables:
@@ -293,6 +327,7 @@ files:
 - lib/munge/cli/commands/build.rb
 - lib/munge/cli/commands/init.rb
 - lib/munge/cli/commands/server.rb
+- lib/munge/cli/commands/update.rb
 - lib/munge/cli/commands/view.rb
 - lib/munge/cli/dispatch.rb
 - lib/munge/formatters/default.rb
@@ -315,15 +350,16 @@ files:
 - lib/munge/routers/remove_index_basename.rb
 - lib/munge/runner.rb
 - lib/munge/system.rb
-- lib/munge/system/alterant.rb
 - lib/munge/system/collection.rb
 - lib/munge/system/item_factory.rb
 - lib/munge/system/item_factory/content_parser.rb
 - lib/munge/system/item_factory/item_identifier.rb
+- lib/munge/system/processor.rb
 - lib/munge/system/readers/filesystem.rb
 - lib/munge/system/router.rb
 - lib/munge/system/router/itemish.rb
 - lib/munge/transformers/tilt_transformer.rb
+- lib/munge/util/boolean_regex.rb
 - lib/munge/util/config.rb
 - lib/munge/util/path.rb
 - lib/munge/util/symbol_hash.rb
@@ -376,3 +412,4 @@ signing_key:
 specification_version: 4
 summary: Static site generator aiming to simplify complex build rules
 test_files: []
+has_rdoc: