munge 0.18.0 → 0.19.0

data/lib/munge/config.rb

@@ -10,7 +10,7 @@ module Munge
       if @configs.key?(sym_key)
         @configs[sym_key]
       else
-        raise Errors::ConfigKeyNotFound, sym_key
+        raise Error::ConfigKeyNotFound, sym_key
       end
     end
 
@@ -28,7 +28,7 @@ module Munge
       elsif key?(method_name)
         self[method_name]
       else
-        raise Errors::ConfigKeyNotFound, method_name
+        raise Error::ConfigKeyNotFound, method_name
       end
     end
 

data/lib/munge/{system.rb → conglomerate.rb}

@@ -1,5 +1,5 @@
 module Munge
-  class System
+  class Conglomerate
     def initialize(root_path, config)
       @root_path = root_path
       @config = config
@@ -17,28 +17,32 @@ module Munge
       return @items if @items
 
       source_path = File.expand_path(@config[:source_path], @root_path)
+      vfs = Vfs::Filesystem.new(source_path)
 
       @items =
         Collection.new(
-          item_factory: item_factory,
-          items: Readers::Filesystem.new(source_path)
+          items: Reader.new(vfs, item_factory)
         )
     end
 
     def layouts
-      return @layouts if @layouts
+      if @layouts.nil?
+        layouts_path = File.expand_path(@config[:layouts_path], @root_path)
+        vfs = Vfs::Filesystem.new(layouts_path)
 
-      layouts_path = File.expand_path(@config[:layouts_path], @root_path)
+        @layouts =
+          Collection.new(
+            items: Reader.new(vfs, item_factory)
+          )
 
-      @layouts ||=
-        Collection.new(
-          item_factory: item_factory,
-          items: Readers::Filesystem.new(layouts_path)
-        )
+        @layouts.each(&:transform)
+      end
+
+      @layouts
     end
 
     def processor
-      @processor ||= Processor.new
+      @processor ||= Processor.new(self)
     end
 
     def router
@@ -49,10 +53,13 @@ module Munge
     end
 
     def global_data
-      return @global_data if @global_data
+      if @global_data.nil?
+        data_path = File.expand_path(@config[:data_path], @root_path)
+        loaded_file = YAML.load_file(data_path) || {}
+        @global_data = Munge::Util::SymbolHash.deep_convert(loaded_file)
+      end
 
-      data_path = File.expand_path(@config[:data_path], @root_path)
-      @global_data = YAML.load_file(data_path) || {}
+      @global_data
     end
 
     attr_reader :config

data/lib/munge/{system → conglomerate}/collection.rb

@@ -1,39 +1,18 @@
 module Munge
-  class System
+  class Conglomerate
     # This class is effectively an Array of Items
     class Collection
       include Enumerable
 
-      # @param [System::ItemFactory] item_factory
+      # @param [Conglomerate::ItemFactory] item_factory
       # @param [Array<Hash>] items
-      def initialize(item_factory:,
-                     items:)
-        @item_factory = item_factory
-
+      def initialize(items:)
         @items =
           items
-            .map { |item| parse(**item) }
             .map { |item| [item.id, item] }
             .to_h
       end
 
-      # @see System::ItemFactory#build
-      # @param relpath [String]
-      # @param content [String]
-      # @param frontmatter [Hash]
-      # @param stat [File::Stat]
-      def build(**args)
-        @item_factory.build(**args)
-      end
-
-      # @see System::ItemFactory#parse
-      # @param relpath [String]
-      # @param content [String]
-      # @param stat [File::Stat]
-      def parse(**args)
-        @item_factory.parse(**args)
-      end
-
       # @yield [Item]
       # @return [Enumerator]
       def each
@@ -48,7 +27,7 @@ module Munge
       # @return [void]
       def push(item)
         if @items.key?(item.id)
-          raise Errors::DuplicateItemError, item.id
+          raise Error::DuplicateItemError, item.id
         else
           @items[item.id] = item
         end
@@ -60,7 +39,7 @@ module Munge
         if @items.key?(id)
           @items[id]
         else
-          raise Errors::ItemNotFoundError, id
+          raise Error::ItemNotFoundError, id
         end
       end
 

