frontman-ssg 0.0.2

data/lib/frontman/concerns/forward_calls_to_app.rb

@@ -0,0 +1,28 @@
+# typed: true
+# frozen_string_literal: true
+
+module Frontman
+  module ForwardCallsToApp
+    def self.included(klass)
+      klass.extend Frontman::ForwardCallsToApp::ClassMethods
+    end
+
+    def method_missing(method_id, *arguments, &block)
+      Frontman::App.instance.public_send(method_id, *arguments, &block)
+    end
+
+    def respond_to_missing?(method_name, _ = false)
+      Frontman::App.instance.respond_to?(method_name)
+    end
+
+    module ClassMethods
+      def method_missing(method_id, *arguments, &block)
+        Frontman::App.instance.public_send(method_id, *arguments, &block)
+      end
+
+      def respond_to_missing?(method_name, _ = false)
+        Frontman::App.instance.respond_to?(method_name)
+      end
+    end
+  end
+end

data/lib/frontman/config.rb

@@ -0,0 +1,52 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module Frontman
+  class Config
+    class << self
+      extend T::Sig
+
+      sig do
+        params(
+          key: T.any(String, Symbol), value: T.untyped
+        ).returns(T.self_type)
+      end
+      def set(key, value)
+        @@values ||= {}
+        @@values[key.to_sym] = value
+        self
+      end
+
+      sig do
+        params(
+          key: T.any(String, Symbol), fallback: T.untyped
+        ).returns(T.untyped)
+      end
+      def get(key, fallback: nil)
+        @@values ||= {}
+        @@values.key?(key.to_sym) ? @@values[key.to_sym] : fallback
+      end
+
+      sig { params(key: T.any(String, Symbol)).returns(T.self_type) }
+      def delete(key)
+        @@values ||= {}
+        @@values.delete(key)
+        self
+      end
+
+      sig { params(key: T.any(String, Symbol)).returns(T::Boolean) }
+      def has?(key)
+        @@values ||= {}
+        @@values.key?(key.to_sym)
+      end
+
+      sig { returns(Hash) }
+      def all
+        @@values ||= {}
+        @@values
+      end
+    end
+  end
+end

data/lib/frontman/context.rb

@@ -0,0 +1,125 @@
+# typed: true
+# frozen_string_literal: false
+
+require 'frontman/app'
+require 'frontman/concerns/forward_calls_to_app'
+require 'frontman/config'
+require 'sorbet-runtime'
+
+module Frontman
+  class Context
+    extend T::Sig
+    include Frontman::ForwardCallsToApp
+
+    sig { params(layout: String).returns(String) }
+    def wrap_layout(layout)
+      layout_dir = Frontman::Config.get(:layout_dir, fallback: 'views/layouts')
+      layout_path = File.join(layout_dir, layout)
+
+      # Haml is not designed to do handle wrap_layout properly
+      # so we need to hack the buffer of haml that is set
+      # inside the context by haml
+      save_buffer
+
+      # We don't save the content of the yield, it will be saved in the buffer
+      yield
+
+      # The buffer now contains the content of the yield
+      content = load_buffer
+
+      # Restore the buffer so the rendering of the file can continue
+      restore_buffer
+
+      Resource.from_path(layout_path, nil, false).render(content)
+    end
+
+    sig do
+      params(key: T.any(String, Symbol), content: T.untyped)
+        .returns(T.untyped)
+    end
+    def content_for(key, content = nil)
+      # Haml is not designed to do handle content_for properly
+      # so we need to hack the buffer of haml that is set
+      # inside the context by haml
+      save_buffer
+
+      content ||= ''
+
+      if block_given?
+        # We don't save the content of the yield, it will be saved in the buffer
+        yield
+
+        # The buffer now contains the content of the yield
+        content = load_buffer
+      end
+
+      # Restore the buffer so the rendering of the file can continue
+      restore_buffer
+
+      # We store the the content block inside the current page
+      # because we don't know which renderer/layout/template will need it
+      current_page = Frontman::App.instance.current_page
+      current_page.content_blocks[key.to_sym] = content unless current_page.nil?
+    end
+
+    sig { params(key: T.any(String, Symbol)).returns(T::Boolean) }
+    def content_for?(key)
+      Frontman::App.instance.current_page.content_blocks.key?(key.to_sym)
+    end
+
+    sig do
+      params(key: T.any(String, Symbol), _args: T.untyped).returns(T.untyped)
+    end
+    def yield_content(key, *_args)
+      Frontman::App.instance.current_page.content_blocks[key.to_sym]
+    end
+
+    sig do
+      params(content: T.untyped).returns(T.untyped)
+    end
+    def get_binding(&content)
+      binding { content }
+    end
+
+    private
+
+    sig { void }
+    def save_buffer
+      haml_locals = instance_variable_get(:@_haml_locals)
+
+      if haml_locals
+        # save buffer
+        @buffer = haml_locals[:_hamlout].buffer
+        # empty the buffer so we can capture everything from the new render
+        haml_locals[:_hamlout].buffer = ''
+      else
+        # save buffer
+        @buffer = instance_variable_get(:@_erbout)
+        # empty the buffer so we can capture everything from the new render
+        instance_variable_set(:@_erbout, '')
+      end
+    end
+
+    sig { void }
+    def restore_buffer
+      haml_locals = instance_variable_get(:@_haml_locals)
+
+      if haml_locals
+        haml_locals[:_hamlout].buffer = @buffer
+      else
+        instance_variable_set(:@_erbout, @buffer)
+      end
+    end
+
+    sig { returns(T.untyped) }
+    def load_buffer
+      haml_locals = instance_variable_get(:@_haml_locals)
+
+      if haml_locals
+        haml_locals[:_hamlout].buffer
+      else
+        instance_variable_get(:@_erbout)
+      end
+    end
+  end
+end

