munge 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a6fdef4a9e19d71e01f67961124f1bc0ca14d46
-  data.tar.gz: 1abf979491cce35a858f227f800402f7899d7efa
+  metadata.gz: 493a1b527391a30c807a1c358dda4c9854d1744f
+  data.tar.gz: cc9fbb10a2e927e85074b46d7e232477ade37928
 SHA512:
-  metadata.gz: 14a64e75bf2ac7044816052bb9742819c1561c49335305f2ade3583ef9dfaeb4e685655bcb82440d4a40a5aa2766cee8409f0f090800d82ea11953c619775857
-  data.tar.gz: b9152a9873565d2575137bd9e3c644af6c13fa3f1b937572d76d4e2a73e571fb843579211ed51a0c09ba1b93b3784bacb873f9e631b8db1a62ad993b4a1f95eb
+  metadata.gz: b4910b7a5825f85eeb970b4c2bc3b5699622f94d2085ad3dbeab5574531425d613fd5653adc5451988507a61b23c758e7a6c0d4f9ce6412591501ca63cbec5cb
+  data.tar.gz: 5e85a223fb27596e2fecb3c78ea4860be786c47d272e3d8a0979d1b9b1a05707a580e5b069cf0bde57f1ea14f792f4114af117397061706062e99af585d43a63

data/lib/munge/application.rb

@@ -10,22 +10,24 @@ module Munge
       output_path  = File.expand_path(config[:output], root_path)
       data_path    = File.expand_path(config[:data], root_path)
 
-      global_data = YAML.load_file(data_path) || {}
+      @global_data = YAML.load_file(data_path) || {}
 
