frontman-ssg 0.0.2

data/lib/frontman/helpers/render_helper.rb

@@ -0,0 +1,76 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'frontman/config'
+require 'frontman/context'
+require 'frontman/renderers/markdown_renderer'
+require 'frontman/renderers/erb_renderer'
+require 'frontman/resource'
+require 'sorbet-runtime'
+
+module RenderHelper
+  extend T::Sig
+
+  sig do
+    params(template: String, data: T.any(Hash, CustomStruct))
+      .returns(String)
+  end
+  def partial(template, data = {})
+    partial_dir = Frontman::Config.get(
+      :partial_dir, fallback: 'views/partials'
+    )
+    r = Frontman::Resource.from_path(
+      File.join(partial_dir, template), nil, false
+    )
+    r.render(nil, data)
+  end
+
+  sig do
+    params(
+      page: Frontman::Resource, options: T.any(Hash, CustomStruct)
+    ).returns(String)
+  end
+  def render_page(page, options = {})
+    # We force not to render any layout
+    options[:layout] = nil
+    options[:ignore_page] = true
+
+    # We don't need to cache here since it already done in the render function
+    # of the resource
+    page.render(nil, options)
+  end
+
+  sig do
+    params(options: T.any(Hash, CustomStruct)).returns(String)
+  end
+  def render_current_page(options = {})
+    render_page(Frontman::App.instance.current_page, options)
+  end
+
+  sig { params(content: String).returns(String) }
+  def render_markdown(content)
+    compiled = Frontman::MarkdownRenderer.instance.compile(content)
+    Frontman::MarkdownRenderer.instance.render(
+      compiled, nil, Frontman::Context.new, {}
+    )
+  end
+
+  sig do
+    params(
+      content: String,
+      template_data: T.nilable(Hash)
+    ).returns(String)
+  end
+  def render_erb(content, template_data = nil)
+    context = Frontman::Context.new
+
+    if !template_data.nil? && template_data
+      template_data.each do |key, value|
+        context.singleton_class.send(:define_method, key) { value }
+      end
+    end
+
+    compiled = Frontman::ErbRenderer.instance.compile(content)
+    Frontman::ErbRenderer.instance.render(compiled, nil, context, {})
+  end
+end

data/lib/frontman/helpers/url_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module UrlHelper
+  def format_url(url)
+    formatted = url.gsub('index.html', '')
+                   .sub(%r{^/}, '')
+                   .chomp('/')
+
+    "/#{formatted}/".gsub('//', '/')
+  end
+end

data/lib/frontman/iterator.rb

@@ -0,0 +1,48 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'parallel'
+
+module Frontman
+  class Iterator
+    class << self
+      extend T::Sig
+
+      def map(collection, *options, &block)
+        forward(:map, collection, *options, &block)
+      end
+
+      def each(collection, *options, &block)
+        forward(:each, collection, *options, &block)
+      end
+
+      def map_with_index(collection, *options, &block)
+        forward(:map_with_index, collection, *options, &block)
+      end
+
+      def each_with_index(collection, *options, &block)
+        forward(:each_with_index, collection, *options, &block)
+      end
+
+      def processor_count
+        return Parallel.processor_count if parallel?
+
+        Frontman::Config.get(:processor_count, fallback: 1)
+      end
+
+      private
+
+      def parallel?
+        Frontman::Config.get(:parallel, fallback: true)
+      end
+
+      def forward(method, collection, *options, &block)
+        if parallel?
+          return ::Parallel.public_send(method, collection, *options, &block)
+        end
+
+        collection.public_send(method, &block)
+      end
+    end
+  end
+end

data/lib/frontman/process/chain.rb

