munge 0.4.0 → 0.5.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 493a1b527391a30c807a1c358dda4c9854d1744f
-  data.tar.gz: cc9fbb10a2e927e85074b46d7e232477ade37928
+  metadata.gz: f0ea780f903de0afaf329d50a2e81a69e14b8e4e
+  data.tar.gz: 53d5d6025748b56dbc3394b5080afa7ec107a954
 SHA512:
-  metadata.gz: b4910b7a5825f85eeb970b4c2bc3b5699622f94d2085ad3dbeab5574531425d613fd5653adc5451988507a61b23c758e7a6c0d4f9ce6412591501ca63cbec5cb
-  data.tar.gz: 5e85a223fb27596e2fecb3c78ea4860be786c47d272e3d8a0979d1b9b1a05707a580e5b069cf0bde57f1ea14f792f4114af117397061706062e99af585d43a63
+  metadata.gz: ec154947682821e309c2d781bf7de1692e86c78bbb6f9236d3b46264ee49fcfbd94ea84ce214f6bb09754c81e9507a570265a22212f2e3f637c97433ffbb5914
+  data.tar.gz: 98d471dcfae5960316b92ac17cd4aa9e078d984a74091cfc687b3c4c435ee561f51e1f641efb1e8f6380d8374eb59cb65c84fb5806206580ba99cf830c1a4451

data/.gitignore

@@ -7,3 +7,6 @@
 /pkg/
 /spec/reports/
 /tmp/
+
+/seeds/dest
+.sass-cache

data/.rubocop.yml

@@ -13,6 +13,10 @@ Metrics/MethodLength:
   Exclude:
     - test/**/*
 
+Metrics/ClassLength:
+  Exclude:
+    - test/**/*
+
 Style/AlignParameters:
   Enabled: false
 
@@ -22,8 +26,14 @@ Style/Documentation:
 Style/ClassAndModuleChildren:
   Enabled: false
 
+Style/GuardClause:
+  Enabled: false
+
 Style/IfUnlessModifier:
   Enabled: false
 
+Style/MultilineOperationIndentation:
+  EnforcedStyle: indented
+
 Style/StringLiterals:
   EnforcedStyle: double_quotes

data/Makefile

@@ -0,0 +1,21 @@
+.PHONY: all test testc openc release
+
+all:
+	@echo "usage:"
+	@echo
+	@echo "make test	runs tests"
+	@echo "make testc	runs tests and logs coverage"
+	@echo "make openc	starts webserver in coverage directory"
+	@echo "make release	releases gem (dangerous)"
+
+test:
+	script/test
+
+testc:
+	COVERAGE=1 script/test
+
+openc:
+	cd coverage && adsf
+
+release:
+	bundle exec rake release

data/README.md

@@ -50,7 +50,7 @@ After installing your gem, you can start a project using the command line client
 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