-      @source =
-        Core::Source.new(
-          source_abspath:    source_path,
-          binary_extensions: config[:binary_extensions],
-          location:          :fs_memory,
+      @item_factory =
+        Core::ItemFactory.new(
+          text_extensions: config[:text_extensions],
           ignored_basenames: config[:ignored_basenames]
         )
 
+      @source =
+        Core::Collection.new(
+          item_factory: @item_factory,
+          items: Reader::Filesystem.new(source_path)
+        )
+
       @layouts =
-        Core::Source.new(
-          source_abspath:    layouts_path,
-          binary_extensions: [],
-          location:          :fs_memory,
-          ignored_basenames: []
+        Core::Collection.new(
+          item_factory: @item_factory,
+          items: Reader::Filesystem.new(layouts_path)
         )
 
       @router =
@@ -34,18 +36,15 @@ module Munge
           keep_extensions: config[:keep_extensions]
         )
 
-      @transform =
-        Core::Transform.new(
-          global_data:  global_data,
-          layouts:      @layouts,
-          source:       @source,
-          router:       @router
-        )
+      @alterant =
+        Core::Alterant.new(scope: self)
 
       @writer =
         Core::Write.new(
           output: output_path
         )
+
+      @alterant.register(Transformer::Tilt.new(self))
     end
     # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
@@ -58,7 +57,7 @@ module Munge
     end
 
     def build_virtual_item(*args)
-      @source.build_virtual_item(*args)
+      @source.build(*args)
     end
 
     def create(*args, &block)
@@ -72,7 +71,7 @@ module Munge
     def render_and_write(item, &block)
       relpath = @router.filepath(item)
 
-      write_status = @writer.write(relpath, @transform.call(item))
+      write_status = @writer.write(relpath, @alterant.transform(item))
 
       if block_given?
         block.call(item, write_status)

data/lib/munge/core/alterant.rb

@@ -0,0 +1,43 @@
+module Munge
+  module Core
+    class Alterant
+      def initialize(scope:)
+        @scope    = scope
+        @registry = {}
+      end
+
+      def register(transformer)
+        register_manually(transformer.name, transformer)
+      end
+
+      # name should be snake_case Symbol
+      def register_manually(name, transformer)
+        if @registry.has_key?(name)
+          fail "already registered transformer `#{name}`"
+        else
+          @registry[name] = transformer
+        end
+      end
+
+      def transform(item)
+        item.transforms
+          .map { |name, args| [get_transformer(name), args] }
+          .inject(item.content) do |content, params|
+            transformer, args = params
+
+            transformer.call(item, content, *args)
+          end
+      end
+
+      private
+
+      def get_transformer(name)
+        if @registry.has_key?(name)
+          @registry[name]
+        else
+          fail "transformer `#{name}` is not installed"
+        end
+      end
+    end
+  end
+end

data/lib/munge/core/collection.rb

@@ -0,0 +1,49 @@
+module Munge
+  module Core
+    class Collection
+      include Enumerable
+
+      def initialize(item_factory:,
+                     items:)
+        @item_factory = item_factory
+
+        @items =
+          items
+            .map { |item| parse(**item) }
+            .map { |item| [item.id, item] }
+            .to_h
+      end
+
+      def build(**args)
+        @item_factory.build(**prune_args(args))
+      end
+
+      def parse(**args)
+        @item_factory.parse(**prune_args(args))
+      end
+
+      def each
+        return enum_for(:each) unless block_given?
+
+        @items.each_value do |item|
+          yield item
+        end
+      end
+
+      def push(virtual_item)
+        key = virtual_item.id
+        @items[key] = virtual_item
+      end
+
+      def [](id)
+        @items[id]
+      end
+
+      private
+
+      def prune_args(args)
+        args.select { |k, v| %i(relpath content frontmatter stat).include?(k) }
+      end
+    end
+  end
+end

data/lib/munge/core/item_factory/content_parser.rb

@@ -0,0 +1,62 @@
+module Munge
+  module Core
+    class ItemFactory
+      class ContentParser
+        def self.match(string)
+          string.match(/
+            # Start of string
+            \A
+            # Begin frontmatter
+            (?:^---\s*[\n\r]+)
+            # Capture frontmatter
+            (.*)
+            # End frontmatter
+            (?:^---\s*[\n\r]+)
+            /mx)
+        end
+
+        def self.parse(string)
+          matchdata = match(string)
+
+          [
+            parse_frontmatter(matchdata),
+            parse_content(matchdata, string)
+          ]
+        end
+
+        def self.parse_frontmatter(matchdata)
+          return {} if matchdata.nil?
+
+          parsed_frontmatter = YAML.load(matchdata[1])
+
+          if parsed_frontmatter
+            parsed_frontmatter
+          else
+            {}
+          end
+        end
+
+        def self.parse_content(matchdata, string)
+          if matchdata
+            matchdata.post_match
+          else
+            string
+          end
+        end
+
+        def initialize(string, frontmatter = nil)
+          @frontmatter, @content = self.class.parse(string)
+
+          if frontmatter
+            @frontmatter = @frontmatter.merge(frontmatter)
+          end
+        rescue ArgumentError
+          @frontmatter = frontmatter || {}
+          @content     = string
+        end
+
+        attr_accessor :frontmatter, :content
+      end
+    end
+  end
+end

data/lib/munge/core/item_factory.rb

@@ -0,0 +1,126 @@
+require_relative "item_factory/content_parser"
+
+module Munge
+  module Core
+    class ItemFactory
+      def initialize(text_extensions:,
+                     ignored_basenames:)
+        @text_extensions = Set.new(text_extensions)
+        @ignored_basenames = ignored_basenames
+      end
+
+      def build(relpath:,
+                content:,
+                frontmatter: {},
+                stat: nil)
+        type = compute_file_type(relpath)
+
+        id =
+          if type == :text
+            compute_id(relpath)
+          else
+            relpath
+          end
+
+        Munge::Item.new(
+          relpath: relpath,
+          content: content,
+          frontmatter: frontmatter,
+          stat: stat,
+          type: type,
+          id: id
+        )
+      end
+
+      def parse(relpath:,
+                content:,
+                stat: nil)
+        type = compute_file_type(relpath)
+
+        if type == :text
+          parsed = Munge::Core::ItemFactory::ContentParser.new(content)
+
+          build(
+            relpath: relpath,
+            content: parsed.content,
+            frontmatter: parsed.frontmatter,
+            stat: stat
+          )
+        else
+          build(
+            relpath: relpath,
+            content: content,
+            frontmatter: {},
+            stat: stat
+          )
+        end
+      end
+
+      private
+
+      def compute_content_and_frontmatter(abspath)
+        case @location
+        when :fs_memory
+          content = Munge::Attribute::Content.new(File.read(abspath))
+          [content.content, content.frontmatter]
+        when :fs, :virtual
+          ["", {}]
+        else
+          fail "invalid @location `#{@location}`"
+        end
+      end
+
+      def file_extensions(filepath)
+        extensions = File.basename(filepath).split(".")[1..-1]
+        Set.new(extensions)
+      end
+
+      def compute_file_type(abspath)
+        exts = file_extensions(abspath)
+
+        if exts.intersect?(@text_extensions)
+          :text
+        else
+          :binary
+        end
+      end
+
+      def compute_relpath(abspath)
+        folder = Pathname.new(@source_path)
+        file   = Pathname.new(abspath)
+
+        file.relative_path_from(folder).to_s
+      end
+
+      def compute_stat(abspath)
+        File.stat(abspath)
+      end
+
+      def compute_id(relpath)
+        dirname  = compute_dirname(relpath)
+        basename = compute_basename(relpath)
+
+        id = []
+
+        unless dirname == "."
+          id.push(dirname)
+        end
+
+        unless @ignored_basenames.include?(basename)
+          id.push(basename)
+        end
+
+        id.join("/")
+      end
+
+      def compute_dirname(relpath)
+        dirname = File.dirname(relpath)
+      end
+
+      def compute_basename(relpath)
+        filename = File.basename(relpath)
+        filename.split(".").first
+      end
+    end
+  end
+end

data/lib/munge/helper/rendering.rb

@@ -6,29 +6,41 @@ module Munge
         renderers = tilt_renderer_list(item, engines)
         mdata     = merged_data(item.frontmatter, data)
 
-        manual_render(content, mdata, renderers)
+        render_string(content, data: mdata, engines: renderers)
       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)
 
