middleman-mdocs 0.1.0.62562 → 0.1.1.64612

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a178d824ca8aa52558c1d79e3caa57d591f7ca6061de94e7aa7bf8beb2deac5
-  data.tar.gz: 3ae7963d4b26818877c8263dd682d7da4e425cad6eea79d0910c0218b870a8d8
+  metadata.gz: 0017d29f60525f2e65face5f38e5e4aa16f95251a57ae549c6ed85fa6d3b7630
+  data.tar.gz: d2faa46fa54fe14164b4d0b96ded110a19964ebe996a85ef9846f0ac4d4cbe59
 SHA512:
-  metadata.gz: 9e8662688f936f346461d76a3c02e531de5330ac1d99edcfe9cd44a61ce4fdbde488e1c918d00b00c51559f83532cf898af5ce8238761d66412fbc87e3bf8135
-  data.tar.gz: 151d8aa1ba4f99207382b1e976b1c28daecdf8618d578b6221952802f071b0fae09782a97ffed92d30bb986adef2c3d6488b56c2fc33f44b2b5a2eac451f7202
+  metadata.gz: 58494151dd0490fd1579ceb58a6e258d88de1ea5b0aefc3f0a03f5c2a76e299b74065e9ab6f19849f31b0ff8df2c71c0728bd1684084bcac1a959254148e6a46
+  data.tar.gz: cb8dec229b7f5c32a9c9c79a6c734954275a6908f7e6354ac85ece03cd9be6096323ddae40bafddec0acd6092f4aa50924e020aed0a718dbcfc9b6dfe918b402

data/Gemfile

@@ -2,13 +2,13 @@
 
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in mdocs.gemspec
-gemspec
-
 gem 'rake', '~> 13.0'
-gem 'simplecov', '~> 0.21'
 gem 'rspec', '~> 3.10'
 gem 'rspec_junit_formatter', '~> 0.4'
+gem 'simplecov', '~> 0.21'
 gem 'simplecov-console'
 
 gem 'rubocop', require: false
+
+# Specify your gem's dependencies in mdocs.gemspec
+gemspec

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    middleman-mdocs (0.1.0.62562)
+    middleman-mdocs (0.1.1.64612)
       activesupport
       awesome_print
       kramdown
@@ -221,4 +221,4 @@ DEPENDENCIES
   simplecov-console
 
 BUNDLED WITH
-   2.2.26
+   2.2.28

data/bin/console

@@ -2,7 +2,9 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
-require 'mdocs'
+require 'middleman-mdocs'
+require 'middleman-mdocs/extension'
+require 'middleman-mdocs/deps'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.

data/lib/middleman-mdocs/controller.rb

@@ -1,38 +1,99 @@
 module MiddlemanMdocs
   class Controller
-    attr_reader :nav, :sitemap, :app
+    attr_reader :nav, :extension, :sitemap, :app, :ready
+
+    include(::MiddlemanMdocs::TOC)
+
+    def initialize(extension)
+      @extension = extension
+
+      @app = extension.app
+      @sitemap = app.sitemap
 
-    def initialize(sitemap)
-      @sitemap = sitemap
-      @app = sitemap.app
       @guards = {}
+      @dependencies = {}
+      @metadata = {}
+      @updated = SecureRandom.hex
+      @resources = {}
+    end
+
+    def register(resource)
+      if (old = @resources[resource.page_id])
+        resource.copy_from(old)
+      end
+
+      @resources[resource.page_id] = resource
+    end
+
+    def refresh
+      @updated = SecureRandom.hex
+      @ready = true
+    end
+
+    def nav
+      with_cache(:nav) do
+        ::MiddlemanMdocs::Navigation.parse(app.data.mdocs['nav'])
+      end
+    end
+
+    def ready?
+      @ready
+    end
+
+    def add_dependency(resource, child)
+      @dependencies[resource.page_id] ||= {}
+      @dependencies[resource.page_id][child.page_id] = child
+    end
+
+    def dependencies(resource)
+      @dependencies[resource.page_id]&.values || []
+    end
+
+    def metadata(resource, key, default)
+      @metadata[resource.page_id] ||= {}
+      @metadata[resource.page_id][key] ||= default
+    end
+
+    def set_metadata(resource, key, data)
+      @metadata[resource.page_id] ||= {}
+      @metadata[resource.page_id][key] = data
+    end
+
+    def page_id
+      self.class.to_s
     end
 
