munge 0.18.0 → 0.19.0

data/lib/munge/{extras → extra}/livereload/update_client.rb

@@ -1,5 +1,5 @@
 module Munge
-  module Extras
+  module Extra
     module Livereload
       class UpdateClient
         include Celluloid

data/lib/munge/{extras → extra}/livereload/update_server.rb

@@ -1,5 +1,5 @@
 module Munge
-  module Extras
+  module Extra
     module Livereload
       class UpdateServer
         include Celluloid

data/lib/munge/{formatters → formatter}/default.rb

@@ -1,5 +1,5 @@
 module Munge
-  module Formatters
+  module Formatter
     class Default
       def initialize
         @new_count = 0

data/lib/munge/{formatters → formatter}/dots.rb

@@ -1,5 +1,5 @@
 module Munge
-  module Formatters
+  module Formatter
     class Dots
       def initialize
         @counts = Hash.new { 0 }

data/lib/munge/{formatters → formatter}/silent.rb

@@ -1,5 +1,5 @@
 module Munge
-  module Formatters
+  module Formatter
     class Silent
       def call(_item, _relpath, _write_status, _should_print)
       end

data/lib/munge/function/clean.rb

@@ -0,0 +1,18 @@
+module Munge
+  module Function
+    class Clean
+      def initialize(memory:, destination:)
+        @memory = memory
+        @destination = destination
+      end
+
+      def call
+        orphans = @destination.tree - @memory.tree
+
+        orphans.each do |orphan|
+          @destination.rm(orphan)
+        end
+      end
+    end
+  end
+end

data/lib/munge/function/write.rb

@@ -0,0 +1,68 @@
+module Munge
+  module Function
+    class Write
+      def initialize(conglomerate:, reporter:, manager:, destination:)
+        @items = conglomerate.items
+        @router = conglomerate.router
+        @processor = conglomerate.processor
+        @reporter = reporter
+        @manager = manager
+        @vfs = destination
+        @written_paths = []
+      end
+
+      def call
+        @reporter.start
+
+        @items
+          .reject { |item| item.route.nil? }
+          .each { |item| render_and_write(item) }
+
+        @reporter.done
+
+        @manager.written_routes
+      end
+
+      private
+
+      def render_and_write(item)
+        relpath = @router.filepath(item)
+        route = @router.route(item)
+        content = @processor.transform(item)
+
+        write_status = status(relpath, content)
+
+        case write_status
+        when :new
+          @manager.on_new(route, relpath, content)
+        when :changed
+          @manager.on_changed(route, relpath, content)
+        when :identical
+          @manager.on_identical(route, relpath, content)
+        when :double_write_error
+          raise Error::DoubleWriteError, item.route
+        end
+
+        @reporter.call(item, relpath, write_status)
+      end
+
+      def status(path, content)
+        if @written_paths.include?(path)
+          return :double_write_error
+        end
+
+        @written_paths.push(path)
+
+        if !@vfs.exist?(path)
+          return :new
+        end
+
+        if @vfs.read(path) == content
+          return :identical
+        end
+
+        :changed
+      end
+    end
+  end
+end

data/lib/munge/go/sass.rb

@@ -14,13 +14,13 @@ module Munge
       Sass.load_paths << File.join(*paths)
     end
 
-    # Sets {Munge::System} for use with plugins
+    # Sets {Munge::Conglomerate} for use with plugins
     #
-    # @param system [Munge::System]
+    # @param conglomerate [Munge::Conglomerate]
     # @return [void]
-    def set_sass_system!(system)
-      Sass::Script::Functions.send(:define_method, :system) do
-        system
+    def set_sass_conglomerate!(conglomerate)
+      Sass::Script::Functions.send(:define_method, :conglomerate) do
+        conglomerate
       end
     end
 

data/lib/munge/go/sass/asset_urls.rb

@@ -34,8 +34,8 @@ module Sass::Script::Functions
   def asset_route_helper(root, basename)
     basename_string = stringify_string(basename)
 
-    item = system.items["#{root}/#{basename_string}"]
-    r = system.router.route(item)
+    item = conglomerate.items["#{root}/#{basename_string}"]
+    r = conglomerate.router.route(item)
 
     quoted_string(r)
   end