-        if block_given?
-          if block.binding.local_variable_defined?(:_erbout)
-            layout_within_template(layout_item, mdata, &block)
+        render_string(layout_item.content, data: mdata, engines: renderers, &block)
+      end
+
+      def render_string(content, data: {}, engines: [])
+        inner =
+          if block_given?
+            yield
           else
-            layout_outside_template(layout_item, mdata, &block)
+            nil
+          end
+
+        engines
+          .inject(content) do |output, engine|
+            template = engine.new { output }
+
+            if inner
+              template.render(self, data) { inner }
+            else
+              template.render(self, data)
+            end
           end
-        else
-          layout_without_block(layout_item, mdata)
-        end
       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)
 
-        inner = render(item, engines: content_engines, data: mdata, content_override: content_override)
-
         if item.layout
           layout(item.layout, data: mdata) do
             inner
@@ -60,32 +72,6 @@ module Munge
         end
       end
 
-      def layout_outside_template(layout_item, mdata, &block)
-        engine_list = tilt_renderer_list(layout_item, nil)
-
-        manual_render(layout_item.content, mdata, engine_list, &block)
-      end
-
-      def layout_within_template(layout_item, mdata, &block)
-        original_erbout = block.binding.local_variable_get(:_erbout)
-
-        block.binding.local_variable_set(:_erbout, "")
-
-        result = layout_outside_template(layout_item, mdata) { block.call }
-
-        final = original_erbout + result
-
-        block.binding.local_variable_set(:_erbout, final)
-
-        ""
-      end
-
-      def layout_without_block(layout_item, mdata)
-        engine_list = tilt_renderer_list(layout_item, nil)
-
-        manual_render(layout_item.content, mdata, engine_list)
-      end
-
       def tilt_renderer_list(item, preferred_engine)
         if preferred_engine
           tilt_renderers_from_preferred(preferred_engine)
@@ -108,26 +94,6 @@ module Munge
 
         ::Tilt.templates_for(preferred)
       end
-
-      def manual_render(content, data, engine_list, &block)
-        inner =
-          if block_given?
-            block.call
-          else
-            nil
-          end
-
-        engine_list
-          .inject(content) do |output, engine|
-            template = engine.new { output }
-
-            if inner
-              template.render(self, data) { inner }
-            else
-              template.render(self, data)
-            end
-          end
-      end
     end
   end
 end

data/lib/munge/item.rb

