frontman-ssg 0.0.2

data/lib/frontman/builder/file.rb

@@ -0,0 +1,55 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module Frontman
+  module Builder
+    class File
+      extend T::Sig
+
+      attr_accessor :path, :status
+
+      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
+
+        @path = path
+        @status = status.to_sym
+      end
+
+      class << self
+        extend T::Sig
+
+        sig { params(path: String).returns(Frontman::Builder::File) }
+        def unchanged(path)
+          new(path, :unchanged)
+        end
+
+        sig { params(path: String).returns(Frontman::Builder::File) }
+        def deleted(path)
+          new(path, :deleted)
+        end
+
+        sig { params(path: String).returns(Frontman::Builder::File) }
+        def created(path)
+          new(path, :created)
+        end
+
+        sig { params(path: String).returns(Frontman::Builder::File) }
+        def updated(path)
+          new(path, :updated)
+        end
+      end
+
+      private
+
+      sig { params(status: T.any(String, Symbol)).returns(T::Boolean) }
+      def valid_status?(status)
+        %i[updated deleted created unchanged].include?(status.to_sym)
+      end
+    end
+  end
+end

data/lib/frontman/builder/mapping.rb

@@ -0,0 +1,54 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'sorbet-runtime'
+
+module Frontman
+  module Builder
+    class Mapping
+      extend T::Sig
+
+      attr_reader :output_path
+
+      sig { params(output_path: String).void }
+      def initialize(output_path)
+        @output_path = output_path
+        @mapping = {
+          updated: [],
+          created: [],
+          unchanged: [],
+          deleted: []
+        }
+      end
+
+      sig { returns(T::Hash[T.any(String, Symbol), T::Array[String]]) }
+      def all
+        @mapping
+      end
+
+      sig { params(build_file: Frontman::Builder::File).void }
+      def add_from_build_file(build_file)
+        add(build_file.status, build_file.path)
+      end
+
+      sig { params(status: T.any(String, Symbol), path: String).void }
+      def add(status, path)
+        @mapping[status.to_sym].push(path)
+      end
+
+      sig { void }
+      def save_file
+        ::File.open(output_path, 'w') do |f|
+          f.write(JSON.pretty_generate(@mapping))
+        end
+      end
+
+      sig { void }
+      def delete_file
+        FileUtils.rm_f(output_path)
+      end
+    end
+  end
+end

data/lib/frontman/builder/statistics_collector.rb

@@ -0,0 +1,37 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'frontman/builder/builder'
+require 'frontman/builder/mapping'
+require 'frontman/toolbox/timer'
+require 'sorbet-runtime'
+
+module Frontman
+  module Builder
+    class StatisticsCollector
+      extend T::Sig
+
+      sig do
+        params(
+          builder: Frontman::Builder::Builder,
+          mapping: Frontman::Builder::Mapping,
+          timer: Frontman::Toolbox::Timer,
+          new_files: T::Array[String]
+        ).void
+      end
+      def self.output(builder, mapping, timer, new_files = [])
+        puts JSON.pretty_generate(mapping.all)
+        puts '================================================================='
+        puts "Previous build size : #{builder.current_build_files.size} files"
+        puts "Current build size  : #{new_files.size} files"
+
+        %i[updated created deleted unchanged].each do |status|
+          puts "#{status}    : #{Array(mapping.all[status]).length} files"
+        end
+
+        timer.stop
+        puts timer.output
+      end
+    end
+  end
+end

data/lib/frontman/cli.rb

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'frontman/commands/serve'
+require 'frontman/commands/build'
+require 'frontman/commands/init'

