munge 0.4.0 → 0.5.0.beta1

data/lib/munge/routers/auto_add_extension.rb

@@ -0,0 +1,44 @@
+module Munge
+  module Router
+    class AutoAddExtension
+      def initialize(keep_extensions:)
+        @keep_extensions = keep_extensions
+      end
+
+      def type
+        :route
+      end
+
+      def match?(initial_route, item)
+        item_should_have_extension?(item) && route_doesnt_have_extension?(initial_route)
+      end
+
+      def call(initial_route, item)
+        add_extension(initial_route, item)
+      end
+
+      private
+
+      def add_extension(initial_route, item)
+        intersection = item.extensions & @keep_extensions
+        extension    = intersection[0]
+
+        "#{initial_route}.#{extension}"
+      end
+
+      def item_should_have_extension?(item)
+        intersection = item.extensions & @keep_extensions
+
+        intersection.length > 0
+      end
+
+      def route_doesnt_have_extension?(initial_route)
+        initial_route_extensions = initial_route.split(".")[1..-1]
+
+        intersection = initial_route_extensions & @keep_extensions
+
+        intersection.length == 0
+      end
+    end
+  end
+end

data/lib/munge/routers/fingerprint.rb

@@ -0,0 +1,60 @@
+module Munge
+  module Router
+    class Fingerprint
+      def initialize(extensions:,
+                     separator:)
+        @extensions = extensions
+        @separator  = separator
+      end
+
+      def type
+        :route
+      end
+
+      def match?(_initial_route, item)
+        if item.frontmatter.key?(:fingerprint_asset)
+          return item.frontmatter[:fingerprint_asset]
+        end
+
+        intersection = item.extensions & @extensions
+
+        if intersection.size == 0
+          false
+        else
+          true
+        end
+      end
+
+      def call(initial_route, item)
+        generate_link(initial_route, item.compiled_content)
+      end
+
+      private
+
+      def generate_link(initial_route, content)
+        pre, extension = disassemble(initial_route)
+        asset_hash     = hash(content)
+
+        if extension == ""
+          "#{pre}#{@separator}#{asset_hash}"
+        else
+          "#{pre}#{@separator}#{asset_hash}.#{extension}"
+        end
+      end
+
+      def hash(content)
+        Digest::MD5.hexdigest(content)
+      end
+
+      def disassemble(path)
+        extension              = Util::Path.extname(path)
+        path_without_extension = Util::Path.path_no_extension(path)
+
+        [
+          path_without_extension,
+          extension
+        ]
+      end
+    end
+  end
+end

data/lib/munge/routers/remove_index_basename.rb

@@ -0,0 +1,35 @@
+module Munge
+  module Router
+    class RemoveIndexBasename
+      def initialize(html_extensions:, index:)
+        @html_extensions = html_extensions
+        @index           = index
+        @index_basename  = Munge::Util::Path.basename_no_extension(@index)
+      end
+
+      def type
+        :route
+      end
+
+      def match?(initial_route, item)
+        item_is_html?(item) && basename_is_index?(initial_route)
+      end
+
+      def call(initial_route, _item)
+        Munge::Util::Path.dirname(initial_route)
+      end
+
+      private
+
+      def item_is_html?(item)
+        intersection = item.extensions & @html_extensions
+
+        intersection.length > 0
+      end
+
+      def basename_is_index?(route)
+        File.basename(route) == @index_basename
+      end
+    end
+  end
+end

data/lib/munge/runner.rb

@@ -1,8 +1,8 @@
 module Munge
   class Runner
     class << self
-      def method_missing(method, config_path, rules_path, *args)
-        runner = new(config_path, rules_path)
+      def method_missing(method, root_path, *args)
+        runner = new(application(root_path))
         runner.public_send(method, *args)
       end
 
@@ -13,12 +13,16 @@ module Munge
           super
         end
       end
-    end
 
-    def initialize(config_path, rules_path)
-      @app = app = Munge::Application.new(config_path)
+      def application(root_path)
+        bootstrap = Munge::Bootstrap.new_from_dir(root_path: root_path)
+
+        bootstrap.app
+      end
+    end
 
-      binding.eval(File.read(rules_path), rules_path)
+    def initialize(application)
+      @app = application
     end
 
     def write

data/lib/munge/system.rb

@@ -0,0 +1,54 @@
+module Munge
+  class System
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def initialize(root_path, config)
+      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) || {}
+
+      @config = config
+
+      @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::Collection.new(
+          item_factory: @item_factory,
+          items: Reader::Filesystem.new(layouts_path)
+        )
+
+      @alterant =
+        Core::Alterant.new(scope: self)
+
+      @router =
+        Core::Router.new(
+          alterant: @alterant
+        )
+
+      @writer =
+        Core::Write.new(
+          output: output_path
+        )
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    attr_accessor :alterant
+    attr_accessor :config
+    attr_accessor :global_data
+    attr_accessor :router
+    attr_accessor :source
+    attr_accessor :writer
+  end
+end

data/lib/munge/transformer/tilt.rb

@@ -3,6 +3,7 @@ module Munge
     class Tilt
       def initialize(scope)
         @pristine_scope = scope