@@ -1,16 +1,12 @@
 module Munge
   class Item
     def initialize(type:,
-                   location:,
-                   abspath:,
                    relpath:,
                    id:,
                    content: nil,
                    frontmatter: {},
                    stat: nil)
       @type        = type
-      @location    = location
-      @abspath     = abspath
       @relpath     = relpath
       @id          = id
       @content     = content
@@ -22,8 +18,8 @@ module Munge
       @transforms = []
     end
 
-    attr_reader :type, :location
-    attr_reader :abspath, :relpath, :id
+    attr_reader :type
+    attr_reader :relpath, :id
     attr_reader :content, :frontmatter
     attr_reader :stat
 
@@ -82,7 +78,7 @@ module Munge
       @layout = remove_surrounding_slashes(new_layout)
     end
 
-    def transform(transformer = :Tilt, *args)
+    def transform(transformer = :tilt, *args)
       @transforms.push([transformer, args])
     end
 

data/lib/munge/readers/filesystem.rb

@@ -0,0 +1,46 @@
+module Munge
+  module Reader
+    class Filesystem
+      include Enumerable
+
+      def initialize(source_path)
+        @source_path = source_path
+      end
+
+      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

data/lib/munge/transformer/tilt.rb

@@ -1,14 +1,27 @@
-require_relative "tilt/scope"
-
 module Munge
   module Transformer
     class Tilt
-      def initialize(scope_factory)
-        @scope = scope_factory.create
+      def initialize(scope)
+        @pristine_scope = scope
+      end
+
+      def name
+        :tilt
       end
 
       def call(item, content = nil, renderer = nil)
-        @scope.render_with_layout(item, content_engines: renderer, content_override: content)
+        scope = @pristine_scope.dup
+        scope.instance_variable_set :@renderer, @renderer
+        dirty_scope = extend_with_helpers(scope)
+        dirty_scope.render_with_layout(item, content_engines: renderer, content_override: content)
+      end
+
+      private
+
+      def extend_with_helpers(scope)
+        Munge::Helper.constants
+          .map  { |sym| Munge::Helper.const_get(sym) }
+          .inject(scope) { |scope, helper| scope.extend(helper) }
       end
     end
   end

data/lib/munge/version.rb

@@ -1,3 +1,3 @@
 module Munge
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/munge.rb

@@ -8,24 +8,18 @@ require "rack"
 require "tilt"
 
 require "munge/version"
-require "munge/attribute/content"
-require "munge/attribute/metadata"
-require "munge/attribute/path"
 require "munge/item"
 require "munge/helper"
 require "munge/helper/find"
 require "munge/helper/link"
 require "munge/helper/rendering"
 require "munge/transformer/tilt"
+require "munge/readers/filesystem"
 require "munge/core/config"
 require "munge/core/router"
-require "munge/core/source"
-require "munge/core/transform"
-require "munge/core/transform_scope_factory"
+require "munge/core/item_factory"
+require "munge/core/collection"
 require "munge/core/write"
+require "munge/core/alterant"
 require "munge/application"
 require "munge/runner"
-
-module Munge
-  # Your code goes here...
-end

data/munge.gemspec

@@ -32,8 +32,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "simplecov", "~> 0.10"
 
   spec.add_runtime_dependency "adsf", "~> 1.2"
-  spec.add_runtime_dependency "image_optim", "~> 0.21"
-  spec.add_runtime_dependency "image_optim_pack", "~> 0.2"
   spec.add_runtime_dependency "thor", "~> 0.19"
   spec.add_runtime_dependency "tilt", "~> 2.0"
 end

data/seeds/config.yml

@@ -3,12 +3,11 @@ output: dest
 data: data.yml
 layouts: layouts
 index: index.html
-binary_extensions:
-  - gif
-  - ico
-  - jpg
-  - jpeg
-  - png
+text_extensions:
+  - html
+  - htm
+  - txt
+  - md
 ignored_basenames:
   - index
 keep_extensions:

data/seeds/rules.rb

@@ -1,5 +1,5 @@
 app.source
-  .select { |item| item.id == "index" }
+  .select { |item| item.id == "" }
   .each   { |item| item.route = "/" }
   .each   { |item| item.layout = "default" }
   .each   { |item| item.transform }

data/seeds/src/index.html.erb