+munge view                  # open http://localhost:7000/ to see output
 ```
 
 The three main files of your application are `config.yml`, `data.yml`, and `rules.rb`.

data/exe/munge

@@ -1,4 +1,10 @@
 #!/usr/bin/env ruby
+
+if File.exist?(File.expand_path("../../.git", __FILE__))
+  lib = File.expand_path("../../lib", __FILE__)
+  $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+end
+
 require "munge"
 require "munge/cli"
 

data/lib/munge/application.rb

@@ -1,77 +1,35 @@
 module Munge
   class Application
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-    def initialize(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)
-
-      @global_data = YAML.load_file(data_path) || {}
-
-      @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)
-        )
-
-      @router =
-        Core::Router.new(
-          index:           config[:index],
-          keep_extensions: config[:keep_extensions]
-        )
-
-      @alterant =
-        Core::Alterant.new(scope: self)
-
-      @writer =
-        Core::Write.new(
-          output: output_path
-        )
-
-      @alterant.register(Transformer::Tilt.new(self))
+    def initialize(system)
+      @system = system
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-    attr_reader :source
+    def source
+      @system.source
+    end
 
     def write(&block)
-      @source
+      @system.source
         .reject { |item| item.route.nil? }
         .each   { |item| render_and_write(item, &block) }
     end
 
     def build_virtual_item(*args)
-      @source.build(*args)
+      @system.source.build(*args)
     end
 
-    def create(*args, &block)
+    def create(*args)
       item = build_virtual_item(*args)
       yield item if block_given?
-      @source.push(item)
+      @system.source.push(item)
     end
 
     private
 
     def render_and_write(item, &block)
-      relpath = @router.filepath(item)
+      relpath = @system.router.filepath(item)
 
-      write_status = @writer.write(relpath, @alterant.transform(item))
+      write_status = @system.writer.write(relpath, @system.alterant.transform(item))
 
       if block_given?
         block.call(item, write_status)

data/lib/munge/bootstrap.rb

@@ -0,0 +1,63 @@
+module Munge
+  class Bootstrap
+    class << self
+      def new_from_dir(root_path:)
+        new_from_fs(
+          root_path: root_path,
+          config_path: config_path(root_path),
+          setup_path: setup_path(root_path),
+          rules_path: rules_path(root_path)
+        )
+      end
+
+      def new_from_fs(root_path:,
+                      config_path:,
+                      setup_path:,
+                      rules_path:)
+        new(
+          root_path: root_path,
+          config: read_config(config_path),
+          setup_string: File.read(setup_path),
+          setup_path: setup_path,
+          rules_string: File.read(rules_path),
+          rules_path: rules_path
+        )
+      end
+
+      private
+
+      def read_config(config_path)
+        Munge::Util::Config.read(config_path)
+      end
+
+      def config_path(root_path)
+        File.join(root_path, "config.yml")
+      end
+
+      def setup_path(root_path)
+        File.join(root_path, "setup.rb")
+      end
+
+      def rules_path(root_path)
+        File.join(root_path, "rules.rb")
+      end
+    end
+
+    def initialize(root_path:,
+                   config:,
+                   setup_string:,
+                   rules_string:,
+                   setup_path:,
+                   rules_path:)
+      system = Munge::System.new(root_path, config)
+
+      binding.eval(setup_string, setup_path)
+
+      @app = Munge::Application.new(system)
+
+      binding.eval(rules_string, rules_path)
+    end
+
+    attr_reader :app
+  end
+end

data/lib/munge/cli.rb

@@ -1,5 +1,7 @@
 require "thor"
 
+require_relative "commands/view"
+
 module Munge
   class CLI < Thor
     include Thor::Actions
@@ -15,28 +17,14 @@ module Munge
 
     desc "build", "Build in current directory"
     def build
-      Munge::Runner.write(config_path, rules_path)
+      Munge::Runner.write(destination_root)
     end
 
     desc "view", "View built files"
-    method_option :port, aliases: "-p", desc: "Set port", default: 3000, type: :numeric
+    method_option :port, aliases: "-p", desc: "Set port", default: 7000, 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)
+      Munge::Commands::View.new(options, config_path)
     end
 
     desc "version", "Print version"

data/lib/munge/commands/view.rb

@@ -0,0 +1,46 @@
+# Copyright (c) 2007-2015 Denis Defreyne and contributors
+# Copyright (c) 2015 Zach Ahn
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+# https://github.com/nanoc/nanoc/blob/fdf8b28/lib/nanoc/cli/commands/view.rb#L17-L53
+
+require "adsf"
+require "rack"
+
+module Munge
+  class Commands
+    class View
+      def initialize(options, config_path)
+        config    = Munge::Util::Config.read(config_path)
+        rack_opts = { Host: options[:host], Port: options[:port] }
+
+        app =
+          Rack::Builder.new do
+            use Rack::ShowExceptions
+            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
+    end
+  end
+end

data/lib/munge/core/alterant.rb

@@ -12,7 +12,7 @@ module Munge
 
       # name should be snake_case Symbol
       def register_manually(name, transformer)
-        if @registry.has_key?(name)
+        if @registry.key?(name)
           fail "already registered transformer `#{name}`"
         else
           @registry[name] = transformer
@@ -32,7 +32,7 @@ module Munge
       private
 
       def get_transformer(name)
-        if @registry.has_key?(name)
+        if @registry.key?(name)
           @registry[name]
         else
           fail "transformer `#{name}` is not installed"

data/lib/munge/core/collection.rb

@@ -42,7 +42,7 @@ module Munge
       private
 
       def prune_args(args)
-        args.select { |k, v| %i(relpath content frontmatter stat).include?(k) }
+        args.select { |k, _| %i(relpath content frontmatter stat).include?(k) }
       end
     end
   end

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

@@ -29,11 +29,14 @@ module Munge
 
           parsed_frontmatter = YAML.load(matchdata[1])
 
-          if parsed_frontmatter
-            parsed_frontmatter
-          else
-            {}
-          end
+          frontmatter_hash =
+            if parsed_frontmatter.is_a?(Hash)
+              parsed_frontmatter
+            else
+              {}
+            end
+
+          Munge::Util::SymbolHash.deep_convert(frontmatter_hash)
         end
 
         def self.parse_content(matchdata, string)
@@ -44,15 +47,8 @@ module Munge
           end
         end
 
-        def initialize(string, frontmatter = nil)
+        def initialize(string)
           @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/core/item_factory.rb

@@ -58,18 +58,6 @@ module Munge
 
       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)
@@ -85,17 +73,6 @@ module Munge
         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)
@@ -114,7 +91,7 @@ module Munge
       end
 
       def compute_dirname(relpath)
-        dirname = File.dirname(relpath)
+        File.dirname(relpath)
       end
 
       def compute_basename(relpath)

data/lib/munge/core/router/itemish.rb