@@ -0,0 +1,43 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module Frontman
+  module Process
+    class Chain
+      extend T::Sig
+
+      sig do
+        params(
+          processors: T::Array[Frontman::Process::Processor]
+        ).returns(T.self_type)
+      end
+      def initialize(processors = [])
+        @processors = []
+
+        add_processors(processors)
+      end
+
+      sig do
+        params(
+          processors: T.any(
+            Frontman::Process::Processor,
+            T::Array[Frontman::Process::Processor]
+          )
+        ).returns(T.self_type)
+      end
+      def add_processors(processors)
+        @processors.push(*Array(processors))
+        self
+      end
+
+      sig { params(arguments: T.untyped).returns(T::Array[T.untyped]) }
+      def process(*arguments)
+        @processors.map do |processor|
+          processor.process(*arguments)
+        end
+      end
+    end
+  end
+end

data/lib/frontman/process/processor.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Frontman
+  module Process
+    class Processor
+      def process(*_args)
+        raise NoMethodError 'process method is not implemented'
+      end
+    end
+  end
+end

data/lib/frontman/renderers/erb_renderer.rb

@@ -0,0 +1,21 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'erubis'
+require 'frontman/renderers/renderer'
+
+module Frontman
+  class ErbRenderer < Frontman::Renderer
+    def compile(layout)
+      Erubis::Eruby.new(layout, bufvar: '@_erbout')
+    end
+
+    def render_content(compiled, content, scope, data)
+      data.each do |key, value|
+        scope.singleton_class.send(:define_method, key) { value }
+      end
+
+      compiled.result(scope.get_binding { content })
+    end
+  end
+end

data/lib/frontman/renderers/haml_renderer.rb

@@ -0,0 +1,22 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'haml'
+require 'frontman/renderers/renderer'
+
+module Frontman
+  class HamlRenderer < Renderer
+    def initialize
+      Haml::Options.defaults[:format] = :html5
+      super
+    end
+
+    def compile(layout)
+      Haml::Engine.new(layout)
+    end
+
+    def render_content(compiled, content, scope, _data)
+      compiled.render(scope.get_binding) { content }
+    end
+  end
+end

data/lib/frontman/renderers/markdown_renderer.rb

@@ -0,0 +1,26 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'kramdown'
+require 'frontman/renderers/renderer'
+
+module Frontman
+  class MarkdownRenderer < Frontman::Renderer
+    def compile(layout)
+      Kramdown::Document.new(
+        layout,
+        syntax_highlighter: 'rouge',
+        parse_block_html: true,
+        fenced_code_blocks: true,
+        input: 'GFM',
+        with_toc_data: true,
+        smartypants: true,
+        hard_wrap: false
+      )
+    end
+
+    def render_content(compiled, _content, _scope, _data)
+      compiled.to_html
+    end
+  end
+end

data/lib/frontman/renderers/renderer.rb

@@ -0,0 +1,26 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Frontman
+  class Renderer
+    include Singleton
+
+    def compile(_layout)
+      raise('Should be implemented in child classes')
+    end
+
+    def render(compiled, content, scope, data)
+      Frontman::App.instance.view_data.push(data)
+      content = render_content(compiled, content, scope, data)
+      Frontman::App.instance.view_data.pop
+
+      content
+    end
+
+    def render_content(_compiled, _content, _scope, _data)
+      raise('Should be implemented in child classes')
+    end
+  end
+end

data/lib/frontman/renderers/renderer_resolver.rb

@@ -0,0 +1,26 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'frontman/renderers/erb_renderer'
+require 'frontman/renderers/haml_renderer'
+require 'frontman/renderers/markdown_renderer'
+require 'singleton'
+require 'sorbet-runtime'
+
+module Frontman
+  class RendererResolver
+    extend T::Sig
+    include Singleton
+
+    sig { params(extension: String).returns(T.nilable(Frontman::Renderer)) }
+    def get_renderer(extension)
+      renderers = {
+        'erb': Frontman::ErbRenderer.instance,
+        'md': Frontman::MarkdownRenderer.instance,
+        'haml': Frontman::HamlRenderer.instance
+      }
+
+      renderers[extension.to_sym]
+    end
+  end
+end

data/lib/frontman/resource.rb