@@ -0,0 +1,5 @@
+---
+title: Welcome
+---
+
+<h1><%= title %></h1>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: munge
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Zach Ahn
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-14 00:00:00.000000000 Z
+date: 2015-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -136,34 +136,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
-- !ruby/object:Gem::Dependency
-  name: image_optim
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.21'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.21'
-- !ruby/object:Gem::Dependency
-  name: image_optim_pack
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -192,7 +164,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
-description: Documentation for this release is located in https://github.com/zachahn/munge/blob/v0.3.0/README.md
+description: Documentation for this release is located in https://github.com/zachahn/munge/blob/v0.4.0/README.md
 email:
 - zach.ahn@gmail.com
 executables:
@@ -211,26 +183,22 @@ files:
 - exe/munge
 - lib/munge.rb
 - lib/munge/application.rb
-- lib/munge/attribute/content.rb
-- lib/munge/attribute/metadata.rb
-- lib/munge/attribute/path.rb
 - lib/munge/cli.rb
+- lib/munge/core/alterant.rb
+- lib/munge/core/collection.rb
 - lib/munge/core/config.rb
+- lib/munge/core/item_factory.rb
+- lib/munge/core/item_factory/content_parser.rb
 - lib/munge/core/router.rb
-- lib/munge/core/source.rb
-- lib/munge/core/source/item_factory.rb
-- lib/munge/core/transform.rb
-- lib/munge/core/transform_scope_factory.rb
 - lib/munge/core/write.rb
 - lib/munge/helper.rb
 - lib/munge/helper/find.rb
 - lib/munge/helper/link.rb
 - lib/munge/helper/rendering.rb
 - lib/munge/item.rb
+- lib/munge/readers/filesystem.rb
 - lib/munge/runner.rb
-- lib/munge/transformer/image_optim.rb
 - lib/munge/transformer/tilt.rb
-- lib/munge/transformer/tilt/scope.rb
 - lib/munge/version.rb
 - munge.gemspec
 - seeds/Gemfile.tt
@@ -238,7 +206,7 @@ files:
 - seeds/data.yml
 - seeds/layouts/default.html.erb
 - seeds/rules.rb
-- seeds/src/index.html
+- seeds/src/index.html.erb
 homepage: https://github.com/zachahn/munge
 licenses:
 - MIT

data/lib/munge/attribute/content.rb

@@ -1,60 +0,0 @@
-module Munge
-  module Attribute
-    class Content
-      def self.match(string)
-        string.match(/
-          # Start of string
-          \A
-          # Begin frontmatter
-          (?:^---\s*[\n\r]+)
-          # Capture frontmatter
-          (.*)
-          # End frontmatter
-          (?:^---\s*[\n\r]+)
-          /mx)
-      end
-
-      def self.parse(string)
-        matchdata = match(string)
-
-        [
-          parse_frontmatter(matchdata),
-          parse_content(matchdata, string)
-        ]
-      end
-
-      def self.parse_frontmatter(matchdata)
-        return {} if matchdata.nil?
-
-        parsed_frontmatter = YAML.load(matchdata[1])
-
-        if parsed_frontmatter
-          parsed_frontmatter
-        else
-          {}
-        end
-      end
-
-      def self.parse_content(matchdata, string)
-        if matchdata
-          matchdata.post_match
-        else
-          string
-        end
-      end
-
-      def initialize(string, frontmatter = nil)
-        @frontmatter, @content = self.class.parse(string)
-
-        if frontmatter
-          @frontmatter = @frontmatter.merge(frontmatter)
-        end
-      rescue ArgumentError
-        @frontmatter = frontmatter || {}
-        @content     = string
-      end
-
-      attr_accessor :frontmatter, :content
-    end
-  end
-end

data/lib/munge/attribute/metadata.rb

@@ -1,12 +0,0 @@
-module Munge
-  module Attribute
-    class Metadata
-      def initialize(abspath)
-        @abspath = abspath
-        @stat    = File::Stat.new(abspath)
-      end
-
-      attr_reader :stat
-    end
-  end
-end

data/lib/munge/attribute/path.rb

