munge 0.18.0 → 0.19.0

data/lib/munge/cleaner.rb

@@ -1,31 +0,0 @@
-module Munge
-  class Cleaner
-    def initialize(path_to_clean:, paths_to_write:, io:)
-      @path_to_clean = path_to_clean
-      @paths_to_write = paths_to_write
-      @io = io
-    end
-
-    def orphans
-      existing_files - @paths_to_write
-    end
-
-    def delete
-      orphans.each { |orphan| @io.rm(orphan) }
-
-      Dir.glob(File.join(@path_to_clean, "**", "*")).reverse_each do |dir|
-        if !File.directory?(dir)
-          next
-        end
-
-        @io.rmdir(dir)
-      end
-    end
-
-    private
-
-    def existing_files
-      Dir.glob(File.join(@path_to_clean, "**", "*")).select { |path| File.file?(path) }
-    end
-  end
-end

data/lib/munge/helpers/rendering.rb

@@ -1,100 +0,0 @@
-module Munge
-  module Helpers
-    module Rendering
-      def render(item, engines: nil, data: {}, content_override: nil)
-        content = content_override || item.content
-        renderers = tilt_renderer_list(item, engines)
-        mdata = merged_data(item.frontmatter, data, self_item: item)
-        item_path = item.relpath
-
-        render_string(content, data: mdata, engines: renderers, template_name: item_path)
-      end
-
-      def layout(item_or_string, data: {}, &block)
-        layout_item = resolve_layout(item_or_string)
-        renderers = tilt_renderer_list(layout_item, nil)
-        mdata = merged_data(layout_item.frontmatter, data, self_layout: layout_item)
-        layout_path = "(layout) #{layout_item.relpath}"
-
-        render_string(layout_item.content, data: mdata, engines: renderers, template_name: layout_path, &block)
-      end
-
-      def render_string(content, data: {}, engines: [], template_name: nil, &block)
-        inner =
-          if block_given?
-            capture(&block)
-          end
-
-        output =
-          engines
-            .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?
-          append_to_erbout(block.binding, output)
-        end
-
-        output
-      end
-
-      def render_with_layout(item, content_engines: nil, data: {}, content_override: nil)
-        inner = render(item, engines: content_engines, data: data, content_override: content_override)
-        mdata = merged_data(item.frontmatter, data, self_item: item)
-
-        if item.layout
-          layout(item.layout, data: mdata) do
-            inner
-          end
-        else
-          inner
-        end
-      end
-
-      private
-
-      def merged_data(*data)
-        hash_with_string_and_symbol_keys =
-          data.reduce(system.global_data) do |merged, datum|
-            merged.merge(datum)
-          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)
-          system.layouts[item_or_string]
-        else
-          item_or_string
-        end
-      end
-
-      def tilt_renderer_list(item, preferred_engine)
-        if preferred_engine
-          tilt_renderers_from_preferred(preferred_engine)
-        else
-          tilt_renderers_from_path(item.relpath)
-        end
-      end
-
-      def tilt_renderers_from_path(path)
-        ::Tilt.templates_for(path)
-      end
-
-      def tilt_renderers_from_preferred(preferred_engines)
-        preferred =
-          if preferred_engines.is_a?(Array)
-            preferred_engines.flatten.join(".")
-          else
-            preferred_engines
-          end
-
-        ::Tilt.templates_for(preferred)
-      end
-    end
-  end
-end

data/lib/munge/init.rb

@@ -1,45 +0,0 @@
-module Munge
-  # This class loads the user rules, as well as provides some useful methods
-  # for setup.
-  class Init
-    include Munge::Util::Import
-
-    # Initializing loads up the user's `setup.rb` and `rules.rb`.
-    def initialize(root_path:,
-                   config:,
-                   setup_path:,
-                   rules_path:)
-      @root_path = root_path
-      @setup_path = setup_path
-      @rules_path = rules_path
-      @binding = binding
-
-      system = Munge::System.new(root_path, config)
-
-      import(setup_path)
-
-      @app = Munge::Application.new(system)
-
-      import(rules_path)
-
-      @app.items.each(&:freeze)
-      @app.items.freeze
-    end
-
-    # @return [String] path to user's `lib/` directory
-    def lib_path
-      File.join(root_path, "lib")
-    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)
-      import_to_context(absolute_file_path, @binding)
-    end
-
-    attr_reader :app
-    attr_reader :root_path
-  end
-end