data/lib/frontman/custom_struct.rb

@@ -0,0 +1,44 @@
+# typed: false
+# frozen_string_literal: false
+
+require 'ostruct'
+
+class CustomStruct < OpenStruct
+  def respond_to_missing?(method_id, *_arguments)
+    to_h.respond_to?(method_id) || super(method_id)
+  end
+
+  def key?(key)
+    to_h.key?(key)
+  end
+
+  def method_missing(method_id, *arguments, &block)
+    if to_h.respond_to?(method_id)
+      to_h.public_send(method_id, *arguments, &block)
+    else
+      super(method_id, *arguments)
+    end
+  end
+end
+
+class Hash
+  def to_ostruct
+    arr = map do |k, v|
+      if v.is_a? Array
+        [k, v.map { |el| el.respond_to?(:to_ostruct) ? el.to_ostruct : el }]
+      else
+        [k, v.respond_to?(:to_ostruct) ? v.to_ostruct : v]
+      end
+    end
+
+    CustomStruct.new(Hash[arr])
+  end
+end
+
+class Array
+  def to_ostruct
+    map do |item|
+      item.respond_to?(:to_ostruct) ? item.to_ostruct : item
+    end
+  end
+end

data/lib/frontman/data_store.rb

@@ -0,0 +1,106 @@
+# typed: true
+# frozen_string_literal: false
+
+require 'pathname'
+require 'frontman/data_store_file'
+require 'sorbet-runtime'
+
+module Frontman
+  class DataStore
+    extend T::Sig
+
+    attr_reader :base_file_name, :path, :parent
+
+    sig do
+      params(
+        path: String,
+        base_file_name: T.nilable(String),
+        parent: T.nilable(DataStore)
+      ).void
+    end
+    def initialize(path, base_file_name = nil, parent = nil)
+      @path = path
+      @cache = {}
+      @parent = parent
+      @base_file_name = base_file_name
+
+      load_files
+    end
+
+    sig { returns(Array) }
+    def flatten
+      elements = []
+
+      @cache.sort_by { |_k, v| v.path }.each do |_k, v|
+        if v.instance_of?(Frontman::DataStoreFile)
+          v.refresh
+          elements.push(v)
+        else
+          elements.push(*v.flatten)
+        end
+      end
+
+      elements
+    end
+
+    def method_missing(method_id, *arguments, &block)
+      method_name = method_id
+
+      # Make sure we are able to access data files with an array syntax
+      method_name = arguments[0].to_sym if method_id == :[]
+
+      if @cache.key?(method_name.to_s)
+        cached = @cache[method_name.to_s]
+
+        if Frontman::App.instance.refresh_data_files
+          cached.refresh if cached.is_a?(Frontman::DataStoreFile)
+        end
+
+        return cached
+      end
+
+      # Make sure we forward the access to the data
+      if @cache.respond_to?(method_name)
+        return @cache.public_send(method_name, &block)
+      end
+
+      nil
+    end
+
+    def respond_to_missing?(method_name, _)
+      @cache.key?(method_name.to_s) || @cache.respond_to?(method_name)
+    end
+
+    sig { returns(String) }
+    def to_s
+      "<DataStore #{@cache.keys.join(', ')} >"
+    end
+
+    private
+
+    sig { void }
+    def load_files
+      Dir.entries(@path).sort.each do |file|
+        next if (file == '.') || (file == '..')
+
+        file_path = @path + '/' + file
+
+        # remove numbers and first '-' from the filename so we can
+        # - generate nice urls
+        # - omit the number when accessing the object
+        base_file_name = file.gsub(/[0-9]*+-?(.+)/, '\1')
+
+        if File.file?(file_path) && (File.extname(file) == '.yml')
+          method_name = File.basename(base_file_name, File.extname(file))
+          @cache[method_name.to_s] = Frontman::DataStoreFile.new(
+            file_path, file, method_name, self
+          )
+        elsif File.directory?(file_path)
+          @cache[base_file_name] = DataStore.new(
+            file_path, base_file_name, self
+          )
+        end
+      end
+    end
+  end
+end

