frontman-ssg 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d98534ae36366f01f9b304aa66cf452d69688a68e37f33e53a3b0afab9ce328a
-  data.tar.gz: aa330a04fd43740fff7dfc1ef6d3e46b640a0a428070456933e24141e58d3b86
+  metadata.gz: d044410bb8578a36c2876cf887a9e807053864fd28045c1bc92e4ecce769f49b
+  data.tar.gz: 0e9400d87ef35ab925d80cc05b4ba9b122ab52d5c280ddb6a39ffb9b9c76c48e
 SHA512:
-  metadata.gz: 6e23982fea37d56e567c96d9344efb5f98c02fead828861410ead02486fe7d6520eb47d0d509bfd46f57e20e4e0476c1ee69820779074afa51fb1527f985e71e
-  data.tar.gz: b1eab4c96e41d2a38951f8893ef29786b20ed2b31689b6c94bfd22a8263f545f9fdd250d3ce8d097fbd694558744c605e92a1d586485376929d2c295520fe335
+  metadata.gz: c54550757e0312a3f7e9051a37bb173f98c120f76b75b99b7634383ba687e5977dfd0bf8c82ecacfecf28e998742aa9c3459172086c734fba3287b1868176d4e
+  data.tar.gz: b89cf82a4807cd97ce05e2a569afe1b6a92266d2aca5c942c68ba5360ac8ecf1419400526fd3955e9575670f48d3b5b57dd177117daf5fe1da8703faf36cb1ee

data/.rubocop.yml

@@ -32,6 +32,7 @@ Metrics/MethodLength:
 
 Metrics/AbcSize:
   Exclude:
+    - 'lib/frontman/context.rb'
     - 'lib/frontman/sitemap_tree.rb'
     - 'lib/frontman/data_store.rb'
     - 'lib/frontman/builder/statistics_collector.rb'
@@ -73,9 +74,11 @@ Metrics/BlockLength:
     - '*.gemspec'
 
 Metrics/LineLength:
+  Max: 100
   Exclude:
     - 'frontman-ssg.gemspec'
     - 'spec/**/*'
+    - 'lib/frontman/context.rb'
 
 Naming/FileName:
   Exclude:

data/CHANGELOG.md