data/lib/munge/io/dry_run.rb

@@ -1,31 +0,0 @@
-module Munge
-  module Io
-    # NoOp driver for writing files. This is used to compute dry-runs.
-    class DryRun
-      def initialize(driver)
-        @driver = driver
-      end
-
-      # Pretends to write, but actually does nothing
-      #
-      # @param _abspath [String]
-      # @param _content [String]
-      def write(_abspath, _content)
-      end
-
-      def exist?(path)
-        @driver.exist?(path)
-      end
-
-      def read(path)
-        @driver.read(path)
-      end
-
-      def rm(_path)
-      end
-
-      def rmdir(_path)
-      end
-    end
-  end
-end

data/lib/munge/io/filesystem.rb

@@ -1,38 +0,0 @@
-module Munge
-  module Io
-    # 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))
-
-        File.write(abspath, content)
-      end
-
-      def exist?(path)
-        File.exist?(path)
-      end
-
-      def read(path)
-        File.read(path)
-      end
-
-      def rm(path)
-        File.delete(path)
-      end
-
-      def rmdir(path)
-        contents = Dir.entries(path) - %w(. ..)
-
-        if contents.empty?
-          Dir.rmdir(path)
-        end
-      end
-    end
-  end
-end

data/lib/munge/io/noop.rb

@@ -1,27 +0,0 @@
-module Munge
-  module Io
-    # 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
-
-      def exist?(_path)
-        false
-      end
-
-      def read(_path)
-        ""
-      end
-
-      def rm(_path)
-      end
-
-      def rmdir(_path)
-      end
-    end
-  end
-end

data/lib/munge/runner.rb

@@ -1,68 +0,0 @@
-module Munge
-  class Runner
-    def initialize(items:, router:, processor:, io:, reporter:, destination:, manager:)
-      @items = items
-      @router = router
-      @processor = processor
-      @io = io
-      @reporter = reporter
-      @destination = destination
-      @manager = manager
-      @written_paths = []
-    end
-
-    def write
-      @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)
-      abspath = File.join(@destination, relpath)
-      route = @router.route(item)
-      content = @processor.transform(item)
-
-      write_status = status(abspath, content)
-
-      case write_status
-      when :new
-        @manager.on_new(route, abspath, content)
-      when :changed
-        @manager.on_changed(route, abspath, content)
-      when :identical
-        @manager.on_identical(route, abspath, content)
-      when :double_write_error
-        raise Errors::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 !@io.exist?(path)
-        return :new
-      end
-
-      if @io.read(path) == content
-        return :identical
-      end
-
-      :changed
-    end
-  end
-end

data/lib/munge/system/processor.rb

@@ -1,52 +0,0 @@
-module Munge
-  class System
-    class Processor
-      def initialize
-        @registry = {}
-      end
-
-      # Register tranformer
-      #
-      # @see Munge::Transformers::Tilt
-      def register(transformer)
-        register_manually(transformer.name, transformer)
-      end
-
-      # 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 Errors::DuplicateTransformerError, name
-        else
-          @registry[name] = transformer
-        end
-      end
-
-      # Transforms the given item's content
-      #
-      # @param item [Item]
-      def transform(item)
-        item.transforms
-          .map { |name, args| [get_transformer(name), args] }
-          .reduce(item.content) do |content, params|
-            transformer, args = params
-
-            transformer.call(item, content, *args)
-          end
-      end
-
-      private
-
-      def get_transformer(name)
-        if @registry.key?(name)
-          @registry[name]
-        else
-          raise Errors::TransformerNotFoundError, name
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-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?
-
-          filepaths =
-            Dir.glob(File.join(@source_path, "**", "*"))
-              .select { |path| File.file?(path) }
-
-          filepaths.each do |abspath|
-            filehash = Hash[
-              relpath: compute_relpath(abspath),
-              content: compute_content(abspath),
-              stat: compute_stat(abspath)
-            ]
-
-            yield filehash
-          end
-        end
-
-        private
-
-        def compute_stat(abspath)
-          File.stat(abspath)
-        end
-
-        def compute_relpath(abspath)
-          folder = Pathname.new(@source_path)
-          file = Pathname.new(abspath)
-
-          file.relative_path_from(folder).to_s
-        end
-
-        def compute_content(abspath)
-          File.read(abspath)
-        end
-      end
-    end
-  end
-end