data/lib/munge/{helpers → helper}/asset_paths.rb

@@ -1,5 +1,5 @@
 module Munge
-  module Helpers
+  module Helper
     module AssetPaths
       def image_path(basename)
         item = items["#{images_root}/#{basename}"]

data/lib/munge/{helpers → helper}/asset_tags.rb

@@ -1,5 +1,5 @@
 module Munge
-  module Helpers
+  module Helper
     module AssetTags
       def stylesheet_tag(basename, options = {})
         options[:rel] ||= "stylesheet"

data/lib/munge/{helpers → helper}/capture.rb

@@ -1,5 +1,5 @@
 module Munge
-  module Helpers
+  module Helper
     module Capture
       def capture(&block)
         if block.binding.local_variable_defined?(:_erbout)

data/lib/munge/helper/data.rb

@@ -0,0 +1,21 @@
+module Munge
+  module Helper
+    module Data
+      def data_stack
+        @data_stack ||= []
+      end
+
+      def globals
+        data_stack[0]
+      end
+
+      def instance
+        data_stack[1]
+      end
+
+      def frontmatter
+        data_stack.last
+      end
+    end
+  end
+end

data/lib/munge/helper/define_module.rb

@@ -0,0 +1,13 @@
+module Munge
+  module Helper
+    module DefineModule
+      def self.new(name, value)
+        Module.new do
+          define_method(name) do
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/munge/{helpers → helper}/find.rb

@@ -1,12 +1,12 @@
 module Munge
-  module Helpers
+  module Helper
     module Find
       def items
-        system.items
+        conglomerate.items
       end
 
       def layouts
-        system.layouts
+        conglomerate.layouts
       end
     end
   end

data/lib/munge/{helpers → helper}/link.rb

@@ -1,15 +1,15 @@
 module Munge
-  module Helpers
+  module Helper
     module Link
       def path_to(itemish)
         item =
           if itemish.is_a?(String)
-            system.items[itemish]
+            conglomerate.items[itemish]
           else
             itemish
           end
 
-        system.router.route(item)
+        conglomerate.router.route(item)
       end
 
       def link_to(itemish, text = nil, opts = {})

data/lib/munge/{helpers → helper}/livereload.rb

@@ -1,5 +1,5 @@
 module Munge
-  module Helpers
+  module Helper
     module Livereload
       def livereload_script(force: false)
         should_show = ENV["MUNGE_ENV"] == "development" && Gem.loaded_specs.key?("reel")

data/lib/munge/helper/rendering.rb

@@ -0,0 +1,51 @@
+module Munge
+  module Helper
+    module Rendering
+      def render(item, engines: :use_extensions, data: {})
+        merged_data = item.frontmatter.merge(data)
+        inner_view_scope = current_view_scope.clone
+        inner_view_scope.instance_variable_set(:@data_stack, data_stack.dup)
+        inner_view_scope.data_stack.push(merged_data)
+
+        conglomerate.processor.private_transform(
+          filename: item.relpath,
+          content: item.content,
+          view_scope: inner_view_scope,
+          engines: [engines].flatten.compact
+        )
+      end
+
+      def layout(item_or_string, data: {}, &block)
+        layout_item =
+          if item_or_string.is_a?(String)
+            conglomerate.layouts[item_or_string]
+          else
+            item_or_string
+          end
+
+        inner_as_block =
+          if block_given?
+            inner = capture(&block)
+            -> { inner }
+          else
+            nil
+          end
+
+        output =
+          conglomerate.processor.private_transform(
+            filename: "(layout) #{layout_item.relpath}",
+            content: layout_item.content,
+            view_scope: current_view_scope.clone,
+            engines: %i[use_extensions],
+            block: inner_as_block
+          )
+
+        if block_given?
+          append_to_erbout(block.binding, output)
+        end
+
+        output
+      end
+    end
+  end
+end

data/lib/munge/{helpers → helper}/tag.rb

@@ -1,5 +1,5 @@
 module Munge