@@ -1,44 +0,0 @@
-module Munge
-  module Attribute
-    class Path
-      def initialize(source_path, file_path)
-        @relative = resolve_relative(source_path, file_path)
-        @absolute = file_path
-        @basename = resolve_basename(file_path)
-        @extnames = resolve_extnames(file_path)
-        @dirname  = resolve_dirname(@relative)
-      end
-
-      attr_reader :relative, :absolute, :basename, :extnames, :dirname
-
-      private
-
-      def resolve_relative(source_path, file_path)
-        folder = Pathname.new(source_path)
-        file   = Pathname.new(file_path)
-
-        file.relative_path_from(folder).to_s
-      end
-
-      def resolve_basename(file_path)
-        file_name = File.basename(file_path)
-        file_name_parts = file_name.split(".")
-
-        file_name_parts.first
-      end
-
-      def resolve_extnames(file_path)
-        file_name = File.basename(file_path)
-        file_name_parts = file_name.split(".")
-
-        file_name_parts[1..-1]
-      end
-
-      def resolve_dirname(relpath)
-        relpath_with_prefix_slash = File.join("/", relpath)
-        dirname = File.dirname(relpath_with_prefix_slash)
-        File.join(dirname[1..-1], "/")
-      end
-    end
-  end
-end

data/lib/munge/core/source/item_factory.rb

@@ -1,109 +0,0 @@
-module Munge
-  class ItemFactory
-    def initialize(source_path:,
-                   binary_extensions:,
-                   location:,
-                   ignored_basenames:)
-      @source_path       = source_path
-      @binary_extensions = Set.new(binary_extensions)
-      @location          = location
-      @ignored_basenames = ignored_basenames
-    end
-
-    def read(abspath)
-      content, frontmatter = compute_content_and_frontmatter(abspath)
-
-      relpath = compute_relpath(abspath)
-
-      Munge::Item.new(
-        type: compute_file_type(abspath),
-        location: @location,
-        abspath: abspath,
-        relpath: relpath,
-        id: compute_id(relpath),
-        content: content,
-        frontmatter: frontmatter,
-        stat: compute_stat(abspath)
-      )
-    end
-
-    def build_virtual(relpath, content, frontmatter, type: :text)
-      Munge::Item.new(
-        type: type,
-        location: :virtual,
-        abspath: nil,
-        relpath: relpath,
-        id: compute_id(relpath),
-        content: content,
-        frontmatter: frontmatter,
-        stat: nil
-      )
-    end
-
-    private
-
-    def compute_content_and_frontmatter(abspath)
-      case @location
-      when :fs_memory
-        content = Munge::Attribute::Content.new(File.read(abspath))
-        [content.content, content.frontmatter]
-      when :fs, :virtual
-        ["", {}]
-      else
-        fail "invalid @location `#{@location}`"
-      end
-    end
-
-    def file_extensions(filepath)
-      extensions = File.basename(filepath).split(".")[1..-1]
-      Set.new(extensions)
-    end
-
-    def compute_file_type(abspath)
-      exts = file_extensions(abspath)
-
-      if exts.intersect?(@binary_extensions)
-        :binary
-      else
-        :text
-      end
-    end
-
-    def compute_relpath(abspath)
-      folder = Pathname.new(@source_path)
-      file   = Pathname.new(abspath)
-
-      file.relative_path_from(folder).to_s
-    end
-
-    def compute_stat(abspath)
-      File.stat(abspath)
-    end
-
-    def compute_id(relpath)
-      dirname  = compute_dirname(relpath)
-      basename = compute_basename(relpath)
-
-      id = []
-
-      unless dirname == "."
-        id.push(dirname)
-      end
-
-      unless @ignored_basenames.include?(basename)
-        id.push(basename)
-      end
-
-      id.join("/")
-    end
-
-    def compute_dirname(relpath)
-      dirname = File.dirname(relpath)
-    end
-
-    def compute_basename(relpath)
-      filename = File.basename(relpath)
-      filename.split(".").first
-    end
-  end
-end

data/lib/munge/core/source.rb