data/lib/frontman/data_store_file.rb

@@ -0,0 +1,60 @@
+# typed: true
+# frozen_string_literal: false
+
+require 'pathname'
+require 'sorbet-runtime'
+require 'yaml'
+
+module Frontman
+  class DataStoreFile
+    extend T::Sig
+    attr_accessor :path, :file_name, :base_file_name, :parent,
+                  :position, :data
+
+    sig do
+      params(
+        path: String,
+        file_name: String,
+        base_file_name: String,
+        parent: DataStore
+      ).void
+    end
+    def initialize(path, file_name, base_file_name, parent)
+      @path = path
+      @file_name = file_name
+      @base_file_name = base_file_name
+      @parent = parent
+      @data = (YAML.load_file(@path) || {}).to_ostruct
+
+      @@i ||= 0
+      @position = @@i
+      @@i += 1
+    end
+
+    def method_missing(method_id, *arguments, &block)
+      @data.public_send(method_id, *arguments, &block)
+    end
+
+    def respond_to_missing?(method_id, _)
+      @data.respond_to? method_id
+    end
+
+    sig { returns(String) }
+    def current_path
+      @path
+    end
+
+    sig { void }
+    def refresh
+      return unless Frontman::App.instance.refresh_data_files
+
+      data = YAML.load_file(@path) || {}
+      @data = data.to_ostruct
+    end
+
+    sig { returns(String) }
+    def to_s
+      "<DataStoreFile #{@data.keys.join(', ')} >"
+    end
+  end
+end

data/lib/frontman/helpers/app_helper.rb

@@ -0,0 +1,18 @@
+# typed: true
+# frozen_string_literal: false
+
+require 'frontman/config'
+
+module AppHelper
+  extend T::Sig
+
+  sig { returns(T::Boolean) }
+  def build?
+    Frontman::Config.get(:mode) == 'build'
+  end
+
+  sig { returns(T::Boolean) }
+  def serve?
+    !build?
+  end
+end

data/lib/frontman/helpers/link_helper.rb

@@ -0,0 +1,35 @@
+# typed: true
+# frozen_string_literal: false
+
+require 'htmlentities'
+require 'singleton'
+require 'sorbet-runtime'
+
+module LinkHelper
+  extend T::Sig
+
+  sig { params(str: String, salt: String).returns(String) }
+  def generate_id(str, salt = '')
+    id = slugify(str)
+
+    @ids ||= {}
+    @ids[salt.to_s + id] ||= 0
+    @ids[salt.to_s + id] += 1
+    @ids[salt.to_s + id] == 1 ? id : "#{id}-#{@ids[salt.to_s + id]}"
+  end
+
+  sig { void }
+  def reset_ids_generation
+    @ids = {}
+  end
+
+  sig { params(string: String).returns(String) }
+  def slugify(string)
+    HTMLEntities.new
+                .decode(string)
+                .gsub(%r{</?[^>]*>}, '')
+                .gsub(/\s/, '-')
+                .gsub(%r{[\[\]()/",`'&<>\.*]}, '')
+                .downcase
+  end
+end