data/lib/munge/{system → conglomerate}/item_factory.rb

@@ -1,5 +1,5 @@
 module Munge
-  class System
+  class Conglomerate
     class ItemFactory
       # @param text_extensions [Array<String>]
       # @param ignore_extensions [Array<String>] Strings are converted to regex

data/lib/munge/{system → conglomerate}/item_factory/content_parser.rb

@@ -1,5 +1,5 @@
 module Munge
-  class System
+  class Conglomerate
     class ItemFactory
       class ContentParser
         def self.match(string)

data/lib/munge/{system → conglomerate}/item_factory/item_identifier.rb

@@ -1,5 +1,5 @@
 module Munge
-  class System
+  class Conglomerate
     class ItemFactory
       class ItemIdentifier
         def initialize(remove_extensions:)

data/lib/munge/conglomerate/processor.rb

@@ -0,0 +1,138 @@
+module Munge
+  class Conglomerate
+    class Processor
+      def initialize(conglomerate)
+        @conglomerate = conglomerate
+
+        @fixer_upper = FixerUpper.new
+        @scope_modules = [
+          Munge::Helper::Capture,
+          Munge::Helper::Find,
+          Munge::Helper::Link,
+          Munge::Helper::Rendering,
+          Munge::Helper::Tag,
+          Munge::Helper::AssetPaths,
+          Munge::Helper::AssetTags,
+          Munge::Helper::Livereload,
+          Munge::Helper::Data,
+        ]
+      end
+
+      def register(*names, to:, with_options: {})
+        @fixer_upper.register(*names, engine: to)
+      end
+
+      def register_tilt(*names, to:, with_options: {})
+        @fixer_upper.register_tilt(*names, engine: to, options: with_options)
+      end
+
+      def include(mod)
+        @scope_modules.push(mod)
+      end
+
+      # Transforms the given item's content
+      #
+      # @param item [Item]
+      def transform(item)
+        view_scope = new_view_scope
+
+        view_scope.data_stack.push(item.frontmatter)
+
+        if item.layout
+          layout_item = @conglomerate.layouts[item.layout]
+
+          transform_layout(layout_item, view_scope) do
+            transform_item(item, view_scope)
+          end
+        else
+          transform_item(item, view_scope)
+        end
+      end
+
+      def transform_item(item, view_scope)
+        renderer =
+          @fixer_upper.renderer(
+            filename: item.relpath,
+            content: item.content,
+            view_scope: view_scope,
+            engines: engines_for(item)
+          )
+
+        renderer.call
+      end
+
+      def transform_layout(layout_item, view_scope, &block)
+        renderer =
+          @fixer_upper.renderer(
+            filename: "(layout) #{layout_item.relpath}",
+            content: layout_item.content,
+            view_scope: view_scope,
+            engines: engines_for(layout_item),
+            block: block
+          )
+
+        renderer.call
+      end
+
+      # everything below should be considered private API
+
+      def private_transform(filename:, content:, view_scope:, engines:, block: nil)
+        renderer =
+          @fixer_upper.renderer(
+            filename: filename,
+            content: content,
+            view_scope: view_scope,
+            engines: resolved_engines(engines, resolve_extensions(filename)),
+            block: block
+          )
+
+        renderer.call
+      end
+
+      def engines_for(item, engine_overrides = [])
+        transforms = resolved_engines(item.transforms, item.extensions)
+        overrides = resolved_engines(engine_overrides, item.extensions)
+
+        if overrides.empty?
+          transforms
+        else
+          overrides
+        end
+      end
+
+      private
+
+      def new_view_scope
+        scope =
+          @scope_modules.reduce(Object.new) do |scope, mod|
+            scope.extend(mod)
+            scope
+          end
+
+        scope.extend(Munge::Helper::DefineModule.new(:conglomerate, @conglomerate))
+        scope.extend(Munge::Helper::DefineModule.new(:current_view_scope, scope))
+
+        scope.data_stack.push(@conglomerate.global_data)
+
+        scope
+      end
+
+      def resolved_engines(engines, extensions)
+        safe_engines = [engines].flatten.compact
+
+        safe_engines.flat_map do |engine|
+          if engine == :use_extensions
+            extensions.reverse
+          else
+            engine
+          end
+        end
+      end
+
+      def resolve_extensions(filename)
+        basename = File.basename(filename)
+        basename.split(".")[1..-1]
+      end
+    end
+  end
+end

