munge 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e8fc56a43cc01c94bce65df0af73e6d2028ac93f
-  data.tar.gz: 136d8b5a37e8fbc6ecb9fd69ae951eebe0a10b32
+  metadata.gz: 1a6fdef4a9e19d71e01f67961124f1bc0ca14d46
+  data.tar.gz: 1abf979491cce35a858f227f800402f7899d7efa
 SHA512:
-  metadata.gz: 1c4d0b4818104f8f08aa1a7fc196ab2d710b8259a04e7b98bede587f56487f06d533915621c1920e93338d6974432dac46432d26320fd5dd1284b4028ed51d13
-  data.tar.gz: cf7c2270b12795bdf4623596bc026967b55b8fb0c6e052c20c983d55d291ed0f8dfbf92c31813857b28672969b459a063a92a76314f920eaa90e08bd23506f2c
+  metadata.gz: 14a64e75bf2ac7044816052bb9742819c1561c49335305f2ade3583ef9dfaeb4e685655bcb82440d4a40a5aa2766cee8409f0f090800d82ea11953c619775857
+  data.tar.gz: b9152a9873565d2575137bd9e3c644af6c13fa3f1b937572d76d4e2a73e571fb843579211ed51a0c09ba1b93b3784bacb873f9e631b8db1a62ad993b4a1f95eb

data/README.md

@@ -11,6 +11,20 @@ Until then,
 the API should be considered experimental.
 
 
+## Features
+
+- No metaprogramming
+- Suitable for large, complex sites (e.g., multiple blogs with different templates, a single blog with multiple data sources)
+- Concise rule definition
+- Rules defined by iterating through arrays and modifying objects
+
+
+## Caveats
+
+- Not optimized (Pull requests welcome, gradual optimizations preferred)
+- Rules can seem pretty dense (because of its conciseness)
+
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -32,8 +46,11 @@ Or install it yourself as:
 
 After installing your gem, you can start a project using the command line client.
 