@@ -1,51 +0,0 @@
-require_relative "source/item_factory"
-
-module Munge
-  module Core
-    class Source
-      include Enumerable
-
-      def initialize(source_abspath:,
-                     binary_extensions:,
-                     location:,
-                     ignored_basenames:)
-        @item_factory =
-          ItemFactory.new(
-            source_path:       source_abspath,
-            binary_extensions: binary_extensions,
-            location:          location,
-            ignored_basenames: ignored_basenames
-          )
-        pattern       = File.join(source_abspath, "**", "*")
-
-        @items =
-          Dir.glob(pattern)
-            .reject { |item_path| File.directory?(item_path) }
-            .map    { |item_path| @item_factory.read(item_path) }
-            .map    { |item| [item.id, item] }
-            .to_h
-      end
-
-      def build_virtual_item(*args)
-        @item_factory.build_virtual(*args)
-      end
-
-      def each
-        return enum_for(:each) unless block_given?
-
-        @items.each_value do |item|
-          yield item
-        end
-      end
-
-      def push(virtual_item)
-        key = virtual_item.id
-        @items[key] = virtual_item
-      end
-
-      def [](id)
-        @items[id]
-      end
-    end
-  end
-end

data/lib/munge/core/transform.rb

@@ -1,51 +0,0 @@
-module Munge
-  module Core
-    class Transform
-      def initialize(layouts:,
-                     global_data:,
-                     source:,
-                     router:)
-        @scope_factory = Core::TransformScopeFactory.new(
-          layouts: layouts,
-          global_data: global_data,
-          source: source,
-          helper_container: Munge::Helper,
-          router: router
-        )
-      end
-
-      def call(item)
-        item.transforms
-          .map { |name, args| [resolve_transformer(name), args] }
-          .inject(item.content) do |content, params|
-            transformer, args = params
-
-            t = transformer.new(@scope_factory)
-
-            t.call(item, content, *args)
-          end
-      end
-
-      def resolve_transformer(identifier)
-        resolver = proc do |name|
-          if Munge::Transformer.constants.include?(name)
-            return Munge::Transformer.const_get(name)
-          end
-        end
-
-        resolver.call(identifier.to_sym)
-
-        resolver.call(underscore_to_camel(identifier.to_s).to_sym)
-      end
-
-      private
-
-      def underscore_to_camel(string)
-        string
-          .split("_")
-          .map(&:capitalize)
-          .join("")
-      end
-    end
-  end
-end

data/lib/munge/core/transform_scope_factory.rb

@@ -1,42 +0,0 @@
-module Munge
-  module Core
-    class TransformScopeFactory
-      def initialize(layouts:,
-                     global_data:,
-                     source:,
-                     helper_container:,
-                     router:)
-        @layouts          = layouts
-        @global_data      = global_data
-        @source           = source
-        @helper_container = helper_container
-        @router           = router
-      end
-
-      def create(load_helpers = true)
-        scope = Munge::Transformer::Tilt::Scope.new(
-          layouts:     @layouts,
-          global_data: @global_data,
-          source:      @source,
-          router:      @router
-        )
-
-        if load_helpers
-          extend_with_helpers(scope)
-        end
-
-        scope
-      end
-
-      private
-
-      def extend_with_helpers(scope)
-        Munge::Helper.constants
-          .map  { |sym| @helper_container.const_get(sym) }
-          .each { |helper| scope.extend(helper) }
-
-        scope
-      end
-    end
-  end
-end

data/lib/munge/transformer/image_optim.rb

@@ -1,20 +0,0 @@
-module Munge
-  module Transformer
-    class ImageOptim
-      def initialize(_scope_factory)
-      end
-
-      def call(item, content = nil, **initialization)
-        actual_content =
-          if content.nil?
-            item.content
-          else
-            content
-          end
-
-        optimizer = ::ImageOptim.new(**initialization)
-        optimizer.optimize_image_data(actual_content)
-      end
-    end
-  end
-end

data/lib/munge/transformer/tilt/scope.rb

@@ -1,17 +0,0 @@
-module Munge
-  module Transformer
-    class Tilt
-      class Scope
-        def initialize(layouts:,
-                       global_data:,
-                       source:,
-                       router:)
-          @global_data = global_data
-          @layouts     = layouts
-          @source      = source
-          @router      = router
-        end
-      end
-    end
-  end
-end

data/seeds/src/index.html

@@ -1 +0,0 @@
-<h1>Welcome</h1>