data/lib/munge/conglomerate/reader.rb

@@ -0,0 +1,33 @@
+module Munge
+  class Conglomerate
+    # Enumerable list of {Munge::Item}s
+    class Reader
+      include Enumerable
+
+      # @param source_path [String]
+      def initialize(vfs, item_factory)
+        @vfs = vfs
+        @item_factory = item_factory
+      end
+
+      # @yield [Item]
+      # @return [Enumerator]
+      def each
+        return enum_for(:each) unless block_given?
+
+        filepaths = @vfs.tree
+
+        filepaths.each do |relpath|
+          item =
+            @item_factory.parse(
+              relpath: relpath,
+              content: @vfs.read(relpath),
+              stat: @vfs.stat(relpath)
+            )
+
+          yield item
+        end
+      end
+    end
+  end
+end

data/lib/munge/{system → conglomerate}/router.rb

@@ -1,5 +1,5 @@
 module Munge
-  class System
+  class Conglomerate
     class Router
       def initialize(processor:)
         @registries = { route: [], filepath: [] }
@@ -13,7 +13,7 @@ module Munge
         when :filepath
           @registries[:filepath].push(router)
         else
-          raise Errors::InvalidRouterError, router.type
+          raise Error::InvalidRouterError, router.type
         end
       end
 
@@ -32,7 +32,7 @@ module Munge
 
       def route_mapper(item, method_name, initial_route = nil)
         if !item.route && !initial_route
-          raise Errors::ItemHasNoRouteError, item.relpath
+          raise Error::ItemHasNoRouteError, item.relpath
         end
 
         itemish = Itemish.new(item, @processor)

data/lib/munge/{system → conglomerate}/router/itemish.rb

@@ -1,5 +1,5 @@
 module Munge
-  class System
+  class Conglomerate
     class Router
       class Itemish
         extend Forwardable

data/lib/munge/{errors.rb → error.rb}

@@ -1,5 +1,5 @@
 module Munge
-  module Errors
+  module Error
     class Base < StandardError
     end
 
@@ -41,30 +41,6 @@ module Munge
       end
     end
 
-    class DuplicateTransformerError < Base
-      include ErrorWithIdentifier
-
-      def message
-        "already registered transformer `#{@identifier}`"
-      end
-    end
-
-    class TransformerNotFoundError < Base
-      include ErrorWithIdentifier
-
-      def message
-        "transformer `#{@identifier}` is not installed"
-      end
-    end
-
-    class InvalidRouterError < Base
-      include ErrorWithIdentifier
-
-      def message
-        "invalid router with type #{@identifier}"
-      end
-    end
-
     class ConfigRbNotFound < Base
       include ErrorWithIdentifier
 

data/lib/munge/{extras → extra}/livereload.rb

@@ -2,14 +2,14 @@ if Gem.loaded_specs.key?("reel")
   require "celluloid/current"
   require "reel"
 
-  require "munge/extras/livereload/update_server"
-  require "munge/extras/livereload/update_client"
-  require "munge/extras/livereload/messaging"
-  require "munge/extras/livereload/server"
+  require "munge/extra/livereload/update_server"
+  require "munge/extra/livereload/update_client"
+  require "munge/extra/livereload/messaging"
+  require "munge/extra/livereload/server"
 end
 
 module Munge
-  module Extras
+  module Extra
     module Livereload
       class Main
         def initialize(activated)

data/lib/munge/{extras → extra}/livereload/messaging.rb

@@ -1,5 +1,5 @@
 module Munge
-  module Extras
+  module Extra
     module Livereload
       class Messaging
         def hello

data/lib/munge/{extras → extra}/livereload/server.rb

@@ -1,5 +1,5 @@
 module Munge
-  module Extras
+  module Extra
     module Livereload
       class Server < Reel::Server::HTTP
         def initialize(host = "127.0.0.1", port = 35729)