-```
-munge init path/to/project
+```bash
+munge init path/to/project  # create a barebones project
+cd path/to/project
+munge build                 # compiles your project
+munge view                  # open http://localhost:3000/ to see output
 ```
 
 The three main files of your application are `config.yml`, `data.yml`, and `rules.rb`.
@@ -51,7 +68,7 @@ app.source
 
 # blog posts
 app.source
-  .select { |item| item.relpath =~ %r(^posts/) }          # looks for items in "src/posts/**/*"
+  .select { |item| item.relpath?("posts") }               # looks for items in "src/posts/**/*"
   .each   { |item| item.route = "blog/#{item.basename}" } # sets output file to "/blog/#{basename}/index.html"
   .each   { |item| item.layout = "post" }
   .each   { |item| item.transform }                       # sets transform to Tilt (default)
@@ -59,8 +76,8 @@ app.source
 # blog index
 posts_for_index =
   app.source
-    .find_all { |item| item.route =~ %r(^blog/) }
-    .sort_by  { |item| item.route }
+    .select  { |item| item.route?("blog") }
+    .sort_by { |item| item.route }
     .reverse
 
 app.create("blog/index.html.erb", "", posts: posts_for_index) do |item|

data/lib/munge.rb

@@ -1,21 +1,24 @@
 require "fileutils"
 require "pathname"
+require "set"
 require "yaml"
 
+require "adsf"
+require "rack"
 require "tilt"
 
 require "munge/version"
 require "munge/attribute/content"
 require "munge/attribute/metadata"
 require "munge/attribute/path"
-require "munge/item/base"
-require "munge/item/binary"
-require "munge/item/text"
-require "munge/item/virtual"
+require "munge/item"
 require "munge/helper"
 require "munge/helper/find"
+require "munge/helper/link"
 require "munge/helper/rendering"
 require "munge/transformer/tilt"
+require "munge/core/config"
+require "munge/core/router"
 require "munge/core/source"
 require "munge/core/transform"
 require "munge/core/transform_scope_factory"

data/lib/munge/application.rb

@@ -2,24 +2,50 @@ module Munge
   class Application
     # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     def initialize(config_path)
-      config = YAML.load_file(File.expand_path(config_path))
+      config = Core::Config.new(config_path)
 
       root_path    = File.dirname(File.expand_path(config_path))
-      source_path  = File.expand_path(config["source"], root_path)
-      layouts_path = File.expand_path(config["layouts"], root_path)
-      output_path  = File.expand_path(config["output"], root_path)
-      data_path    = File.expand_path(config["data"], root_path)
+      source_path  = File.expand_path(config[:source], root_path)
+      layouts_path = File.expand_path(config[:layouts], root_path)
+      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) || {}
 
-      @source = Core::Source.new(source_path, config["binary_extensions"])
-      @transform = Core::Transform.new(
-        source_path,
-        layouts_path,
-        global_data,
-        @source
-      )
-      @writer    = Core::Write.new(output_path, config["index"])
+      @source =
+        Core::Source.new(
+          source_abspath:    source_path,
+          binary_extensions: config[:binary_extensions],
+          location:          :fs_memory,
+          ignored_basenames: config[:ignored_basenames]
+        )
+
+      @layouts =
+        Core::Source.new(
+          source_abspath:    layouts_path,
+          binary_extensions: [],
+          location:          :fs_memory,
+          ignored_basenames: []
+        )
+
+      @router =
+        Core::Router.new(
+          index:           config[:index],
+          keep_extensions: config[:keep_extensions]
+        )
+
+      @transform =
+        Core::Transform.new(
+          global_data:  global_data,
+          layouts:      @layouts,
+          source:       @source,
+          router:       @router
+        )
+
+      @writer =
+        Core::Write.new(
+          output: output_path
+        )
     end
     # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
@@ -31,12 +57,12 @@ module Munge
         .each   { |item| render_and_write(item, &block) }
     end
 
-    def new_virtual_item(*args)
-      Munge::Item::Virtual.new(*args)
+    def build_virtual_item(*args)
+      @source.build_virtual_item(*args)
     end
 
     def create(*args, &block)
-      item = new_virtual_item(*args)
+      item = build_virtual_item(*args)
       yield item if block_given?
       @source.push(item)
     end
@@ -44,9 +70,12 @@ module Munge
     private
 
     def render_and_write(item, &block)
-      did_write = @writer.write(item.route, @transform.call(item))
+      relpath = @router.filepath(item)
+
+      write_status = @writer.write(relpath, @transform.call(item))
+
       if block_given?
-        block.call(item, did_write)
+        block.call(item, write_status)
       end
     end
   end

data/lib/munge/cli.rb

@@ -15,15 +15,43 @@ module Munge
 
     desc "build", "Build in current directory"
     def build
-      config_path = File.join(destination_root, "config.yml")
-      rules_path  = File.join(destination_root, "rules.rb")
-
       Munge::Runner.write(config_path, rules_path)
     end
 
+    desc "view", "View built files"
+    method_option :port, aliases: "-p", desc: "Set port", default: 3000, type: :numeric
+    method_option :host, aliases: "-h", desc: "Set host", default: "0.0.0.0", type: :string
+    def view
+      config    = Munge::Core::Config.new(config_path)
+      handler   = Rack::Handler::WEBrick
+      rack_opts = { Host: options[:host], Port: options[:port] }
+
+      app =
+        Rack::Builder.new do
+          use Rack::CommonLogger
+          use Rack::ShowExceptions
+          use Rack::Lint
+          use Rack::Head
+          use Adsf::Rack::IndexFileFinder, root: config[:output]
+          run Rack::File.new(config[:output])
+        end
+
+      Rack::Handler::WEBrick.run(app, rack_opts)
+    end
+
     desc "version", "Print version"
     def version
       puts "munge #{Munge::VERSION}"
     end
+
+    private
+
+    def config_path
+      File.join(destination_root, "config.yml")
+    end
+
+    def rules_path
+      File.join(destination_root, "rules.rb")
+    end
   end
 end

data/lib/munge/core/config.rb

@@ -0,0 +1,23 @@
+module Munge
+  module Core
+    class Config
+      def initialize(path)
+        abspath = File.expand_path(path)
+        @datastore =
+          read_yaml(abspath)
+            .map { |key, value| [key.to_sym, value] }
+            .to_h
+      end
+
+      def [](key)
+        @datastore[key]
+      end
+
+      private
+
+      def read_yaml(abspath)
+        YAML.load_file(abspath) || {}
+      end
+    end
+  end
+end

data/lib/munge/core/router.rb

@@ -0,0 +1,63 @@
+module Munge
+  module Core
+    class Router
+      def initialize(index:, keep_extensions:)
+        @index          = index
+        @keep_extensions = keep_extensions
+      end
+
+      def route(item)
+        fail "item has no route" unless item.route
+
+        if keep_extension?(item)
+          "/#{filepath(item)}"
+        else
+          item.route
+        end
+      end
+
+      def filepath(item)
+        fail "item has no route" unless item.route
+
+        relroute = relativeize(item.route)
+
+        path =
+          if route_has_extension?(item)
+            "#{relroute}"
+          elsif keep_extension?(item)
+            "#{relroute}.#{main_extension(item)}"
+          else
+            "#{relroute}/#{@index}"
+          end
+
+        relativeize(path)
+      end
+
+      private
+
+      def relativeize(path)
+        while path[0] == "/"
+          path = path[1..-1]
+        end
+
+        path
+      end
+
+      def route_has_extension?(item)
+        route_basename(item) =~ /\./
+      end
+
+      def keep_extension?(item)
+        @keep_extensions.include?(main_extension(item))
+      end
+
+      def main_extension(item)
+        item.extensions.first
+      end
+
+      def route_basename(item)
+        File.basename(item.route)
+      end
+    end
+  end
+end

data/lib/munge/core/source.rb

@@ -5,18 +5,31 @@ module Munge
     class Source
       include Enumerable
 
-      def initialize(source_abspath, binary_extensions = [])
-        item_factory = ItemFactory.new(source_abspath, binary_extensions)
-        pattern      = File.join(source_abspath, "**", "*")
+      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.create(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?
 

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

@@ -1,30 +1,109 @@
 module Munge
   class ItemFactory
-    def initialize(sourcepath, binary_extensions)
-      @sourcepath        = sourcepath
-      @binary_extensions = binary_extensions
+    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 create(filepath)
-      path    = Munge::Attribute::Path.new(@sourcepath, filepath)
-      content = Munge::Attribute::Content.new(File.read(path.absolute))
-      stat    = Munge::Attribute::Metadata.new(filepath)
+    def read(abspath)
+      content, frontmatter = compute_content_and_frontmatter(abspath)
 
-      if binary_extension?(filepath)
-        Munge::Item::Binary.new(path, content, stat)
+      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
-        Munge::Item::Text.new(path, content, stat)
+        fail "invalid @location `#{@location}`"
       end
     end
 
