munge 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 90a523f13c830272c0fb00314bff78658c2967c4
-  data.tar.gz: c7875ddc140b85157f5e248920d1d1a951f3a1d4
+  metadata.gz: e8fc56a43cc01c94bce65df0af73e6d2028ac93f
+  data.tar.gz: 136d8b5a37e8fbc6ecb9fd69ae951eebe0a10b32
 SHA512:
-  metadata.gz: 67093ea7b88f0a9fcf36970a1e29d268008d0958010c6fd9716183ec0480ab8e098a0426e8a7c5b0229293b29f768e03c791417bf27bb29e861a34cb62783d89
-  data.tar.gz: 138f51ff91d5cb37c9d805b0bc622654e4b66f06f4b54d3edc046e2a841298a7f65f2e41f62202a5e43be8c405dfb83e6dcd112bc408c3441d48e95109442ded
+  metadata.gz: 1c4d0b4818104f8f08aa1a7fc196ab2d710b8259a04e7b98bede587f56487f06d533915621c1920e93338d6974432dac46432d26320fd5dd1284b4028ed51d13
+  data.tar.gz: cf7c2270b12795bdf4623596bc026967b55b8fb0c6e052c20c983d55d291ed0f8dfbf92c31813857b28672969b459a063a92a76314f920eaa90e08bd23506f2c

data/.rubocop.yml

@@ -3,6 +3,15 @@ AllCops:
     - vendor/bundle/**/*
     - Gemfile
     - Rakefile
+    - seeds/**/*
+
+Metrics/AbcSize:
+  Exclude:
+    - test/**/*
+
+Metrics/MethodLength:
+  Exclude:
+    - test/**/*
 
 Style/AlignParameters:
   Enabled: false

data/.travis.yml

@@ -1,4 +1,17 @@
 language: ruby
 rvm:
-  - 2.2.2
+  - 2.2
+  - 2.1
+  - ruby-head
+cache: bundler
 before_install: gem install bundler -v 1.10.5
+script: ./script/test
+addons:
+  code_climate:
+    repo_token: b8fc4a1660d2067059476e3e579080fb6820daedbdb5e56cd9028f5dcc058fc8
+notifications:
+  email: false
+matrix:
+  fast_finish: true
+  allow_failures:
+    - rvm: ruby-head

data/README.md

@@ -1,5 +1,9 @@
 # Munge
 