data/lib/frontman/commands/build.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: false
+
+require 'thor'
+require 'frontman/app'
+require 'frontman/bootstrapper'
+require 'frontman/builder/asset_pipeline'
+require 'frontman/builder/builder'
+require 'frontman/builder/mapping'
+require 'frontman/builder/statistics_collector'
+require 'frontman/config'
+require 'frontman/toolbox/timer'
+require 'frontman/sitemap_tree'
+
+module Frontman
+  class CLI < Thor
+    option :parallel, type: :boolean
+    option :verbose, type: :boolean
+    desc 'build', 'Generate the HTML for your website'
+    def build
+      Frontman::Config.set(:mode, 'build')
+      Frontman::Bootstrapper.bootstrap_app(Frontman::App.instance)
+
+      assets_pipeline = Frontman::Builder::AssetPipeline.new(
+        Frontman::App.instance
+          .asset_pipelines
+          .filter { |p| %i[all build].include?(p[:mode]) }
+      )
+
+      assets_pipeline.run!(:before)
+
+      enable_parallel = options[:parallel]
+
+      Frontman::Config.set(:parallel, enable_parallel)
+
+      timer = Frontman::Toolbox::Timer.start
+
+      current_build_files = Dir.glob(Dir.pwd + '/build/**/*').reject do |f|
+        File.directory? f
+      end
+
+      public_dir = Frontman::Config.get(:public_dir, fallback: 'public/')
+      assets_to_build = Dir.glob(File.join(public_dir, '**/*')).reject do |f|
+        File.directory? f
+      end
+
+      mapping_path = Dir.pwd + '/_build.json'
+      mapping = Frontman::Builder::Mapping.new(mapping_path)
+      mapping.delete_file
+
+      build_directory = Dir.pwd + '/build/'
+      builder = Frontman::Builder::Builder.new
+      builder.build_directory = build_directory
+      builder.current_build_files = current_build_files
+
+      builder.on('created, updated, deleted, unchanged', lambda { |build_file|
+        mapping.add_from_build_file(build_file)
+      })
+
+      assets = builder.build_assets(assets_to_build)
+      redirects = builder.build_redirects
+
+      resources_paths = builder.build_from_resources(
+        Frontman::SitemapTree.resources
+      )
+
+      new_files = assets + redirects + resources_paths
+
+      builder.delete_files(current_build_files - new_files)
+      mapping.save_file
+
+      assets_pipeline.run!(:after)
+
+      Builder::StatisticsCollector.output(builder, mapping, timer, new_files)
+    end
+  end
+end

data/lib/frontman/commands/init.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: false
+
+require 'fileutils'
+require 'thor'
+
+module Frontman
+  class CLI < Thor
+    option :template
+    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
+
+      target_dir = File.join(Dir.pwd, path == '.' ? '' : path)
+
+      unless allowed_to_modify_dir?(target_dir)
+        say 'Not bootstrapping new Frontman project'
+        return
+      end
+
+      copy_template(template, target_dir)
+
+      command = path == '.' ? '' : "cd #{path} && "
+      command += 'bundle exec frontman serve'
+
+      say "Your project is ready. Run `#{command}` and start developing!"
+    end
+
+    private
+
+    def copy_template(template, dest)
+      FileUtils.cp_r(
+        "#{path_to_template(template)}/.",
+        dest
+      )
+    end
+
+    def allowed_to_modify_dir?(dir)
+      return true if !Dir.exist?(dir) || Dir.empty?(dir)
+
+      say 'This folder already contains files. '
+      say 'Initializing a new Frontman project here may override these files.'
+      answer = ask('Are you sure you want to continue? [y/N]')
+
+      answer.to_s.downcase == 'y'
+    end
+
+    def template_exists?(template)
+      Dir.exist?(path_to_template(template))
+    end
+
+    def path_to_template(template)
+      File.join(__dir__, '../../../project-templates', template)
+    end
+  end
+end