@@ -5,9 +5,20 @@ We document all notable changes to the project in the file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/) and this project adheres to [semantic versioning](http://semver.org/).
 
 # Release Notes
-## [Unreleased](https://github.com/algolia/frontman/compare/0.0.4...master)
+## [Unreleased](https://github.com/algolia/frontman/compare/0.1.0...master)
 
-## [0.0.4](https://github.com/algolia/frontman/tree/0.0.3) - 2020-08-28
+## [0.1.0](https://github.com/algolia/frontman/tree/0.1.0) - 2021-01-05
+
+### Added
+* Support for Slim templates ([`#41`](https://github.com/algolia/frontman/pull/41)) by [@westonganger](https://github.com/westonganger)
+* `append_content` method to push content to a block ([`#25`](https://github.com/algolia/frontman/pull/25)) by [@westonganger](https://github.com/westonganger)
+* Setting to change the local server host ([`#36`](https://github.com/algolia/frontman/pull/36)) by [@westonganger](https://github.com/westonganger)
+* Execute Rubocop in the default Rake task ([`#37`](https://github.com/algolia/frontman/pull/37)) by [@westonganger](https://github.com/westonganger)
+
+### Fixed
+* Issue with setting for local server ports ([`#42`](https://github.com/algolia/frontman/pull/42)) by [@westonganger](https://github.com/westonganger)
+
+## [0.0.4](https://github.com/algolia/frontman/tree/0.0.4) - 2020-08-28
 
 ### Added
 * Retry strategy to allow for multiple running Frontman processes ([`#24`](https://github.com/algolia/frontman/pull/24)) by [@westonganger](https://github.com/westonganger)

data/Rakefile

@@ -4,6 +4,7 @@ require 'bundler/gem_tasks'
 require 'frontman/version'
 require 'rake'
 require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
 
 begin
   Bundler.setup(:default, :development)
@@ -15,7 +16,9 @@ end
 
 RSpec::Core::RakeTask.new(:spec)
 
-task default: :spec
+RuboCop::RakeTask.new(:rubocop)
+
+task default: [:spec, :rubocop]
 
 namespace :frontman do
   GEM_VERSION_FILE = File.join(Dir.pwd, 'lib/frontman/version.rb')
@@ -91,4 +94,4 @@ module Bundler
       version.to_s
     end
   end
-end
+end

data/frontman-ssg.gemspec

@@ -42,6 +42,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'parallel', '~> 1.17'
   s.add_runtime_dependency 'rouge', '~> 3.16'
   s.add_runtime_dependency 'sinatra', '~> 2.0'
+  s.add_runtime_dependency 'slim', '~> 4.1'
   s.add_runtime_dependency 'sorbet-runtime', '~> 0.5'
   s.add_runtime_dependency 'thor', '~> 0.20'
   s.add_runtime_dependency 'yaml-front-matter', '0.0.1'

data/lib/frontman.rb

@@ -10,8 +10,3 @@ require 'frontman/data_store_file'
 require 'frontman/errors'
 require 'frontman/sitemap_tree'
 require 'frontman/resource'
-
-require 'frontman/renderers/renderer'
-require 'frontman/renderers/erb_renderer'
-require 'frontman/renderers/haml_renderer'
-require 'frontman/renderers/markdown_renderer'

data/lib/frontman/app.rb

@@ -97,9 +97,7 @@ module Frontman
 
     sig { params(dirs: T.any(Array, Hash)).void }
     def register_data_dirs(dirs)
-      if dirs.is_a?(Array)
-        dirs = dirs.map { |dir| [dir.split('/').last, dir] }.to_h
-      end
+      dirs = dirs.map { |dir| [dir.split('/').last, dir] }.to_h if dirs.is_a?(Array)
 
       dirs.each do |name, dir|
         define_singleton_method name do

data/lib/frontman/builder/file.rb

@@ -12,9 +12,7 @@ module Frontman
 
       sig { params(path: String, status: T.any(String, Symbol)).void }
       def initialize(path, status)
-        unless valid_status?(status)
-          raise "#{status} is not a valid file status!"
-        end
+        raise "#{status} is not a valid file status!" unless valid_status?(status)
 
         @path = path
         @status = status.to_sym

data/lib/frontman/commands/init.rb

@@ -10,9 +10,8 @@ module Frontman
     desc 'init', 'Bootstrap a new Frontman project'
     def init(path)
       template = options[:template] || 'default'
-      unless template_exists?(template)
-        raise "Template #{template} does not exist!"
-      end
+
+      raise "Template #{template} does not exist!" unless template_exists?(template)
 
       target_dir = File.join(Dir.pwd, path == '.' ? '' : path)
 

data/lib/frontman/commands/serve.rb

@@ -75,44 +75,45 @@ module Frontman
       FrontmanServer.set :public_folder, Frontman::Config.get(
         :public_dir, fallback: 'public'
       )
-      FrontmanServer.run! do
-        host = "http://localhost:#{FrontmanServer.settings.port}"
-        print "== View your site at \"#{host}/\"\n"
-        processes += assets_pipeline.run_in_background!(:after)
-        at_exit { processes.each { |pid| Process.kill(0, pid) } }
-      end
-    end
-  end
-end
-
-class FrontmanServer < Sinatra::Base
-  port = Frontman::Config.get(:port, fallback: 4568)
-  num_retries = Frontman::Config.get(:port_retries, fallback: 3)
 
-  retry_strategy = Frontman::Config.get(:port_retry_strategy, fallback: ->(p) {
-    port_in_use = false
+      port = Frontman::Config.get(:port, fallback: 4568)
+      num_retries = Frontman::Config.get(:port_retries, fallback: 3)
 
-    (1 + num_retries).times do
-      begin
-        port_in_use = Socket.tcp('localhost', p, connect_timeout: 3) { true }
-      rescue StandardError
+      port_retry_strategy = Frontman::Config.get(:port_retry_strategy, fallback: ->(p) {
         port_in_use = false
-      end
 
-      break unless port_in_use
+        (1 + num_retries).times do
+          begin
+            port_in_use = Socket.tcp('localhost', p, connect_timeout: 3) { true }
+          rescue StandardError
+            port_in_use = false
+          end
 
-      p += 1
-    end
+          break unless port_in_use
+
+          p += 1
+        end
 
-    raise Frontman::ServerPortError if port_in_use
+        raise Frontman::ServerPortError if port_in_use
 
-    p
-  })
+        p
+      })
 
-  port = retry_strategy.call(port)
+      FrontmanServer.set(:port, port_retry_strategy.call(port))
+      FrontmanServer.set(:bind, Frontman::Config.get(:host, fallback: 'localhost'))
 
-  set :port, port
+      FrontmanServer.run! do
+        hostname = FrontmanServer.settings.bind
+        host = "http://#{hostname}:#{FrontmanServer.settings.port}"
+        print "== View your site at \"#{host}/\"\n"
+        processes += assets_pipeline.run_in_background!(:after)
+        at_exit { processes.each { |pid| Process.kill(0, pid) } }
+      end
+    end
+  end
+end
 
+class FrontmanServer < Sinatra::Base
   set :server_settings,
       # Avoid having webrick displaying logs for every requests to the serve
       AccessLog: [],

data/lib/frontman/concerns/forward_calls_to_app.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: false
 # frozen_string_literal: true
 
 module Frontman

data/lib/frontman/context.rb

@@ -11,55 +11,55 @@ module Frontman
     extend T::Sig
     include Frontman::ForwardCallsToApp
 
-    sig { params(layout: String).returns(String) }
-    def wrap_layout(layout)
+    sig { params(layout: String, block: T.proc.void).returns(String) }
+    def wrap_layout(layout, &block)
       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
+      content = get_content_buffer(nil, &block)
 
       Resource.from_path(layout_path, nil, false).render(content)
     end
 
     sig do
-      params(key: T.any(String, Symbol), content: T.untyped)
-        .returns(T.untyped)
+      params(
+        key: T.any(String, Symbol),
+        content: T.untyped,
+        block: T.nilable(T.proc.void)
+      ).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
+    def content_for(key, content = nil, &block)
+      content = get_content_buffer(content, &(block if block_given?))
 
-        # The buffer now contains the content of the yield
-        content = load_buffer
-      end
+      # 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
 
-      # Restore the buffer so the rendering of the file can continue
-      restore_buffer
+    sig do
+      params(
+        key: T.any(String, Symbol),
+        content: T.untyped,
+        block: T.nilable(T.proc.void)
+      ).returns(T.untyped)
+    end
+    def append_content(key, content = nil, &block)
+      content = get_content_buffer(content, &(block if block_given?))
 
       # 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?
+
+      return if current_page.nil?
+
+      key = key.to_sym
+      current_page.content_blocks[key] ||= ''
+      if current_page.content_blocks[key].frozen?
+        current_page.content_blocks[key] = current_page.content_blocks[key].dup
+      end
+
+      current_page.content_blocks[key].concat(content)
     end
 
     sig { params(key: T.any(String, Symbol)).returns(T::Boolean) }
@@ -83,43 +83,54 @@ module Frontman
 
     private
 
+    def renderers
+      @renderers ||= RendererResolver.instance.all_renderers
+    end
+
     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, '')
+      renderers.each do |_, renderer|
+        renderer.save_buffer(self) if renderer.respond_to?(:save_buffer)
       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)
+      renderers.each do |_, renderer|
+        renderer.restore_buffer(self) if renderer.respond_to?(:restore_buffer)
       end
     end
 
     sig { returns(T.untyped) }
     def load_buffer
-      haml_locals = instance_variable_get(:@_haml_locals)
+      renderers.each do |_, renderer|
+        content = renderer.load_buffer(self) if renderer.respond_to?(:load_buffer)
+        return content if content
+      end
+
+      nil
+    end
 
-      if haml_locals
-        haml_locals[:_hamlout].buffer
-      else
-        instance_variable_get(:@_erbout)
+    sig { params(content: T.untyped).returns(String) }
+    def get_content_buffer(content)
+      # 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
+
+      content ||= ''
+
+      if block_given?
+        # We don't save the content of the yield, it will be saved in the buffer
+        rendered_content = yield
+
+        # The buffer now contains the content of the yield when rendering HAML
+        content = load_buffer || rendered_content
       end
+
+      # Restore the buffer so the rendering of the file can continue
+      restore_buffer
+
+      content
     end
   end
 end

data/lib/frontman/data_store.rb

@@ -60,9 +60,7 @@ module Frontman
       end
 
       # Make sure we forward the access to the data
-      if @cache.respond_to?(method_name)
-        return @cache.public_send(method_name, &block)
-      end
+      return @cache.public_send(method_name, &block) if @cache.respond_to?(method_name)
 
       nil
     end

data/lib/frontman/iterator.rb

@@ -35,9 +35,7 @@ module Frontman
       end
 
       def forward(method, collection, *options, &block)
-        if parallel?
-          return ::Parallel.public_send(method, collection, *options, &block)
-        end
+        return ::Parallel.public_send(method, collection, *options, &block) if parallel?
 
         collection.public_send(method, &block)
       end

data/lib/frontman/renderers/erb_renderer.rb

@@ -1,5 +1,5 @@
 # typed: false
-# frozen_string_literal: true
+# frozen_string_literal: false
 
 require 'erubis'
 require 'frontman/renderers/renderer'
@@ -17,5 +17,23 @@ module Frontman
 
       compiled.result(scope.get_binding { content })
     end
+
+    def save_buffer(context)
+      buffer = context.instance_variable_get(:@_erbout)
+
+      return unless buffer
+
+      @buffer = buffer
+      context.instance_variable_set(:@_erbout, '')
+    end
+
+    def restore_buffer(context)
+      context.instance_variable_set(:@_erbout, @buffer) if @buffer
+      @buffer = nil
+    end
+
+    def load_buffer(context)
+      context.instance_variable_get(:@_erbout)
+    end
   end
 end

data/lib/frontman/renderers/haml_renderer.rb

@@ -1,5 +1,5 @@
 # typed: false
-# frozen_string_literal: true
+# frozen_string_literal: false
 
 require 'haml'
 require 'frontman/renderers/renderer'
@@ -18,5 +18,33 @@ module Frontman
     def render_content(compiled, content, scope, _data)
       compiled.render(scope.get_binding) { content }
     end
+
+    def load_buffer(context)
+      haml_locals = context.instance_variable_get(:@_haml_locals)
+
+      haml_locals[:_hamlout].buffer if haml_locals
+    end
+
+    def save_buffer(context)
+      @buffer = nil
+      haml_locals = context.instance_variable_get(:@_haml_locals)
+
+      return unless haml_locals
+
+      @buffer = haml_locals[:_hamlout].buffer
+      # empty the buffer so we can capture everything from the new render
+      haml_locals[:_hamlout].buffer = ''
+      context.instance_variable_set(:@_haml_locals, haml_locals)
+    end
+
+    def restore_buffer(context)
+      haml_locals = context.instance_variable_get(:@_haml_locals)
+
+      return unless haml_locals
+
+      haml_locals[:_hamlout].buffer = @buffer
+      context.instance_variable_set(:@_haml_locals, haml_locals)
+      @buffer = nil
+    end
   end
 end