-    def load(mdocs)
-      @nav = ::MiddlemanMdocs::Navigation.parse(mdocs['nav'])
+    def init_resource(resource)
+      resource.extend(::MiddlemanMdocs::Resource) unless resource.is_a?(::MiddlemanMdocs::Resource)
+      resource.extension = extension
+      resource.mdocs = self
     end
 
     def tags
-      sitemap.resources.select { |r| r.is_a?(::MiddlemanMdocs::Resource) }.map do |r|
-        guard_recursive('tags', r.path, []) do |_key|
+      with_cache(:tags, dependencies(self).map(&:timestamp).max) do
+        sitemap.resources.select do |r|
+          r.is_a?(::MiddlemanMdocs::Resource) && !r.metadata[:ignore] && r.html?
+        end.map do |r|
+          add_dependency(self, r)
+          # r.options[:tags]
           r.tags
-        end
-      end.flatten.compact.map(&:to_sym).uniq
+        end.flatten.compact.map(&:to_s).uniq.sort
+      end
     end
 
     def has_tag?(tag)
-      tags.include?(tag.to_sym)
+      tags.include?(tag.to_s)
     end
 
     def select_by_meta(meta)
       with_ensure_resource do
-        if meta.is_a? Hash
-          sitemap.resources.select do |resource|
-            resource.is_a?(::MiddlemanMdocs::Resource) && resource.meta_match?(meta) && resource.template?
-          end
-        else
-          sitemap.resources.select do |resource|
-            resource.is_a?(::MiddlemanMdocs::Resource) && resource.has_meta?(*meta) && resource.template?
+        sitemap.resources.select do |r|
+          next false unless r.is_a?(::MiddlemanMdocs::Resource) && !r.metadata[:ignore] && r.template?
+
+          if meta.is_a? Hash
+            r.meta_match?(meta)
+          else
+            r.has_meta?(*meta)
           end
         end
       end
@@ -40,29 +101,35 @@ module MiddlemanMdocs
 
     def select_by_meta_force(meta)
       with_ensure_resource do
-        if meta.is_a? Hash
-          sitemap.resources.select do |resource|
-            resource.is_a?(::MiddlemanMdocs::Resource) && resource.meta_match?(meta)
-          end
-        else
-          sitemap.resources.select do |resource|
-            resource.is_a?(::MiddlemanMdocs::Resource) && resource.has_meta?(*meta)
+        sitemap.resources.select do |r|
+          next false unless r.is_a?(::MiddlemanMdocs::Resource) && !r.metadata[:ignore]
+
+          if meta.is_a? Hash
+            r.meta_match?(meta)
+          else
+            r.has_meta?(*meta)
           end
         end
       end
     end
 
     def select_by_tags(*tags)
+      tags = [tags].flatten.compact.uniq
+
       with_ensure_resource do
-        sitemap.resources.select do |resource|
-          resource.is_a?(::MiddlemanMdocs::Resource) && resource.has_tags?(*tags) && resource.template?
+        sitemap.resources.select do |r|
+          next false unless r.is_a?(::MiddlemanMdocs::Resource) && !r.metadata[:ignore] && r.template?
+
+          r.has_tags?(*tags)
         end
       end
     end
 
     def select(tags, *meta)
-      select_by_meta(*meta).select do |resource|
-        resource.is_a?(::MiddlemanMdocs::Resource) && resource.has_tags?(*tags) && resource.template?
+      tags = [tags].flatten.compact.uniq
+
+      select_by_meta(*meta).select do |r|
+        r.has_tags?(*tags)
       end
     end
 