-  module Helpers
+  module Helper
     module Tag
       def empty_tag(name, options = {})
         options_str = options.map { |k, v| %(#{k}="#{h(v)}") }.join(" ")
@@ -17,23 +17,19 @@ module Munge
           content = nil
         end
 
-        options_str =
+        html_attributes =
           if options.any?
             " " + options.map { |k, v| %(#{k}="#{h(v)}") }.join(" ")
-          else
-            ""
           end
 
-        content_str =
+        inner_html =
           if content
             content
           elsif block_given?
             capture(&block)
-          else
-            ""
           end
 
-        "<#{name}#{options_str}>#{content_str}</#{name}>"
+        "<#{name}#{html_attributes}>#{inner_html}</#{name}>"
       end
 
       def h(string)

data/lib/munge/item.rb

@@ -11,7 +11,7 @@ module Munge
       @relpath = relpath
       @id = id
       @content = content
-      @frontmatter = frontmatter
+      @frontmatter = Munge::Util::SymbolHash.deep_convert(frontmatter)
       @stat = stat
 
       @route = nil
@@ -116,12 +116,11 @@ module Munge
       @layout = remove_surrounding_slashes(new_layout)
     end
 
-    # @param transformer [Symbol] name of transformer to apply onto item when
+    # @param engine [Symbol] name of template engine to apply onto item when
     #   building
-    # @param *args
     # @return [void]
-    def transform(transformer = :tilt, *args)
-      @transforms.push([transformer, args])
+    def transform(engine = :use_extensions)
+      @transforms.push(engine)
     end
 
     # Deep freeze. Freezes all instance variables as well as itself.

data/lib/munge/load.rb

@@ -0,0 +1,60 @@
+module Munge
+  class Load
+    def initialize(root_path)
+      boot_config_path = File.join(root_path, "boot.yml")
+
+      @root_path = Pathname.new(root_path)
+      @boot_config = YAML.load(File.read(boot_config_path))
+      @config = Munge::Config.new
+    end
+
+    def app
+      Dir.chdir(@root_path) do
+        config_load
+
+        conglomerate = Munge::Conglomerate.new(@root_path.to_s, @config)
+        application = Munge::Application.new(conglomerate)
+
+        thread_variable_set_helper(@boot_config["conglomerate_key"], conglomerate) do
+          thread_variable_set_helper(@boot_config["application_key"], application) do
+            thread_variable_set_helper(@boot_config["config_key"], @config) do
+              thread_variable_set_helper(@boot_config["root_path_key"], @root_path) do
+                load_from_boot_config_key("boot_path")
+                load_from_boot_config_key("rules_path")
+
+                yield application, conglomerate
+              end
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    def thread_variable_set_helper(key, value)
+      Thread.current.thread_variable_set(key, value)
+
+      result = yield
+
+      Thread.current.thread_variable_set(key, nil)
+
+      result
+    end
+
+    def load_from_boot_config_key(key)
+      abspath = @root_path.join(@boot_config[key])
+
+      load abspath
+    end
+
+    def config_load
+      return if @loaded_config
+      @loaded_config = true
+
+      thread_variable_set_helper(@boot_config["config_key"], @config) do
+        load_from_boot_config_key("config_path")
+      end
+    end
+  end
+end

data/lib/munge/pre_init.rb

@@ -1,10 +1,8 @@
 module Munge
   class PreInit
-    include Munge::Util::Import
-
     def initialize(config_path)
       if !File.exist?(config_path)
-        raise Munge::Errors::ConfigRbNotFound, config_path
+        raise Munge::Error::ConfigRbNotFound, config_path
       end
 
       @config_path = config_path
@@ -13,16 +11,21 @@ module Munge
     def config
       config = Munge::Config.new
 
-      import_to_context(@config_path, binding)
+      thread_variable_set_helper("config", config) do
+        load @config_path
+      end
 
       config
     end
 
     private
 
-    def __end__
-      contents = File.read(@config_path)
-      contents.split(/^__END__$/, 2).last
+    def thread_variable_set_helper(key, value)
+      Thread.current.thread_variable_set(key, value)
+
+      yield
+
+      Thread.current.thread_variable_set(key, nil)
     end
   end
 end