-    private
+    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 binary_extension?(filepath)
-      file_extensions = File.basename(filepath).split(".")[1..-1]
+    def compute_relpath(abspath)
+      folder = Pathname.new(@source_path)
+      file   = Pathname.new(abspath)
 
-      extensions_intersection = @binary_extensions & file_extensions
+      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
 
-      !extensions_intersection.empty?
+    def compute_basename(relpath)
+      filename = File.basename(relpath)
+      filename.split(".").first
     end
   end
 end

data/lib/munge/core/transform.rb

@@ -1,16 +1,16 @@
 module Munge
   module Core
     class Transform
-      def initialize(source_path,
-                     layouts_path,
-                     global_data,
-                     source)
+      def initialize(layouts:,
+                     global_data:,
+                     source:,
+                     router:)
         @scope_factory = Core::TransformScopeFactory.new(
-          source_path,
-          layouts_path,
-          global_data,
-          source,
-          Munge::Helper
+          layouts: layouts,
+          global_data: global_data,
+          source: source,
+          helper_container: Munge::Helper,
+          router: router
         )
       end
 

data/lib/munge/core/transform_scope_factory.rb

@@ -1,24 +1,24 @@
 module Munge
   module Core
     class TransformScopeFactory
-      def initialize(source_path,
-                     layouts_path,
-                     global_data,
-                     source,
-                     helper_container)
-        @source_path      = source_path
-        @layouts_path     = layouts_path
+      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(
-          @source_path,
-          @layouts_path,
-          @global_data,
-          @source
+          layouts:     @layouts,
+          global_data: @global_data,
+          source:      @source,
+          router:      @router
         )
 
         if load_helpers

data/lib/munge/core/write.rb

@@ -1,13 +1,11 @@
 module Munge
   module Core
     class Write