+        @registry = []
       end
 
       def name
@@ -16,12 +17,15 @@ module Munge
         dirty_scope.render_with_layout(item, content_engines: renderer, content_override: content)
       end
 
+      def register(helper)
+        @registry.push(helper)
+      end
+
       private
 
       def extend_with_helpers(scope)
-        Munge::Helper.constants
-          .map  { |sym| Munge::Helper.const_get(sym) }
-          .inject(scope) { |scope, helper| scope.extend(helper) }
+        @registry
+          .inject(scope) { |a, e| a.extend(e) }
       end
     end
   end

data/lib/munge/util/config.rb

@@ -0,0 +1,28 @@
+module Munge
+  module Util
+    class Config
+      class << self
+        def read(path)
+          abspath = File.expand_path(path)
+
+          yaml = read_yaml(abspath)
+
+          config =
+            if yaml.is_a?(Hash)
+              yaml
+            else
+              {}
+            end
+
+          Munge::Util::SymbolHash.deep_convert(config)
+        end
+
+        private
+
+        def read_yaml(abspath)
+          YAML.load_file(abspath)
+        end
+      end
+    end
+  end
+end

data/lib/munge/util/path.rb

@@ -0,0 +1,58 @@
+module Munge
+  module Util
+    class Path
+      def self.dirname(path)
+        path_parts = path.split("/")
+        path_parts[0..-2].join("/")
+      end
+
+      def self.extname(path)
+        basename = File.basename(path)
+        basename_parts = basename.split(".")
+
+        if basename_parts.length > 1
+          basename_parts[-1]
+        else
+          ""
+        end
+      end
+
+      def self.basename_no_extension(path)
+        basename = File.basename(path)
+        basename_parts = basename.split(".")
+
+        basename_parts[0] || ""
+      end
+
+      def self.path_no_extension(path)
+        extension = extname(path)
+
+        if extension == ""
+          path
+        else
+          path.sub(/\.#{extension}/, "")
+        end
+      end
+
+      def self.ensure_abspath(path)
+        correct = path.squeeze("/")
+
+        if correct[0] == "/"
+          correct
+        else
+          "/#{correct}"
+        end
+      end
+
+      def self.ensure_relpath(path)
+        correct = path.squeeze("/")
+
+        if correct[0] == "/"
+          correct[1..-1]
+        else
+          correct
+        end
+      end
+    end
+  end
+end

data/lib/munge/util/symbol_hash.rb

@@ -0,0 +1,35 @@
+module Munge
+  module Util
+    class SymbolHash
+      class << self
+        def deep_convert(obj)
+          if obj.is_a?(Hash)
+            convert_hash(obj)
+          elsif obj.is_a?(Array)
+            obj.map do |i|
+              deep_convert(i)
+            end
+          else
+            obj
+          end
+        end
+
+        private
+
+        def convert_hash(obj)
+          converted_hash = {}
+
+          obj.each do |key, value|
+            if key.is_a?(String) || key.is_a?(Symbol)
+              converted_hash[key.to_sym] = deep_convert(value)
+            else
+              converted_hash[key] = value
+            end
+          end
+
+          converted_hash
+        end
+      end
+    end
+  end
+end

data/lib/munge/version.rb

@@ -1,3 +1,3 @@
 module Munge
-  VERSION = "0.4.0"
+  VERSION = "0.5.0.beta1"
 end

data/lib/munge.rb

@@ -1,25 +1,32 @@
 require "fileutils"
+require "forwardable"
 require "pathname"
 require "set"
 require "yaml"
 
-require "adsf"
-require "rack"
 require "tilt"
 
 require "munge/version"
 require "munge/item"
-require "munge/helper"
+require "munge/util/path"
+require "munge/util/symbol_hash"
+require "munge/util/config"
+require "munge/helper/capture"
 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/routers/auto_add_extension"
+require "munge/routers/fingerprint"
+require "munge/routers/add_index_html"
+require "munge/routers/remove_index_basename"
 require "munge/core/router"
 require "munge/core/item_factory"
 require "munge/core/collection"
 require "munge/core/write"
 require "munge/core/alterant"
+require "munge/system"
 require "munge/application"
 require "munge/runner"
+require "munge/bootstrap"

data/munge.gemspec

@@ -34,4 +34,5 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "adsf", "~> 1.2"
   spec.add_runtime_dependency "thor", "~> 0.19"
   spec.add_runtime_dependency "tilt", "~> 2.0"
+  spec.add_runtime_dependency "sass", "~> 3.4"
 end

data/seeds/config.yml

@@ -3,6 +3,7 @@ output: dest
 data: data.yml
 layouts: layouts
 index: index.html
+fingeprint_separator: "-"
 text_extensions:
   - html
   - htm

data/seeds/data.yml

@@ -1 +1,2 @@
 ---
+site_name: Munge

data/seeds/layouts/default.html.erb

@@ -2,9 +2,12 @@
 <html lang="en">
 <head>
   <meta charset="UTF-8">
-  <title>Munge</title>
+  <title><%= site_name %></title>
+  <link rel="stylesheet" href="<%= url_for(items["basic.css.scss"]) %>" media="screen" charset="utf-8">
 </head>
 <body>
-  <%= yield %>
+  <div class="layout">
+    <%= yield %>
+  </div>
 </body>
 </html>

data/seeds/layouts/sitemap.html.erb

@@ -0,0 +1,6 @@
+<h2>Sitemap</h2>
+<ul>
+  <% sitemap_pages.each do |page| %>
+    <li><%= link_to page, page[:title] %></li>
+  <% end %>
+</ul>

data/seeds/rules.rb

@@ -1,5 +1,22 @@
+# HTML rules
 app.source
-  .select { |item| item.id == "" }
-  .each   { |item| item.route = "/" }
+  .select { |item| item.extensions.include?("html") }
+  .each   { |item| item.route = item.id }
   .each   { |item| item.layout = "default" }
   .each   { |item| item.transform }
+
+# CSS rules
+app.source
+  .select { |item| item.extensions.include?("scss") }
+  .reject { |item| item.basename[0] == "_" }
+  .each   { |item| item.route = "/styles/#{item.basename}.css" }
+  .each   { |item| item.transform }
+
+# Sitemap
+html_pages =
+  app.source
+    .reject  { |item| item.route.nil? }
+    .select  { |item| item.extensions.include?("html") }
+    .sort_by { |item| item.route }
+
+system.global_data[:sitemap_pages] = html_pages

data/seeds/setup.rb

@@ -0,0 +1,15 @@
+require "sass"
+Sass.load_paths << File.expand_path(system.config[:source], File.dirname(__FILE__))
+
+tilt_transformer = Transformer::Tilt.new(system)
+tilt_transformer.register(Munge::Helper::Capture)
+tilt_transformer.register(Munge::Helper::Find)
+tilt_transformer.register(Munge::Helper::Link)
+tilt_transformer.register(Munge::Helper::Rendering)
+
+system.alterant.register(tilt_transformer)
+
+system.router.register(Router::Fingerprint.new(extensions: system.config[:keep_extensions], separator: system.config[:fingeprint_separator]))
+system.router.register(Router::RemoveIndexBasename.new(html_extensions: system.config[:text_extensions], index: system.config[:index]))
+system.router.register(Router::AddIndexHtml.new(html_extensions: system.config[:text_extensions], index: system.config[:index]))
+system.router.register(Router::AutoAddExtension.new(keep_extensions: system.config[:keep_extensions]))

data/seeds/src/_vars.scss

@@ -0,0 +1,6 @@
+$color-bg: #fff;
+$color-fg: #0f0f0f;
+
+$layout-width: 600px;
+
+$golden: 1.618;

data/seeds/src/about.html.erb

@@ -0,0 +1,11 @@
+---
+title: About
+---
+
+<h1>About</h1>
+
+<p>
+  This is an example of a cool About page.
+</p>
+
+<%= render(layouts["sitemap"]) %>

data/seeds/src/basic.css.scss

@@ -0,0 +1,41 @@
+@import "vars";
+
+body {
+  background-color: $color-bg;
+  color: $color-fg;
+  font-family: "Helvetica Neue", "Helvetica", "Arial", sans-serif;
+  font-size: 16px;
+  line-height: $golden * 1em;
+  margin: $golden * 1em;
+}
+
+h1 {
+  font-size: $golden * $golden * 1em;
+  font-weight: normal;
+  line-height: $golden * 1em;
+  margin: 0;
+}
+
+h2 {
+  font-size: $golden * 1em;
+  font-weight: normal;
+  line-height: $golden;
+  margin: 0;
+}
+
+p {
+  margin: $golden * 0.5em 0;
+}
+
+code {
+  font-family: "Courier New", Courier, monospace;
+}
+
+ul {
+  margin: $golden * 0.5em 0;
+}
+
+.layout {
+  width: $layout-width;
+  margin: 0 auto;
+}

data/seeds/src/index.html.erb

@@ -3,3 +3,37 @@ title: Welcome
 ---
 
 <h1><%= title %></h1>
+
+<h2>Getting started</h2>
+
+<p>
+  <strong><code>rules.rb</code>:</strong>
+  The routing rules are defined in this file.
+</p>
+
+<p>
+  <strong><code>setup.rb</code>:</strong>
+  Plugins, gems, etc can be configured in this file.
+</p>
+
+<p>
+  <strong><code>data.yml</code>:</strong>
+  The keys defined in this file are accessible in every file that you author.
+</p>
+
+<p>
+  <strong><code>config.yml</code>:</strong>
+  The keys defined here are used to change the behavior of the app.
+  Many of the keys are passed directly into the initializers in
+  <code>setup.rb</code>.
+</p>
+
+<h2>Links</h2>
+
+<ul>
+  <li><a href="https://github.com/zachahn/munge">Munge homepage</a></li>
+  <li><a href="https://github.com/zachahn/munge/issues">Munge issues</a></li>
+  <li><a href="https://rubygems.org/gems/munge">Gem homepage</a></li>
+</ul>
+
+<%= render(layouts["sitemap"]) %>