@@ -76,10 +143,20 @@ module MiddlemanMdocs
     end
 
     def tr(tag, scope: :tags)
+      ::MiddlemanMdocs::Controller.tr(tag, scope: scope)
+    end
+
+    def self.tr(tag, scope: :tags)
       I18n.t(tag.to_s.upcase.presence, scope: [:mdocs, scope],
                                        default: I18n.t(tag.to_s.downcase.presence, scope: [:mdocs, scope], default: tag.to_s).presence)
     end
 
+    private
+
+    def with_cache(*key, &block)
+      extension.cache.fetch([:controller, @updated, *key], &block)
+    end
+
     def guard_recursive(name, key, default = nil)
       guard = @guards[name] ||= {}
       return guard[key] if guard.has_key?(key)

data/lib/middleman-mdocs/deps.rb

@@ -0,0 +1,12 @@
+require 'kramdown/parser'
+require 'kramdown/converter'
+
+require 'mdocs_kramdown'
+require 'kramdown/parser/mdocs_kramdown'
+
+require_relative 'resource'
+require_relative 'toc'
+require_relative 'tilt_template'
+require_relative 'navigation'
+require_relative 'controller'
+require_relative 'sitemap'

data/lib/middleman-mdocs/extension.rb

@@ -1,37 +1,57 @@
+require 'active_support/cache'
+require 'active_support/cache/memory_store'
+
+require 'middleman-core/util'
+require 'middleman-core/util/files'
+
+module Middleman
+  module Util
+    include Contracts
+
+    module_function
+
+    # Finds files which should also be considered to be dirty when
+    # the given file(s) are touched.
+    #
+    # @param [Middleman::Application] app The app.
+    # @param [Pathname] files The original touched file paths.
+    # @return [Middleman::SourceFile] All related file paths, not including the source file paths.
+    Contract ::Middleman::Application, ArrayOf[Pathname] => ArrayOf[::Middleman::SourceFile]
+    def find_related_files(_app, _files)
+      []
+    end
+  end
+end
+
 module MiddlemanMdocs
   class Extension < Middleman::Extension
     attr_reader :mdocs, :mdocsnav, :mdocsmeta
 
+    cattr_reader :cache
+
     expose_to_application :mdocs, :mdocsnav
     expose_to_template :mdocs, :mdocsnav
+
     expose_to_config :mdocs, :enrich_metadata
+    expose_to_config :mdocs, :static_sitemap
 
     def initialize(*args, **_kwargs, &block)
       super
 
       # Only require dependency on activation
-      require 'kramdown/parser'
-      require 'kramdown/converter'
-
-      require 'mdocs_kramdown'
-      require 'kramdown/parser/mdocs_kramdown'
+      require_relative 'deps'
 
-      require_relative 'resource'
-      require_relative 'toc'
-      require_relative 'tilt_template'
-      require_relative 'navigation'
-      require_relative 'controller'
-      require_relative 'sitemap'
+      # @@cache ||= ActiveSupport::Cache::MemoryStore.new(size: 100.megabytes)
+      @@cache ||= ActiveSupport::Cache::FileStore.new('tmp/mdocs/cache')
 
-      @mdocs = Controller.new(app.sitemap)
+      register_helpers(::MiddlemanMdocs::Navigation)
 
       configure_application
 
-      register_helpers(::MiddlemanMdocs::TOC)
-      register_helpers(::MiddlemanMdocs::Navigation)
-
       @mdocsmeta = {}
 
+      @mdocs = Controller.new(self)
+
       ::ActiveSupport::Notifications.subscribe('sitemap.update.middleman') do
         lookup = @mdocs.sitemap.instance_variable_get('@_lookup_by_destination_path')
         @mdocs.sitemap.resources.each do |resource|
@@ -41,7 +61,7 @@ module MiddlemanMdocs
     end
 
     def configure_application