-      def initialize(output, index)
+      def initialize(output:)
         @output = output
-        @index  = index
       end
 
-      def write(route, content)
-        relpath = resolve_filepath(route)
+      def write(relpath, content)
         abspath = File.join(@output, relpath)
 
         FileUtils.mkdir_p(File.dirname(abspath))
@@ -19,16 +17,6 @@ module Munge
           true
         end
       end
-
-      def resolve_filepath(preferred_filename)
-        basename = File.basename(preferred_filename)
-
-        if basename.include?(".")
-          preferred_filename
-        else
-          "#{preferred_filename}/#{@index}"
-        end
-      end
     end
   end
 end

data/lib/munge/helper/link.rb

@@ -0,0 +1,29 @@
+module Munge
+  module Helper
+    module Link
+      def url_for(item)
+        @router.route(item)
+      end
+
+      def link_to(item, text = nil, **opts)
+        link = url_for(item)
+
+        optstr = opts.map { |key, val| %(#{key}="#{val}") }
+
+        parts =
+          [
+            [
+              "<a",
+              %(href="#{link}"),
+              optstr
+            ].flatten.join(" "),
+            ">",
+            text || link,
+            "</a>"
+          ]
+
+        parts.join
+      end
+    end
+  end
+end

data/lib/munge/helper/rendering.rb

@@ -1,49 +1,40 @@
 module Munge
   module Helper
     module Rendering
-      def render(item, manual_engine = nil, **additional_data, &content_block)
-        content   = resolve_render_content(item, &content_block)
-        renderers = resolve_render_renderer(item, manual_engine)
-        data      = merged_data(item.frontmatter, additional_data)
+      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)
 
-        renderers
-          .inject(content) do |output, engine|
-            template = engine.new { output }
-            template.render(self, data)
-          end
+        manual_render(content, mdata, renderers)
       end
 
-      def layout(path, **additional_data, &block)
-        actual_layout = find_layout(path)
+      def layout(item_or_string, data: {}, &block)
+        layout_item = resolve_layout(item_or_string)
+        mdata       = merged_data(layout_item.frontmatter, data)
 
         if block_given?
           if block.binding.local_variable_defined?(:_erbout)
-            layout_within_template(actual_layout, additional_data, &block)
+            layout_within_template(layout_item, mdata, &block)
           else
-            layout_outside_template(actual_layout, additional_data, &block)
+            layout_outside_template(layout_item, mdata, &block)
           end
         else
-          layout_without_block(actual_layout, additional_data)
+          layout_without_block(layout_item, mdata)
         end
       end
 
-      def render_with_layout(item, manual_engine = nil, **additional_data, &content_block)
-        data =
-          merged_data(item.frontmatter, additional_data)
+      def render_with_layout(item, content_engines: nil, data: {}, content_override: nil)
+        mdata = merged_data(item.frontmatter, data)
 
-        inner =
-          if block_given?
-            render(item, manual_engine, **data, &content_block)
-          else
-            render(item, manual_engine, **data)
-          end
+        inner = render(item, engines: content_engines, data: mdata, content_override: content_override)
 
-        if item.layout.nil?
-          inner
-        else
-          layout(item.layout, data) do
+        if item.layout
+          layout(item.layout, data: mdata) do
             inner
           end
+        else
+          inner
         end
       end
 
@@ -61,22 +52,26 @@ module Munge
           end
       end
 
-      def find_layout(path)
-        pattern = File.join(@layouts_path, path)
-        Dir["#{pattern}*"].first
+      def resolve_layout(item_or_string)
+        if item_or_string.is_a?(String)
+          @layouts[item_or_string]
+        else
+          item_or_string
+        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(actual_layout, additional_data, &block)
+      def layout_within_template(layout_item, mdata, &block)
         original_erbout = block.binding.local_variable_get(:_erbout)
 
         block.binding.local_variable_set(:_erbout, "")
 
-        inside = block.call
-
-        template = ::Tilt.new(actual_layout)
-        result = template.render(self, merged_data(additional_data)) do
-          inside
-        end
+        result = layout_outside_template(layout_item, mdata) { block.call }
 
         final = original_erbout + result
 
@@ -85,32 +80,53 @@ module Munge
         ""
       end
 
-      def layout_outside_template(actual_layout, additional_data, &block)
-        template = ::Tilt.new(actual_layout)
-        template.render(self, merged_data(additional_data)) do
-          block.call
-        end
-      end
+      def layout_without_block(layout_item, mdata)
+        engine_list = tilt_renderer_list(layout_item, nil)
 
-      def layout_without_block(actual_layout, additional_data)
-        template = ::Tilt.new(actual_layout)
-        template.render(self, merged_data(additional_data))
+        manual_render(layout_item.content, mdata, engine_list)
       end
 
-      def resolve_render_content(item, &content_block)
-        if block_given?
-          content_block.call
+      def tilt_renderer_list(item, preferred_engine)
+        if preferred_engine
+          tilt_renderers_from_preferred(preferred_engine)
         else
-          item.content
+          tilt_renderers_from_path(item.relpath)
         end
       end
 
-      def resolve_render_renderer(item, manual_engine)
-        if manual_engine.nil?
-          ::Tilt.templates_for(item.relpath)
-        else
-          [::Tilt[manual_engine]].compact
-        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
+
+      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

data/lib/munge/item.rb

@@ -0,0 +1,102 @@
+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
+      @frontmatter = frontmatter
+      @stat        = stat
+
+      @route      = nil
+      @layout     = nil
+      @transforms = []
+    end
+
+    attr_reader :type, :location
+    attr_reader :abspath, :relpath, :id
+    attr_reader :content, :frontmatter
+    attr_reader :stat
+
+    attr_reader :layout, :transforms
+
+    def dirname
+      if File.dirname(@relpath) == "."
+        ""
+      else
+        File.dirname(@relpath)
+      end
+    end
+
+    def filename
+      File.basename(@relpath)
+    end
+
+    def basename
+      filename.split(".").first
+    end
+
+    def extensions
+      filename.split(".")[1..-1]
+    end
+
+    def [](key)
+      @frontmatter[key]
+    end
+
+    def []=(key, value)
+      @frontmatter[key] = value
+    end
+
+    def route=(new_route)
+      @route = remove_surrounding_slashes(new_route)
+    end
+
+    def route
+      if @route
+        "/#{@route}"
+      end
+    end
+
+    def relpath?(*subdir_patterns)
+      regexp = generate_regex(subdir_patterns)
+      regexp === @relpath
+    end
+
+    # do not query with slashes
+    def route?(*subdir_patterns)
+      regexp = generate_regex(subdir_patterns)
+      regexp === @route
+    end
+
+    def layout=(new_layout)
+      @layout = remove_surrounding_slashes(new_layout)
+    end
+
+    def transform(transformer = :Tilt, *args)
+      @transforms.push([transformer, args])
+    end
+
+    private
+
+    def generate_regex(pattern_list)
+      joined_pattern = pattern_list.join("/")
+      Regexp.new("^#{joined_pattern}")
+    end
+
+    def remove_surrounding_slashes(string)
+      string
+        .sub(%r(^/+), "")
+        .sub(%r(/+$), "")
+    end
+  end
+end

data/lib/munge/transformer/tilt.rb

@@ -8,13 +8,7 @@ module Munge
       end
 
       def call(item, content = nil, renderer = nil)
-        if content.nil?
-          @scope.render_with_layout(item, renderer)
-        else
-          @scope.render_with_layout(item, renderer) do
-            content
-          end
-        end
+        @scope.render_with_layout(item, content_engines: renderer, content_override: content)
       end
     end
   end

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

@@ -2,16 +2,14 @@ module Munge
   module Transformer
     class Tilt
       class Scope
-        include Munge::Helper::Rendering
-
-        def initialize(source_path,
-                       layouts_path,
-                       global_data,
-                       source)
-          @source_path      = source_path
-          @layouts_path     = layouts_path
-          @global_data      = global_data
-          @source           = source
+        def initialize(layouts:,
+                       global_data:,
+                       source:,
+                       router:)
+          @global_data = global_data
+          @layouts     = layouts
+          @source      = source
+          @router      = router
         end
       end
     end

data/lib/munge/version.rb

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

data/munge.gemspec

@@ -10,6 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["zach.ahn@gmail.com"]
 
   spec.summary       = "Static site generator aiming to simplify complex build rules"
+  spec.description   = "Documentation for this release is located in https://github.com/zachahn/munge/blob/v#{Munge::VERSION}/README.md"
   spec.homepage      = "https://github.com/zachahn/munge"
   spec.license       = "MIT"
 
@@ -30,6 +31,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "codeclimate-test-reporter", "~> 0.4"
   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"

data/seeds/config.yml

@@ -4,6 +4,18 @@ data: data.yml
 layouts: layouts
 index: index.html
 binary_extensions:
+  - gif
+  - ico
+  - jpg
+  - jpeg
   - png
+ignored_basenames:
+  - index
+keep_extensions:
   - gif
+  - ico
   - jpg
+  - jpeg
+  - png
+  - css
+  - js

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: munge
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Zach Ahn
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-01 00:00:00.000000000 Z
+date: 2015-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,6 +122,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: adsf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: image_optim
   requirement: !ruby/object:Gem::Requirement
@@ -178,7 +192,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
-description: 
+description: Documentation for this release is located in https://github.com/zachahn/munge/blob/v0.3.0/README.md
 email:
 - zach.ahn@gmail.com
 executables:
@@ -201,6 +215,8 @@ files:
 - lib/munge/attribute/metadata.rb
 - lib/munge/attribute/path.rb
 - lib/munge/cli.rb
+- lib/munge/core/config.rb
+- lib/munge/core/router.rb
 - lib/munge/core/source.rb
 - lib/munge/core/source/item_factory.rb
 - lib/munge/core/transform.rb
@@ -208,11 +224,9 @@ files:
 - 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/base.rb
-- lib/munge/item/binary.rb
-- lib/munge/item/text.rb
-- lib/munge/item/virtual.rb
+- lib/munge/item.rb
 - lib/munge/runner.rb
 - lib/munge/transformer/image_optim.rb
 - lib/munge/transformer/tilt.rb

data/lib/munge/item/base.rb

@@ -1,85 +0,0 @@
-module Munge
-  module Item
-    class Base
-      def initialize(path = nil, content = nil, info = nil)
-        @path       = path
-        @content    = content
-        @info       = info
-        @layout     = nil
-        @route      = nil
-        @transforms = []
-      end
-
-      attr_reader :transforms
-      attr_accessor :route, :layout
-
-      def id
-        if dirname == ""
-          basename
-        else
-          "#{dirname}/#{basename}"
-        end
-      end
-
-      def relpath
-        @path.relative
-      end
-
-      def dirname
-        if File.dirname(relpath) == "."
-          ""
-        else
-          File.dirname(relpath)
-        end
-      end
-
-      def filename
-        File.basename(relpath)
-      end
-
-      def basename
-        filename.split(".").first
-      end
-
-      def content
-        @content.content
-      end
-
-      def frontmatter
-        @content.frontmatter
-      end
-
-      def stat
-        @info.stat
-      end
-
-      def virtual?
-        false
-      end
-
-      def binary?
-        false
-      end
-
-      def text?
-        false
-      end
-
-      def transform(transformer = :tilt, *args)
-        @transforms.push([transformer, args])
-      end
-
-      def [](key)
-        frontmatter[key]
-      end
-
-      def []=(key, value)
-        frontmatter[key] = value
-      end
-
-      def to_s
-        "#{super} #{relpath} #{route}"
-      end
-    end
-  end
-end

data/lib/munge/item/binary.rb

@@ -1,9 +0,0 @@
-module Munge
-  module Item
-    class Binary < Base
-      def binary?
-        true
-      end
-    end
-  end
-end

data/lib/munge/item/text.rb

@@ -1,9 +0,0 @@
-module Munge
-  module Item
-    class Text < Base
-      def text?
-        true
-      end
-    end
-  end
-end

data/lib/munge/item/virtual.rb

@@ -1,32 +0,0 @@
-module Munge
-  module Item
-    class Virtual < Base
-      def initialize(relpath, kontent, frontmatter = nil)
-        content =
-          if kontent.is_a?(String)
-            Munge::Attribute::Content.new(kontent, frontmatter)
-          else
-            kontent
-          end
-
-        super(relpath, content)
-      end
-
-      def relpath
-        @path
-      end
-
-      def virtual?
-        true
-      end
-
-      def text?
-        true
-      end
-
-      def content=(new_content)
-        @content.content = new_content
-      end
-    end
-  end
-end