@@ -0,0 +1,279 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'frontman/renderers/renderer_resolver'
+require 'frontman/custom_struct'
+require 'frontman/context'
+require 'frontman/app'
+require 'frontman/sitemap_tree'
+require 'sorbet-runtime'
+require 'yaml/front-matter'
+
+module Frontman
+  class Resource
+    extend T::Sig
+
+    attr_reader :dir, :file, :extension, :path
+    attr_accessor :destination_path, :data, :renderers, :compiled, :file_path
+
+    class << self
+      extend T::Sig
+
+      sig { returns(T::Hash[String, Resource]) }
+      def resources
+        @@resources || {}
+      end
+
+      sig do
+        params(
+          file_path: String,
+          destination_path: T.nilable(String),
+          is_page: T::Boolean
+        ).returns(Resource)
+      end
+      def from_path(file_path, destination_path = nil, is_page = true)
+        destination_path ||= file_path
+        file_path = file_path.gsub(%r{^/}, '')
+        destination_path = destination_path.gsub(%r{^/}, '')
+                                           .gsub(%r{/[0-9]+?-}, '/')
+                                           .sub(%r{^source/}, '')
+
+        # We cache the newly created resource so we avoid loosing the cache
+        # if from_path is called again with the same file
+        # This is especially important for perf in case of layouts and templates
+        @@resources ||= {}
+        @@resources[destination_path] ||= new(
+          file_path, destination_path, is_page
+        )
+      end
+    end
+
+    sig { params(path: String).returns(Array) }
+    def strip_extensions(path)
+      split = path.split('/')
+      without_extension = T.must(split.last).split('.')[0]
+      path_without_extensions = split.first(split.length - 1)
+                                     .push(T.must(without_extension))
+                                     .join('/')
+      extensions = T.must(split.last).split('.')[1..-1]
+      [path_without_extensions, extensions]
+    end
+
+    sig { void }
+    def setup_destination
+      destination_without_extension, dest_file_extensions = strip_extensions(
+        @destination_path
+      )
+
+      if destination_without_extension == 'index'
+        destination_without_extension = ''
+      end
+
+      is_index_page = destination_without_extension.end_with?('/index')
+      @extension = dest_file_extensions.first
+
+      if (@extension == 'html' || extension.nil?) && !is_index_page
+        @destination_path = destination_without_extension + '/index.html'
+      else
+        @destination_path = destination_without_extension + '.' + @extension
+      end
+      @path = "/#{@destination_path.chomp('index.html')}"
+              .gsub('//', '/')
+    end
+
+    sig { void }
+    def parse_data_file
+      data_file = @file_path_without_extension + '.yml'
+      return unless File.exist?(data_file)
+
+      begin
+        data = YAML.safe_load(File.read(data_file)).to_ostruct
+      rescue Psych::SyntaxError => e
+        raise("#{e} - #{data_file}")
+      end
+      @data[:yml] = data
+    end
+
+    sig do
+      params(
+        parse_parent: T::Boolean,
+        data: T.any(NilClass, Hash, CustomStruct, OpenStruct)
+      ).void
+    end
+    def parse_resource(parse_parent = false, data = nil)
+      @rendered_content = nil
+
+      @content = File.read(@file_path)
+      @data = {}.to_ostruct
+
+      if %w[erb html haml md txt].include?(@extension)
+        @data, @content = YAML::FrontMatter.extract(@content).to_ostruct
+      end
+
+      @data = @data.to_h.merge(data.to_h).to_ostruct unless data.nil?
+
+      @compiled = nil
+
+      # If there is only one renderer we can precompile the file because there
+      # is no dependency. This is critical to get good performances, especially
+      # for templates and layouts that we also considered as Resources
+      if @renderers.size == 1
+        @renderer = @renderers[0]
+        @compiled = @renderer.compile(@content)
+      end
+
+      if parse_parent
+        proxy_files = Frontman::SitemapTree.proxy_resources_from_template(
+          @file_path
+        )
+
+        if proxy_files.length
+          proxy_files.each do |r|
+            r.parse_resource(false, r.data) unless r == self
+          end
+        end
+      end
+
+      # We need to do that after parsing the resource so @data exists
+      parse_data_file if @is_page
+    end
+
+    sig do
+      params(
+        content_for_layout: T.nilable(String),
+        extra_data: T.any(Hash, CustomStruct)
+      ).returns(String)
+    end
+    def render(content_for_layout = nil, extra_data = {})
+      view_data = data.to_h.merge(extra_data).to_ostruct
+      layout_path = layout
+      layout_from_extra_data = false
+
+      layout_from_extra_data = extra_data[:layout] if extra_data.key?(:layout)
+      if view_data.layout
+        layout_path = File.join(
+          Frontman::Config.get(:layout_dir, fallback: 'views/layouts'),
+          view_data.layout
+        )
+      end
+
+      if @is_page && !view_data[:ignore_page]
+        # We store that in App so it can be accessed from any view
+        Frontman::App.instance.current_page = self
+        Frontman::App.instance.reset_ids_generation
+
+        sitemap_tree = Frontman::App.instance.sitemap_tree.from_resource(self)
+        Frontman::App.instance.current_tree = sitemap_tree
+      end
+
+      # If we have no layout to render and already cache the rendered content
+      # we can return it directly
+      if layout_from_extra_data.nil? && !@rendered_content.nil?
+        return @rendered_content
+      end
+
+      content = @content
+
+      # We create a new context for each file getting rendered
+      context = Frontman::Context.new
+
+      if @compiled
+        # If we manage to compile the template (only 1 renderer)
+        # we render from the compiled template
+        content = @renderer.render(
+          @compiled, content_for_layout, context, view_data
+        )
+      else
+        # We loop over each renderer (infered from extensions of the file)
+        # and render. The result of the 1st rendered is passed as a argument of
+        # the second renderer and so on until we have the final content
+        @renderers.each do |renderer|
+          compiled = renderer.compile(content)
+          content = renderer.render(
+            compiled, content_for_layout, context, view_data
+          )
+        end
+      end
+
+      # Cache the rendered content to avoid non necessary processing
+      # We do this before rendering the layout because it's usually
+      # what's common to every rendering
+      @rendered_content = content
+
+      # If a layout is specified we take the rendered content a inject it
+      # inside the layout.
+      # If layout:nil was specified when triggering the render we don't
+      # render the layout and override the layout that can be set in
+      # frontmatter or config.rb
+      if layout_path && !layout_from_extra_data.nil?
+        content = Resource.from_path(layout_path, nil, false).render(content)
+      end
+
+      content
+    end
+
+    sig { returns(T.nilable(String)) }
+    def layout
+      return nil unless @is_page
+
+      Frontman::App.instance.layouts.each do |(glob, layout)|
+        return layout if File.fnmatch(glob, @destination_path)
+      end
+
+      nil
+    end
+
+    sig { returns(Hash) }
+    def content_blocks
+      @content_blocks ||= {}
+    end
+
+    sig { returns(Time) }
+    def mtime
+      @mtime ||= File.mtime(@file_path)
+    end
+
+    sig { returns(String) }
+    def inspect
+      "Resource: #{@file_path}"
+    end
+
+    sig { returns(T::Boolean) }
+    def indexable?
+      data.key?(:indexable) ? data[:indexable] : true
+    end
+
+    private
+
+    sig do
+      params(
+        file_path: String,
+        destination_path: String,
+        is_page: T::Boolean
+      ).void
+    end
+    def initialize(file_path, destination_path, is_page)
+      raise "File does not exists: #{file_path}" unless File.exist?(file_path)
+
+      @file_path = file_path
+      @destination_path = destination_path
+      @is_page = is_page
+
+      setup_extension_renderers
+      setup_destination
+
+      parse_resource
+    end
+
+    sig { void }
+    def setup_extension_renderers
+      @file_path_without_extension, rendering_extensions = strip_extensions(
+        @file_path
+      )
+      rendering_extensions.reverse!
+      @renderers = rendering_extensions.map do |ext|
+        Frontman::RendererResolver.instance.get_renderer(ext)
+      end.compact
+    end
+  end
+end