-      ::Middleman::Sitemap::Store.include(::MiddlemanMdocs::Sitemap)
+      Middleman::Sitemap::Store.include(::MiddlemanMdocs::Sitemap)
 
       app.config[:markdown_engine] = :kramdown
       app.config[:markdown] = {
@@ -67,9 +87,34 @@ module MiddlemanMdocs
       end
     end
 
+    def after_build
+      $app = app
+      if @sitemap_opts && @sitemap_block
+        interpreter = SitemapGenerator::Interpreter.new(@sitemap_opts.merge(compress: true))
+        interpreter.instance_eval(&@sitemap_block)
+
+        interpreter = SitemapGenerator::Interpreter.new(@sitemap_opts.merge(compress: false))
+        interpreter.instance_eval(&@sitemap_block)
+      end
+    end
+
     def after_configuration
       markdown_exts = %w[markdown mdown md mkd mkdn]
-      ::Tilt.register ::MiddlemanMdocs::TiltTempalte, *markdown_exts
+      ::Tilt.register ::MiddlemanMdocs::TiltTemplate, *markdown_exts
+
+      app.files.on_change :source do |changed, _deleted|
+        resources = changed.map do |_ch|
+          full = changed.first.full_path.to_s
+          app.sitemap.resources.find { |r| r.source_file == full }
+        end.flatten
+
+        resources.compact.each(&:refresh)
+      end
+    end
+
+    def static_sitemap(opts = {}, &block)
+      @sitemap_opts = opts = opts.dup
+      @sitemap_block = block
     end
 
     def enrich_metadata(rx, &block)
@@ -77,18 +122,17 @@ module MiddlemanMdocs
       @enrichers.push([rx, block])
     end
 
-    def ready
-      mdocs.load(app.data.mdocs)
+    helpers do
     end
 
-    helpers do
+    def log(text)
+      logger.debug "[MDOCS] #{Time.now}: #{text}"
     end
 
     def manipulate_resource_list(resources)
+      logger.debug '== [MDOCS] enrich resources...'
       resources.each do |resource|
-        # install MdDocs::Resource extension
-        resource.extend(::MiddlemanMdocs::Resource) unless resource.is_a?(::MiddlemanMdocs::Resource)
-        resource.mdocs_extention = self
+        mdocs.init_resource(resource)
 
         next if resource.metadata[:ignore]
 
@@ -98,8 +142,15 @@ module MiddlemanMdocs
           resource.destination_path << '.html' unless resource.destination_path.end_with?('.html')
         end
 
-        resource.add_tags(*resource.data.tags)
-        resource.add_keywords(*resource.data.keywords)
+        mdocs.register(resource)
+
+        nonce = SecureRandom.hex
+
+        state = cache.fetch([resource.cache_key, :manipulate_resource_list]) do
+          nonce
+        end
+
+        next if mdocs.ready? && nonce != state
 
         # enrich recursive metadata from metadata.yml in each folder
         metadata = get_metadata(resource.source_file)
@@ -111,21 +162,24 @@ module MiddlemanMdocs
             block.call(resource, md)
           end
         end
+
+        resource.refresh
       end
 
+      mdocs.refresh
       resources
     end
 
     def get_metadata(path)
       return {} unless path[app.source_dir.to_s]
 
-      path = ::Pathname.new(path)
+      path = Pathname.new(path)
       current_dir = path.dirname.relative_path_from(app.source_dir).to_s
 
       @mdocsmeta[current_dir] || begin
         tokens = current_dir.split('/')
 
-        ([''] + tokens).reduce(::Pathname('')) do |parent, token|
+        ([''] + tokens).reduce(Pathname('')) do |parent, token|
           return {} if ['.', ','].include?(token)
 
           current = parent.join(token)

data/lib/middleman-mdocs/navigation.rb

@@ -76,7 +76,7 @@ module MiddlemanMdocs
       if block_given?
         link_to("/tags/#{tag}", *args, &block)
       else
-        link_to(I18n.t(tag, scope: %i[mdocs tags], default: tag.to_s), "/tags/#{tag}.html", *args, &block)
+        link_to(I18n.t(tag, scope: %i[mdocs tags], default: tag.to_s), "/tags/#{tag}", *args, &block)
       end
     end
 
@@ -85,28 +85,42 @@ module MiddlemanMdocs
                       url.try(:source_file)
                     elsif url.start_with?('/')
                       app.source_dir.join(url[1..-1]).to_s
+                    elsif current_page
+                      Pathname.new(current_page.source_file).dirname.join(url).to_s
                     else
-                      ::Pathname.new(current_page.source_file).dirname.join(url).to_s
+                      url
                     end
       app.sitemap.resources.find { |r| r.source_file == source_file }
     end
 
     def merge(url)
-      resource = fuzzy_find_resource(url)
+      resource = fuzzy_find_resource(url) || sitemap.find_resource_by_page_id(url)
       raise "unable to find resource by #{url}" unless resource
 
-      current_page.add_tags(*resource.data.fetch(:tags, []))
-      current_page.data.reverse_merge!(resource.data)
+      mdocs.init_resource(resource) unless resource.is_a?(::MiddlemanMdocs::Resource)
+      if current_page
+        current_page.add_tags(resource.tags)
+        current_page.add_keywords(resource.keywords)
+        current_page.data.reverse_merge!(resource.data)
+      end
     end
 
     def include(page_id_or_path, merge: true, render: true)
-      merge(page_id_or_path) if merge
       resource = fuzzy_find_resource(page_id_or_path) || sitemap.find_resource_by_page_id(page_id_or_path)
-      if render
-        resource.render(layout: false)
-      else
-        ::File.read(resource.try(:source_file) || page_id_or_path)
-      end
+      mdocs.add_dependency(current_page, resource)
+
+      mdocs.init_resource(resource) unless resource.is_a?(::MiddlemanMdocs::Resource)
+      result = if render
+                 resource.force_render
+               else
+                 ::File.read(resource.try(:source_file) || page_id_or_path)
+               end
+
+      merge(page_id_or_path) if merge
+      result
+    rescue StandardError => e
+      puts "Error on including #{page_id_or_path.inspect} to #{current_page.inspect}: #{e.inspect}"
+      raise
     end
 
     # some custom magic to find result path to generated resource
@@ -121,6 +135,15 @@ module MiddlemanMdocs
       end
     end
 
+    def current_page
+      r = super
+      if r.nil?
+        @locs&.fetch(:force_current_page, nil)
+      else
+        r
+      end
+    end
+
     # is this is url for current page
     def active_url?(url)
       translated = translate_to_destination(url)

data/lib/middleman-mdocs/resource.rb

@@ -1,57 +1,150 @@
 module MiddlemanMdocs
   module Resource
-    attr_accessor :mdocs_extention
+    attr_accessor :extension, :mdocs, :updated
+
+    def self.normalize_tags(*args)
+      args.flatten.compact.map(&:to_s).map do |tag|
+        ::MiddlemanMdocs::Controller.tr(tag)
+      end.map(&:upcase).uniq.sort
+    end
+
+    def self.normalize_keywords(*args)
+      raw = args.flatten.compact.map(&:to_s)
+      normalized = normalize_tags(raw)
+      (raw + normalized).uniq.sort
+    end
 
     def markdown?
-      true
+      metadata[:markdown]
     end
 
-    def add_options(opts)
-      options.deep_merge!(opts)
+    def html?
+      @html ||= destination_path.end_with?('.html')
     end
 
-    def add_meta(opts)
-      metadata.deep_merge!(opts)
+    def ready?
+      mdocs.ready?
     end
 
-    def add_tags(*args)
-      tags = (options[:tags] ||= [])
-      tags.append(*args.map(&:to_sym))
-      tags = tags.map(&:to_s).map(&:upcase).uniq.map(&:to_sym)
-      options[:tags] = tags
+    def copy_from(other)
+      resource = self
+      unless @patched
+        data.define_singleton_method(:title) do
+          resource.title
+        end
 
-      add_keywords(*args)
-      add_keywords(*args.map { |tag| I18n.t(tag, scope: %i[mdocs tags], default: tag.to_s) })
+        data.define_singleton_method(:keywords) do
+          resource.keywords
+        end
+
+        data.define_singleton_method(:text) do
+          resource.text
+        end
+
+        @patched = true
+      end
+
+      custom_deep_merge!(data, other.data)
+      custom_deep_merge!(metadata, other.metadata)
+
+      self.updated = other.updated
     end
 
-    def add_keywords(*args)
-      keywords = (options[:keywords] ||= [])
-      keywords.append(*args.map(&:to_s))
-      keywords.uniq!
+    def updated_at
+      @updated_at ||= begin
+        ts = data[:updated_at] || metadata[:updated_at] || timestamp
+        ts = DateTime.parse(ts) if ts.is_a?(String)
+        ts
+      end
     end
 
-    def tags
-      unless @rendered
-        unless metadata[:ignore]
-          begin
-            render(layout: false)
-          rescue StandardError
-            nil
-          end
-        end
-        @rendered = true
+    def created_at
+      @created_at ||= begin
+        ts = data[:created_at] || metadata[:created_at] || File.ctime(source_file)
+        ts = DateTime.parse(ts) if ts.is_a?(String)
+        [ts, updated_at].min
       end
-      (options[:tags] ||= [])
+    end
+
+    def timestamp
+      (mdocs.dependencies(self).map(&:timestamp) + [File.mtime(source_file)]).max
+    end
+
+    def cache_key
+      "#{page_id}/#{timestamp}/"
     end
 
     def title
-      return nil unless metadata[:markdown]
+      with_cache(:title, @updated) do
+        data[:title] || metadata[:title] || toc&.children&.first&.raw_text
+      end
+    end
 
-      data[:title] ||= @mdocs_extention.table_of_contents(self).children.first&.raw_text
+    def refresh
+      @guards ||= {}
+
+      # @updated = SecureRandom.hex
+    end
+
+    def text
+      force_render if !metadata[:ignore] && html?
+    end
+
+    def tags
+      with_cache(:tags, @updated) do
+        guard_recursive('tags', page_id, []) do |_key|
+          text
+        end
+
+        options[:tags] = ::MiddlemanMdocs::Resource.normalize_tags(options[:tags], data[:tags], metadata[:tags])
+      end
     end
 
     def keywords
-      (options[:keywords] ||= [])
+      with_cache(:keywords, @updated) do
+        options[:keywords] =
+          ::MiddlemanMdocs::Resource.normalize_keywords(tags, options[:keywords], data[:keywords], metadata[:keywords])
+      end
+    end
+
+    def toc
+      with_cache(:toc, @updated) do
+        if metadata[:ignore] || !html?
+          nil
+        else
+          mdocs.table_of_contents(self)
+        end
+      end
+    end
+
+    def add_options(opts)
+      options.deep_merge!(opts)
+    end
+
+    def add_meta(opts)
+      metadata.deep_merge!(opts)
+    end
+
+    def add_tags(*args)
+      return unless args.flatten.any?
+
+      added = ::MiddlemanMdocs::Resource.normalize_tags(args)
+      return if (added - (options[:tags] || [])).empty?
+
+      @updated = SecureRandom.hex
+      options[:tags] = ::MiddlemanMdocs::Resource.normalize_tags(options[:tags], data[:tags], metadata[:tags], added)
+    end
+
+    def add_keywords(*args)
+      return unless args.flatten.any?
+
+      added = ::MiddlemanMdocs::Resource.normalize_keywords(args)
+      return if (added - (options[:keywords] || [])).empty?
+
+      @updated = SecureRandom.hex
+      options[:keywords] =
+        ::MiddlemanMdocs::Resource.normalize_keywords(options[:tags], options[:keywords], data[:keywords], metadata[:keywords],
+                                                      added)
     end
 
     def meta_match?(meta)
@@ -67,9 +160,60 @@ module MiddlemanMdocs
     end
 
     def has_tags?(*keys)
-      keys.compact!
-      keys.uniq!
       (tags & keys).size == keys.size
     end
+
+    def destination_path(*args)
+      super.force_encoding(Encoding.default_external)
+    end
+
+    def force_render
+      render({ layout: false }, { current_path: path, force_current_page: self })
+    end
+
+    def render(opts = {}, locs = {})
+      return super if nocache? || locs.has_key?('rack') || locs.has_key?(:rack)
+
+      with_cache(Digest::MD5.hexdigest(opts.to_json + locs.to_json) + 'render') do
+        # puts "REFRESH: #{binary?} #{page_id}: #{opts.to_json + locs.to_json}"
+        super
+      end
+    end
+
+    private
+
+    def nocache?
+      binary? || metadata[:ignore] || metadata[:nocache] || data[:nocache]
+    end
+
+    def with_cache(*key, &block)
+      extension.cache.fetch([cache_key, *key], &block)
+    end
+
+    def custom_deep_merge!(left, right)
+      left.merge!(right) do |_key, this_val, other_val|
+        if this_val.is_a?(Hash) && other_val.is_a?(Hash)
+          custom_deep_merge!(this_val, other_val)
+        elsif this_val.is_a?(Array) && other_val.is_a?(Array)
+          this_val.concat(other_val).uniq!
+        else
+          other_val.nil? ? this_val : other_val
+        end
+      end
+    end
+
+    def guard_recursive(name, key, default = nil)
+      @guards ||= {}
+
+      guard = @guards[name] ||= {}
+      return guard[key] if guard.has_key?(key)
+
+      begin
+        guard[key] = default
+        guard[key] = yield(key)
+      ensure
+        guard.delete(key)
+      end
+    end
   end
 end

data/lib/middleman-mdocs/tilt_template.rb

@@ -1,7 +1,7 @@
 require 'middleman-core/renderers/kramdown'
 
 module MiddlemanMdocs
-  class TiltTempalte < ::Middleman::Renderers::KramdownTemplate
+  class TiltTemplate < ::Middleman::Renderers::KramdownTemplate
     def render(*args)
       erb = Middleman::Renderers::ERb::Template.new(file, line, options) { data }
       @data = erb.render(*args)

data/lib/middleman-mdocs/toc.rb

@@ -50,10 +50,13 @@ module MiddlemanMdocs
     ## Generate TOC object tree for current page or source file
     #
     def table_of_contents(page_or_source, input: 'markdown')
+      # puts "#{Process.pid} =>>>> GENERATE TOC: #{page_or_source.try(:page_id) || page_or_source}"
+      # byebug if page_or_source.page_id.force_encoding('UTF-8') == 'docs/services/gis-gmp/import-refunds'
+
       begin
         return nil if page_or_source.metadata[:ignore]
 
-        content = page_or_source.render(layout: false)
+        content = page_or_source.text
         toc = Kramdown::Document.new(content, app.config[:markdown].merge(input: 'html')).to_toc
 
         return Item.parse_kramdown_toc(toc)

data/lib/middleman-mdocs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MiddlemanMdocs
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: middleman-mdocs
 version: !ruby/object:Gem::Version
-  version: 0.1.0.62562
+  version: 0.1.1.64612
 platform: ruby
 authors:
 - Samoylenko Yuri
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-24 00:00:00.000000000 Z
+date: 2021-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -194,6 +194,7 @@ files:
 - bin/setup
 - lib/middleman-mdocs.rb
 - lib/middleman-mdocs/controller.rb
+- lib/middleman-mdocs/deps.rb
 - lib/middleman-mdocs/extension.rb
 - lib/middleman-mdocs/navigation.rb
 - lib/middleman-mdocs/resource.rb