@@ -0,0 +1,22 @@
+module Munge
+  module Core
+    class Router
+      class Itemish
+        extend Forwardable
+
+        def initialize(item, alterant)
+          @item     = item
+          @alterant = alterant
+        end
+
+        def compiled_content
+          @compiled_content ||= @alterant.transform(@item)
+        end
+
+        def_delegators :@item, *%i(type relpath id frontmatter stat layout)
+        def_delegators :@item, *%i(dirname filename basename extensions)
+        def_delegators :@item, *%i(relpath? route?)
+      end
+    end
+  end
+end

data/lib/munge/core/router.rb

@@ -1,62 +1,53 @@
+require_relative "router/itemish"
+
 module Munge
   module Core
     class Router
-      def initialize(index:, keep_extensions:)
-        @index          = index
-        @keep_extensions = keep_extensions
+      def initialize(alterant:)
+        @registries = { route: [], filepath: [] }
+        @alterant = alterant
       end
 
-      def route(item)
-        fail "item has no route" unless item.route
-
-        if keep_extension?(item)
-          "/#{filepath(item)}"
+      def register(router)
+        case router.type
+        when :route
+          @registries[:route].push(router)
+        when :filepath
+          @registries[:filepath].push(router)
         else
-          item.route
+          fail "invalid router"
         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
+      def route(item)
+        path = route_mapper(item, :route)
+        Util::Path.ensure_abspath(path)
+      end
 
-        relativeize(path)
+      def filepath(item)
+        initial_route = route(item)
+        path = route_mapper(item, :filepath, initial_route)
+        Util::Path.ensure_relpath(path)
       end
 
       private
 
-      def relativeize(path)
-        while path[0] == "/"
-          path = path[1..-1]
+      def route_mapper(item, method_name, initial_route = nil)
+        if !item.route && !initial_route
+          fail "item has no route"
         end
 
-        path
-      end
+        itemish = Itemish.new(item, @alterant)
 
-      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)
+        @registries[method_name]
+          .select { |router| router.type == method_name }
+          .inject(initial_route || item.route) do |route, router|
+            if router.match?(route, itemish)
+              router.call(route, itemish)
+            else
+              route
+            end
+          end
       end
     end
   end

data/lib/munge/helper/capture.rb

@@ -0,0 +1,24 @@
+module Munge
+  module Helper
+    module Capture
+      def capture(&block)
+        original_erbout = block.binding.local_variable_get(:_erbout)
+        block.binding.local_variable_set(:_erbout, "")
+
+        captured_text = block.call
+
+        block.binding.local_variable_set(:_erbout, original_erbout)
+
+        captured_text
+      end
+
+      def append_to_erbout(block_binding, text)
+        original_erbout = block_binding.local_variable_get(:_erbout)
+
+        updated_erbout = original_erbout + text
+
+        block_binding.local_variable_set(:_erbout, updated_erbout)
+      end
+    end
+  end
+end

data/lib/munge/helper/find.rb

@@ -4,6 +4,10 @@ module Munge
       def items
         @source
       end
+
+      def layouts
+        @layouts
+      end
     end
   end
 end

data/lib/munge/helper/link.rb

@@ -5,9 +5,14 @@ module Munge
         @router.route(item)
       end
 
-      def link_to(item, text = nil, **opts)
+      def link_to(item, text = nil, opts = {})
         link = url_for(item)
 
+        if text.is_a?(Hash)
+          opts = text
+          text = nil
+        end
+
         optstr = opts.map { |key, val| %(#{key}="#{val}") }
 
         parts =

data/lib/munge/helper/rendering.rb

@@ -21,8 +21,6 @@ module Munge
         inner =
           if block_given?
             yield
-          else
-            nil
           end
 
         engines

data/lib/munge/item.rb

@@ -91,8 +91,8 @@ module Munge
 
     def remove_surrounding_slashes(string)
       string
-        .sub(%r(^/+), "")
-        .sub(%r(/+$), "")
+        .sub(%r{^/+}, "")
+        .sub(%r{/+$}, "")
     end
   end
 end

data/lib/munge/routers/add_index_html.rb

@@ -0,0 +1,36 @@
+module Munge
+  module Router
+    class AddIndexHtml
+      def initialize(html_extensions:, index:)
+        @html_extensions = html_extensions
+        @index           = index
+      end
+
+      def type
+        :filepath
+      end
+
+      def match?(initial_route, item)
+        item_is_html?(item) && route_needs_extension?(initial_route)
+      end
+
+      def call(initial_route, _item)
+        File.join(initial_route, @index)
+      end
+
+      private
+
+      def item_is_html?(item)
+        intersection = item.extensions & @html_extensions
+
+        intersection.length > 0
+      end
+
+      def route_needs_extension?(route)
+        basename = File.basename(route)
+
+        !basename.include?(".")
+      end
+    end
+  end
+end