data/lib/frontman/commands/serve.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: false
+
+require 'thor'
+require 'sinatra/base'
+require 'better_errors'
+require 'listen'
+require 'frontman/app'
+require 'frontman/bootstrapper'
+require 'frontman/builder/asset_pipeline'
+require 'frontman/config'
+require 'frontman/resource'
+
+module Frontman
+  class CLI < Thor
+    desc 'serve', 'Serve your application'
+    def serve
+      Frontman::Config.set(:mode, 'serve')
+      app = Frontman::App.instance
+      Frontman::Bootstrapper.bootstrap_app(app)
+
+      assets_pipeline = Frontman::Builder::AssetPipeline.new(
+        app
+          .asset_pipelines
+          .filter { |p| %i[all serve].include?(p[:mode]) }
+      )
+      processes = assets_pipeline.run_in_background!(:before)
+
+      helpers_dir = Frontman::Config.get(:helpers_dir, fallback: 'helpers')
+      content_dir = Frontman::Config.get(:content_dir, fallback: 'source/')
+      listen_to_dirs = Frontman::Config.get(:observe_dirs, fallback:
+        [
+          Frontman::Config.get(:layout_dir, fallback: 'views/layouts'),
+          Frontman::Config.get(:partial_dir, fallback: 'views/partials'),
+          content_dir,
+          helpers_dir
+        ]).filter { |dir| Dir.exist?(dir) }
+      app.refresh_data_files = true
+
+      listener = Listen.to(*listen_to_dirs) do |modified, added|
+        (added + modified).each do |m|
+          resource_path = m.sub("#{Dir.pwd}/", '')
+          begin
+            if resource_path.start_with?(helpers_dir)
+              helper_name = File.basename(resource_path).gsub('.rb', '')
+              load("./#{resource_path}")
+              app.register_helpers(
+                [{
+                  path: File.join(Dir.pwd, resource_path),
+                  name: helper_name.split('_').collect(&:capitalize).join
+                }]
+              )
+            elsif resource_path.start_with?(*listen_to_dirs)
+              r = Frontman::Resource.from_path(resource_path)
+
+              if resource_path.start_with?(content_dir)
+                exists = app.sitemap_tree.from_resource(r)
+                app.sitemap_tree.add(r) unless exists
+              end
+
+              r&.parse_resource(true)
+            elsif resource_path.end_with?('.rb')
+              load("./#{resource_path}")
+            end
+          rescue Error
+            # We ignore all errors to prevent the listener from crashing.
+            # Errors will be surfaced by the server instead.
+          end
+        end
+      end
+
+      listener.start
+
+      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
+  set :port, 4568
+  set :server_settings,
+      # Avoid having webrick displaying logs for every requests to the serve
+      AccessLog: [],
+      # Remove logger for WebRick, we have the one of sinatra already
+      Logger: Rack::NullLogger.new(self)
+
+  use BetterErrors::Middleware
+  BetterErrors.application_root = Dir.pwd
+
+  get '*' do |path|
+    app = Frontman::App.instance
+    return redirect to app.get_redirect(path), 302 if app.get_redirect(path)
+
+    tree = app.sitemap_tree.from_url(path)
+    if tree&.resource
+      extension = File.extname(tree.resource.destination_path)
+      headers['Content-Type'] = Rack::Mime.mime_type(extension)
+      tree.resource.render
+    else
+      halt 404
+    end
+  end
+end

data/lib/frontman/concerns/dispatch_events.rb

@@ -0,0 +1,56 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module Frontman
+  module DispatchEvents
+    extend T::Sig
+
+    sig { returns(T::Hash[Symbol, T::Array[T.untyped]]) }
+    def listeners
+      @listeners ||= {}
+    end
+
+    sig do
+      params(events: T.any(Symbol, String), callback: T.untyped)
+        .returns(T.self_type)
+    end
+    def on(events, callback)
+      list(events).each do |event_name|
+        listeners[event_name.to_sym] ||= []
+        T.must(listeners[event_name.to_sym]).push(callback)
+      end
+
+      self
+    end
+
+    # We don't annotate with sig because of bad support for splat arguments
+    def emit(events, *arguments)
+      list(events).each do |event_name|
+        event_listeners = listeners[event_name.to_sym] || []
+        event_listeners.each do |listener|
+          listener.call(*arguments)
+        end
+      end
+
+      self
+    end
+
+    sig { params(events: T.any(Symbol, String)).returns(T.self_type) }
+    def off(events)
+      list(events).each do |event_name|
+        listeners[event_name.to_sym] = []
+      end
+
+      self
+    end
+
+    private
+
+    sig { params(events: T.any(Symbol, String)).returns(T::Array[String]) }
+    def list(events)
+      events.to_s.split(',').map(&:strip)
+    end
+  end
+end