+[![Build Status](https://travis-ci.org/zachahn/munge.svg?branch=master)](https://travis-ci.org/zachahn/munge)
+[![Code Climate](https://codeclimate.com/github/zachahn/munge/badges/gpa.svg)](https://codeclimate.com/github/zachahn/munge)
+[![Test Coverage](https://codeclimate.com/github/zachahn/munge/badges/coverage.svg)](https://codeclimate.com/github/zachahn/munge/coverage)
+
 Munge is a static site generator aiming to simplify complex build rules.
 
 SemVer will be followed once 1.0.0 is released.
@@ -7,67 +11,64 @@ Until then,
 the API should be considered experimental.
 
 
-## Usage
-
-**Directory structure**
-
-```
-dest/
-src/
-  layouts/
-    layout.html
-  index.html
-application.rb
-config.yml
-Gemfile
-```
+## Installation
 
-**`application.rb`**
+Add this line to your application's Gemfile:
 
 ```ruby
-require "munge"
+gem 'munge'
+```
 
-app = Munge::Application.new("./config.yml")
+And then execute:
 
-app.source
-  .reject { |item| item.path.relative =~ %r(^layouts/) }
-  .each   { |item| item.route = item.path.dirname }
-  .map    { |item| item.path.dirname }
+    $ bundle
 
-app.write
-```
+Or install it yourself as:
 
-**`config.yml`**
-
-```yaml
----
-source: src
-dest: dest
-binary_extensions:
-  - jpg
-  - jpeg
-  - png
-  - gif
-  - ico
-index: index.html
-```
+    $ gem install munge
 
 
-## Installation
+## Usage
 
-Add this line to your application's Gemfile:
+After installing your gem, you can start a project using the command line client.
 
-```ruby
-gem 'munge'
+```
+munge init path/to/project
 ```
 
-And then execute:
+The three main files of your application are `config.yml`, `data.yml`, and `rules.rb`.
 
-    $ bundle
+Here's an example `rules.rb` for a blog.
 
-Or install it yourself as:
+```ruby
+# home page
+app.source
+  .select { |item| item.id == "home" }      # looks for items where path is "src/home.*"
+  .each   { |item| item.route = "" }        # sets output file to "/index.html"
+  .each   { |item| item.layout = "default"} # sets layout to "layouts/default.*"
+  .each   { |item| item[:title] = "home" }  # sets additional frontmatter variables
+  .each   { |item| item.transform(:tilt) }  # have Tilt compile this file
 
-    $ gem install munge
+# blog posts
+app.source
+  .select { |item| item.relpath =~ %r(^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)
+
+# blog index
+posts_for_index =
+  app.source
+    .find_all { |item| item.route =~ %r(^blog/) }
+    .sort_by  { |item| item.route }
+    .reverse
+
+app.create("blog/index.html.erb", "", posts: posts_for_index) do |item|
+  item.route  = "blog" # sets output file to "/blog/index.html"
+  item.layout = "list"
+  item.transform
+end
+```
 
 
 ## Contributing

data/exe/munge

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require "munge"
+require "munge/cli"
+
+Munge::CLI.start(ARGV)

data/lib/munge/application.rb

@@ -1,33 +1,52 @@
 module Munge
   class Application
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     def initialize(config_path)
-      @config = YAML.load_file(File.expand_path(config_path))
-      @root   = File.dirname(File.expand_path(config_path))
+      config = YAML.load_file(File.expand_path(config_path))
 
-      @source_dir = File.expand_path(@config["source"], @root)
-      @dest_dir   = File.expand_path(@config["dest"], @root)
+      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 = Source.new(@source_dir)
+      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"])
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
     attr_reader :source
 
-    def write
+    def write(&block)
       @source
         .reject { |item| item.route.nil? }
-        .map    { |item| [item, resolve_write_path(item)] }
-        .each   { |_, dest_path| FileUtils.mkdir_p(File.dirname(dest_path)) }
-        .map    { |item, dest_path| [item.rendered_output, dest_path] }
-        .each   { |content, dest_path| File.write(dest_path, content) }
+        .each   { |item| render_and_write(item, &block) }
+    end
+
+    def new_virtual_item(*args)
+      Munge::Item::Virtual.new(*args)
+    end
+
+    def create(*args, &block)
+      item = new_virtual_item(*args)
+      yield item if block_given?
+      @source.push(item)
     end
 
     private
 
-    def resolve_write_path(item)
-      if item.route[-1] == "/"
-        File.join(@dest_dir, item.route, @config["index"])
-      else
-        File.join(@dest_dir, item.route)
+    def render_and_write(item, &block)
+      did_write = @writer.write(item.route, @transform.call(item))
+      if block_given?
+        block.call(item, did_write)
       end
     end
   end

data/lib/munge/attribute/content.rb

@@ -43,8 +43,15 @@ module Munge
         end
       end
 
-      def initialize(string)
+      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

data/lib/munge/attribute/path.rb

@@ -2,11 +2,11 @@ module Munge
   module Attribute
     class Path
       def initialize(source_path, file_path)
-        @relative = resolve_relative(source_path, file_path).freeze
-        @absolute = file_path.dup.freeze
-        @basename = resolve_basename(file_path).freeze
-        @extnames = resolve_extnames(file_path).freeze
-        @dirname  = resolve_dirname(@relative).freeze
+        @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

data/lib/munge/cli.rb

@@ -0,0 +1,29 @@
+require "thor"
+
+module Munge
+  class CLI < Thor
+    include Thor::Actions
+
+    def self.source_root
+      File.expand_path("../../../seeds", __FILE__)
+    end
+
+    desc "init PATH", "Create new site at PATH"
+    def init(path)
+      directory ".", path
+    end
+
+    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 "version", "Print version"
+    def version
+      puts "munge #{Munge::VERSION}"
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Munge
+  class ItemFactory
+    def initialize(sourcepath, binary_extensions)
+      @sourcepath        = sourcepath
+      @binary_extensions = binary_extensions
+    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)
+
+      if binary_extension?(filepath)
+        Munge::Item::Binary.new(path, content, stat)
+      else
+        Munge::Item::Text.new(path, content, stat)
+      end
+    end
+
+    private
+
+    def binary_extension?(filepath)
+      file_extensions = File.basename(filepath).split(".")[1..-1]
+
+      extensions_intersection = @binary_extensions & file_extensions
+
+      !extensions_intersection.empty?
+    end
+  end
+end

data/lib/munge/core/source.rb

@@ -0,0 +1,38 @@
+require_relative "source/item_factory"
+
+module Munge
+  module Core
+    class Source
+      include Enumerable
+
+      def initialize(source_abspath, binary_extensions = [])
+        item_factory = ItemFactory.new(source_abspath, binary_extensions)
+        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| [item.id, item] }
+            .to_h
+      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

@@ -0,0 +1,51 @@
+module Munge
+  module Core
+    class Transform
+      def initialize(source_path,
+                     layouts_path,
+                     global_data,
+                     source)
+        @scope_factory = Core::TransformScopeFactory.new(
+          source_path,
+          layouts_path,
+          global_data,
+          source,
+          Munge::Helper
+        )
+      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

@@ -0,0 +1,42 @@
+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
+        @global_data      = global_data
+        @source           = source
+        @helper_container = helper_container
+      end
+
+      def create(load_helpers = true)
+        scope = Munge::Transformer::Tilt::Scope.new(
+          @source_path,
+          @layouts_path,
+          @global_data,
+          @source
+        )
+
+        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/core/write.rb

@@ -0,0 +1,34 @@
+module Munge
+  module Core
+    class Write
+      def initialize(output, index)
+        @output = output
+        @index  = index
+      end
+
+      def write(route, content)
+        relpath = resolve_filepath(route)
+        abspath = File.join(@output, relpath)
+
+        FileUtils.mkdir_p(File.dirname(abspath))
+
+        if File.exist?(abspath) && File.read(abspath) == content
+          return false
+        else
+          File.write(abspath, content)
+          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/find.rb

@@ -0,0 +1,9 @@
+module Munge
+  module Helper
+    module Find
+      def items
+        @source
+      end
+    end
+  end
+end

data/lib/munge/helper/rendering.rb

@@ -0,0 +1,117 @@
+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)
+
+        renderers
+          .inject(content) do |output, engine|
+            template = engine.new { output }
+            template.render(self, data)
+          end
+      end
+
+      def layout(path, **additional_data, &block)
+        actual_layout = find_layout(path)
+
+        if block_given?
+          if block.binding.local_variable_defined?(:_erbout)
+            layout_within_template(actual_layout, additional_data, &block)
+          else
+            layout_outside_template(actual_layout, additional_data, &block)
+          end
+        else
+          layout_without_block(actual_layout, additional_data)
+        end
+      end
+
+      def render_with_layout(item, manual_engine = nil, **additional_data, &content_block)
+        data =
+          merged_data(item.frontmatter, additional_data)
+
+        inner =
+          if block_given?
+            render(item, manual_engine, **data, &content_block)
+          else
+            render(item, manual_engine, **data)
+          end
+
+        if item.layout.nil?
+          inner
+        else
+          layout(item.layout, data) do
+            inner
+          end
+        end
+      end
+
+      private
+
+      def merged_data(*data)
+        hash_with_string_and_symbol_keys =
+          data.inject(@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
+      end
+
+      def find_layout(path)
+        pattern = File.join(@layouts_path, path)
+        Dir["#{pattern}*"].first
+      end
+
+      def layout_within_template(actual_layout, additional_data, &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
+
+        final = original_erbout + result
+
+        block.binding.local_variable_set(:_erbout, final)
+
+        ""
+      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(actual_layout, additional_data)
+        template = ::Tilt.new(actual_layout)
+        template.render(self, merged_data(additional_data))
+      end
+
+      def resolve_render_content(item, &content_block)
+        if block_given?
+          content_block.call
+        else
+          item.content
+        end
+      end
+
+      def resolve_render_renderer(item, manual_engine)
+        if manual_engine.nil?
+          ::Tilt.templates_for(item.relpath)
+        else
+          [::Tilt[manual_engine]].compact
+        end
+      end
+    end
+  end
+end

data/lib/munge/helper.rb

@@ -0,0 +1,4 @@
+module Munge
+  module Helper
+  end
+end

data/lib/munge/item/base.rb

@@ -0,0 +1,85 @@
+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

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

data/lib/munge/item/text.rb

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

data/lib/munge/item/virtual.rb

@@ -0,0 +1,32 @@
+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

data/lib/munge/runner.rb

@@ -0,0 +1,34 @@
+module Munge
+  class Runner
+    class << self
+      def method_missing(method, config_path, rules_path, *args)
+        runner = new(config_path, rules_path)
+        runner.public_send(method, *args)
+      end
+
+      def respond_to_missing?(method, *)
+        if instance_methods.include?(method)
+          true
+        else
+          super
+        end
+      end
+    end
+
+    def initialize(config_path, rules_path)
+      @app = app = Munge::Application.new(config_path)
+
+      binding.eval(File.read(rules_path), rules_path)
+    end
+
+    def write
+      @app.write do |item, did_write|
+        if did_write
+          puts "wrote #{item.route}"
+        else
+          puts "identical #{item.route}"
+        end
+      end
+    end
+  end
+end

data/lib/munge/transformer/image_optim.rb

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,19 @@
+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
+        end
+      end
+    end
+  end
+end

data/lib/munge/transformer/tilt.rb

@@ -0,0 +1,21 @@
+require_relative "tilt/scope"
+
+module Munge
+  module Transformer
+    class Tilt
+      def initialize(scope_factory)
+        @scope = scope_factory.create
+      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
+      end
+    end
+  end
+end

data/lib/munge/version.rb

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

data/lib/munge.rb

@@ -5,12 +5,23 @@ require "yaml"
 require "tilt"
 
 require "munge/version"
-require "munge/source"
 require "munge/attribute/content"
 require "munge/attribute/metadata"
 require "munge/attribute/path"
-require "munge/item"
+require "munge/item/base"
+require "munge/item/binary"
+require "munge/item/text"
+require "munge/item/virtual"
+require "munge/helper"
+require "munge/helper/find"
+require "munge/helper/rendering"
+require "munge/transformer/tilt"
+require "munge/core/source"
+require "munge/core/transform"
+require "munge/core/transform_scope_factory"
+require "munge/core/write"
 require "munge/application"
+require "munge/runner"
 
 module Munge
   # Your code goes here...

data/munge.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Zach Ahn"]
   spec.email         = ["zach.ahn@gmail.com"]
 
-  spec.summary       = "A piping-inspired static site generator"
+  spec.summary       = "Static site generator aiming to simplify complex build rules"
   spec.homepage      = "https://github.com/zachahn/munge"
   spec.license       = "MIT"
 
@@ -21,10 +21,17 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "bundler", "~> 1.9"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.8"
+  spec.add_development_dependency "fakefs", "~> 0.6"
+  spec.add_development_dependency "redcarpet", "~> 3.3"
   spec.add_development_dependency "rubocop", "~> 0.32"
+  spec.add_development_dependency "codeclimate-test-reporter", "~> 0.4"
+  spec.add_development_dependency "simplecov", "~> 0.10"
 
+  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/Gemfile.tt

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in munge.gemspec
+gem 'munge', '~> <%= Munge::VERSION %>'

data/seeds/config.yml

@@ -0,0 +1,9 @@
+source: src
+output: dest
+data: data.yml
+layouts: layouts
+index: index.html
+binary_extensions:
+  - png
+  - gif
+  - jpg

data/seeds/data.yml

@@ -0,0 +1 @@
+---

data/seeds/layouts/default.html.erb

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Munge</title>
+</head>
+<body>
+  <%= yield %>
+</body>
+</html>

data/seeds/rules.rb

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

data/seeds/src/index.html

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: munge
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Zach Ahn
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-09-15 00:00:00.000000000 Z
+date: 2015-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '1.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '1.9'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +52,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.8'
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +94,76 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.32'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !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
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
 - !ruby/object:Gem::Dependency
   name: tilt
   requirement: !ruby/object:Gem::Requirement
@@ -83,7 +181,8 @@ dependencies:
 description: 
 email:
 - zach.ahn@gmail.com
-executables: []
+executables:
+- munge
 extensions: []
 extra_rdoc_files: []
 files:
@@ -95,15 +194,37 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- 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/item.rb
-- lib/munge/source.rb
+- lib/munge/cli.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/rendering.rb
+- lib/munge/item/base.rb
+- lib/munge/item/binary.rb
+- lib/munge/item/text.rb
+- lib/munge/item/virtual.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
+- seeds/config.yml
+- seeds/data.yml
+- seeds/layouts/default.html.erb
+- seeds/rules.rb
+- seeds/src/index.html
 homepage: https://github.com/zachahn/munge
 licenses:
 - MIT
@@ -127,5 +248,5 @@ rubyforge_project:
 rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: A piping-inspired static site generator
+summary: Static site generator aiming to simplify complex build rules
 test_files: []

data/lib/munge/item.rb

@@ -1,47 +0,0 @@
-module Munge
-  class Item
-    def self.create(source_abspath, file_abspath)
-      path     = Munge::Attribute::Path.new(source_abspath, file_abspath)
-      content  = Munge::Attribute::Content.new(File.read(file_abspath))
-      metadata = Munge::Attribute::Metadata.new(file_abspath)
-
-      new(path, content, metadata)
-    end
-
-    def initialize(path, content, metadata)
-      @path     = path
-      @content  = content
-      @metadata = metadata
-      @route    = nil
-      @layout   = nil
-    end
-
-    attr_reader :path, :metadata
-    attr_accessor :route, :layout
-
-    def content
-      @content.content
-    end
-
-    def content=(new_content)
-      @content.content = new_content
-    end
-
-    def info
-      @content.frontmatter
-    end
-
-    def rendered_content
-      Tilt
-        .templates_for(@path.relative)
-        .inject(content) do |content, engine|
-          renderer = engine.new { content }
-          renderer.render(nil, info)
-        end
-    end
-
-    def rendered_output
-      rendered_content
-    end
-  end
-end

data/lib/munge/source.rb

@@ -1,22 +0,0 @@
-module Munge
-  class Source
-    include Enumerable
-
-    def initialize(source_abspath)
-      @source_abspath = source_abspath
-      @pattern        = File.join(source_abspath, "**", "*")
-
-      @items = Dir[@pattern]
-               .reject { |item_path| File.directory?(item_path) }
-               .map    { |item_path| Item.create(source_abspath, item_path) }
-    end
-
-    def each
-      return enum_for(:each) unless block_given?
-
-      @items.each do |item|
-        yield item
-      end
-    end
-  end
-end