perron 0.0.1 → 0.5.0

data/lib/generators/perron/templates/initializer.rb.tt

@@ -0,0 +1,22 @@
+Perron.configure do |config|
+  # config.output = "output"
+
+  # config.site_name = "AppRefresher"
+
+  # The build mode for Perron. Can be :standalone or :integrated.
+  # config.mode = :standalone
+
+  # In `integrated` mode, the root is skipped by default. Set to `true` to enable.
+  # config.include_root = false
+
+  # config.default_url_options = {host: "apprefresher.com", protocol: "https", trailing_slash: true}
+
+  # Override the defaults (meta) title suffix
+  # Default: `— Perron.configuration.site_name`
+  # config.title_suffix = nil
+
+  # Set default meta values
+  # Examples:
+  # - `config.metadata.description = "AI-powered tool to keep your knowledge base articles images/screenshots and content up-to-date"`
+  # - `config.metadata.author = "Rails Designer"`
+end

data/lib/perron/configuration.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Perron
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+  def self.reset_configuration!
+    @configuration = Configuration.new
+  end
+
+  class Configuration
+    def initialize
+      @config = ActiveSupport::OrderedOptions.new
+
+      @config.output = "output"
+
+      @config.mode = :standalone
+      @config.include_root = false
+
+      @config.site_name = nil
+      @config.title_suffix = nil
+
+      @config.allowed_extensions = [".erb", ".md"]
+      @config.exclude_from_public = %w[assets storage]
+      @config.excluded_assets = %w[action_cable actioncable actiontext activestorage rails-ujs trix turbo]
+
+      @config.default_url_options = {
+        host: ENV.fetch("PERRON_HOST", "localhost:3000"),
+        protocol: ENV.fetch("PERRON_PROTOCOL", "http"),
+        trailing_slash: ENV.fetch("PERRON_TRAILING_SLASH", "true") == "true"
+      }
+
+      @config.metadata = ActiveSupport::OrderedOptions.new
+    end
+
+    def input = "app/content"
+
+    def output
+      mode.integrated? ? "public" : @config.output
+    end
+
+    def mode = @config.mode.to_s.inquiry
+
+    def exclude_root? = !@config.include_root
+
+    def method_missing(method_name, ...)
+      if @config.respond_to?(method_name)
+        @config.send(method_name, ...)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name)
+      @config.respond_to?(method_name) || super
+    end
+  end
+end

data/lib/perron/engine.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Perron
+  class Engine < Rails::Engine
+    initializer "perron.default_url_options" do |app|
+      app.config.action_controller.default_url_options = Perron.configuration.default_url_options
+    end
+
+    rake_tasks do
+      load File.expand_path("../tasks/perron.rake", __FILE__)
+    end
+  end
+end

data/lib/perron/errors.rb

@@ -0,0 +1,9 @@
+module Perron
+  module Errors
+    class CollectionNotFoundError < StandardError; end
+
+    class FileNotFoundError < StandardError; end
+
+    class ResourceNotFoundError < StandardError; end
+  end
+end

data/lib/perron/html_processor/target_blank.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Perron
+  class HtmlProcessor
+    class TargetBlank
+      def initialize(html)
+        @html = html
+      end
+
+      def process
+        @html.css("a").each do |link|
+          href = link["href"]
+
+          next unless href
+          next if href.start_with?("/", "#", "mailto:")
+
+          link["target"] = "_blank"
+          link["rel"] = "noopener"
+        end
+      end
+    end
+  end
+end

data/lib/perron/html_processor.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "perron/html_processor/target_blank"
+
+module Perron
+  class HtmlProcessor
+    def initialize(html)
+      @html = html
+    end
+
+    def process
+      document = Nokogiri::HTML::DocumentFragment.parse(@html)
+
+      PROCESSORS.each do |processor|
+        processor.new(document).process
+      end
+
+      document.to_html
+    end
+
+    private
+
+    # TODO: should be a configuration option
+    PROCESSORS = [
+      Perron::HtmlProcessor::TargetBlank
+    ]
+  end
+end

data/lib/perron/markdown.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "perron/html_processor"
+
+module Perron
+  class Markdown
+    class << self
+      def render(text)
+        parser.parse(text)
+          .then { Perron::HtmlProcessor.new(it).process }
+          .html_safe
+      end
+
+      private
+
+      def parser
+        @parser ||= markdown_parser
+      end
+
+      def markdown_parser
+        if defined?(::CommonMarker)
+          CommonMarkerParser.new
+        elsif defined?(::Kramdown)
+          KramdownParser.new
+        elsif defined?(::Redcarpet)
+          RedcarpetParser.new
+        else
+          PlainTextParser.new
+        end
+      end
+    end
+
+    class CommonMarkerParser
+      def parse(text) = CommonMarker.render_html(text, :DEFAULT)
+    end
+
+    class KramdownParser
+      def parse(text) = Kramdown::Document.new(text).to_html
+    end
+
+    class RedcarpetParser
+      def parse(text)
+        renderer = Redcarpet::Render::HTML.new(filter_html: true)
+        markdown = Redcarpet::Markdown.new(renderer, autolink: true, tables: true)
+
+        markdown.render(text)
+      end
+    end
+
+    class PlainTextParser
+      def parse(text) = text.to_s
+    end
+  end
+end

data/lib/perron/metatags.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Perron
+  class Metatags
+    include ActionView::Helpers::TagHelper
+
+    def initialize(resource)
+      @resource = resource
+      @config = Perron.configuration
+    end
+
+    def render(options = {})
+      keys = tags.keys
+        .then { options[:only] ? it & options[:only].map(&:to_sym) : it }
+        .then { options[:except] ? it - options[:except].map(&:to_sym) : it }
+
+      safe_join(keys.filter_map { tags[it].presence }, "\n")
+    end
+
+    private
+
+    FRONTMATTER_KEY_MAP = {
+      "image" => %w[og:image twitter:image],
+      "author" => %w[og:author]
+    }.freeze
+
+    def tags
+      @tags ||= begin
+        frontmatter = @resource&.metadata&.stringify_keys || {}
+        defaults = @config.metadata
+
+        title = frontmatter["title"] || defaults["title"] || @config.site_name
+        description = frontmatter["description"] || defaults["description"]
+        author = frontmatter["author"] || defaults["author"]
+        image = frontmatter["image"] || defaults["image"]
+        og_image = frontmatter["og:image"] || image
+        twitter_image = frontmatter["twitter:image"] || og_image
+
+        {
+          title: title_tag(title),
+          description: meta_tag(name: "description", content: description),
+
+          og_type: meta_tag(property: "og:type", content: frontmatter["og:type"] || "article"),
+          og_title: meta_tag(property: "og:title", content: frontmatter["og:title"] || title),
+          og_description: meta_tag(property: "og:description", content: frontmatter["og:description"] || description),
+          og_site_name: meta_tag(property: "og:site_name", content: @config.site_name),
+          og_image: meta_tag(property: "og:image", content: og_image),
+          og_author: meta_tag(property: "og:author", content: frontmatter["og:author"] || author),
+
+          twitter_card: meta_tag(name: "twitter:card", content: frontmatter["twitter:card"] || "summary_large_image"),
+          twitter_title: meta_tag(name: "twitter:title", content: frontmatter["twitter:title"] || title),
+          twitter_description: meta_tag(name: "twitter:description", content: frontmatter["twitter:description"] || description),
+          twitter_image: meta_tag(name: "twitter:image", content: twitter_image),
+          article_published: meta_tag(property: "article:published_time", content: @resource&.published_at),
+
+          og_url: meta_tag(property: "og:url", content: canonical_url)
+        }
+      end
+    end
+
+    def title_tag(content)
+      tag.title(
+        content.then { (it == @config.site_name) ? it : "#{it} #{@config.title_suffix || "— #{@config.site_name}"}" }
+      )
+    end
+
+    def meta_tag(attributes)
+      return if attributes[:content].blank?
+
+      tag.meta(**attributes)
+    end
+
+    def canonical_url
+      url_options = @config.default_url_options
+      base_url = "#{url_options[:protocol]}://#{url_options[:host]}"
+      url = URI.join(base_url, @resource&.path).to_s
+      has_extension = URI(url).path.split("/").last&.include?(".")
+
+      url.then { (url_options[:trailing_slash] && !it.end_with?("/") && !has_extension) ? "#{it}/" : it }
+    end
+  end
+end

data/lib/perron/refinements/delete_suffixes.rb

@@ -0,0 +1,12 @@
+module Perron
+  module SuffixStripping
+    refine String do
+      def delete_suffixes(suffixes)
+        suffixes
+          .sort_by(&:length)
+          .reverse_each
+          .reduce(self, :delete_suffix)
+      end
+    end
+  end
+end

data/lib/perron/root.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Perron
+  module Root
+    include ActiveSupport::Concern
+
+    def root
+      @resource = Content::Page.find("/")
+
+      render :show
+    end
+  end
+end

data/lib/perron/site/builder/assets.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Perron
+  module Site
+    class Builder
+      class Assets
+        def initialize
+          @output_path = Rails.root.join(Perron.configuration.output)
+        end
+
+        def prepare
+          puts "📦 Precompiling and copying assets…"
+
+          success = system("bundle exec rails assets:precompile", out: File::NULL, err: File::NULL)
+
+          unless success
+            puts "❌ ERROR: Asset precompilation failed"
+
+            exit(1)
+          end
+
+          source = Rails.root.join("public", "assets")
+          destination = @output_path.join("assets")
+
+          unless Dir.exist?(source)
+            puts "⚠️ WARNING: No assets found in `#{source}` to copy"
+
+            return
+          end
+
+          FileUtils.mkdir_p(destination)
+          FileUtils.cp_r(Dir.glob("#{source}/*"), destination)
+
+          puts "   ✅ Copied assets to `#{destination.relative_path_from(Rails.root)}`"
+
+          prune_excluded_assets from: destination
+        end
+
+        private
+
+        def prune_excluded_assets(from:)
+          return if exclusions.empty?
+
+          puts "Pruning excluded assets…"
+
+          pattern = /^(#{exclusions.join("|")})(\.esm|\.min)?-[a-f0-9]{8,}/
+
+          Dir.glob("#{from}/**/*").each do |path|
+            next if File.directory?(path)
+
+            filename = File.basename(path)
+
+            if filename.match?(pattern)
+              FileUtils.rm(path)
+
+              map_file = "#{path}.map"
+
+              FileUtils.rm(map_file) if File.exist?(map_file)
+            end
+          end
+        end
+
+        def exclusions = Perron.configuration.excluded_assets
+      end
+    end
+  end
+end

data/lib/perron/site/builder/page.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "rack/mock"
+
+module Perron
+  module Site
+    class Builder
+      class Page
+        def initialize(path)
+          @output_path, @path = Rails.root.join(Perron.configuration.output), path
+        end
+
+        def render
+          action = route_info[:action]
+          request = ActionDispatch::Request.new(env)
+          response = ActionDispatch::Response.new
+
+          request.path_parameters = route_info
+
+          controller.dispatch(action, request, response)
+
+          return puts "  ❌ ERROR: Request failed for '#{@path}' (Status: #{response.status})" unless response.successful?
+
+          save_html(response.body)
+        rescue => error
+          puts "  ❌ ERROR: Failed to generate page for '#{@path}'. Details: #{error.class} - #{error.message}\n#{error.backtrace.first(3).join("\n")}"
+        end
+
+        private
+
+        def save_html(html)
+          directory_path = @output_path.join(@path.delete_prefix("/"))
+          file_path = directory_path.join("index.html")
+
+          FileUtils.mkdir_p(directory_path)
+          File.write(file_path, html)
+
+          puts "✅ Generated: #{@path} -> #{file_path.relative_path_from(@output_path)}"
+        end
+
+        def route_info
+          @route_info ||= Rails.application.routes.recognize_path(@path)
+        end
+
+        def env = Rack::MockRequest.env_for(@path, "HTTP_HOST" => Perron.configuration.default_url_options[:host])
+
+        def controller = "#{route_info[:controller]}_controller".classify.constantize.new
+      end
+    end
+  end
+end

data/lib/perron/site/builder/paths.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Perron
+  module Site
+    class Builder
+      class Paths
+        def initialize(collection, paths)
+          @collection, @paths = collection, paths
+        end
+
+        def get
+          @paths << routes.public_send(index_path) if routes.respond_to?(index_path)
+
+          if routes.respond_to?(show_path)
+            @collection.all.each do |resource|
+              root = resource.slug == "/"
+
+              next if skip? root
+
+              @paths << (root ? routes.root_path : routes.public_send(show_path, resource))
+            end
+          end
+        end
+
+        private
+
+        def skip?(root)
+          root &&
+            Perron.configuration.mode.integrated? && Perron.configuration.exclude_root?
+        end
+
+        def routes = Rails.application.routes.url_helpers
+
+        def index_path = "#{@collection.name}_path"
+
+        def show_path = "#{@collection.name.singularize}_path"
+      end
+    end
+  end
+end

data/lib/perron/site/builder/public_files.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Perron
+  module Site
+    class Builder
+      class PublicFiles
+        def initialize
+          @output_path = Rails.root.join(Perron.configuration.output)
+          @public_dir = Rails.root.join("public")
+        end
+
+        def copy
+          puts "📂 Copying public files…"
+
+          return unless Dir.exist?(@public_dir)
+
+          if paths.empty?
+            puts "  - No public files to copy"
+
+            return
+          end
+
+          paths.each do |path|
+            FileUtils.cp_r(path, @output_path)
+
+            puts "   ✅ Copied: #{File.basename(path)}"
+          end
+        end
+
+        private
+
+        def paths
+          @paths ||= Dir.glob("#{@public_dir}/*", File::FNM_DOTMATCH).reject do |path|
+            Set.new(Perron.configuration.exclude_from_public + %w[. ..]).include?(File.basename(path))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/perron/site/builder.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "perron/site/builder/assets"
+require "perron/site/builder/public_files"
+require "perron/site/builder/paths"
+require "perron/site/builder/page"
+
+module Perron
+  module Site
+    class Builder
+      def initialize
+        @output_path = Rails.root.join(Perron.configuration.output)
+      end
+
+      def build
+        if Perron.configuration.mode.standalone?
+          puts "🧹 Cleaning previous build…"
+          FileUtils.rm_rf(Dir.glob("#{@output_path}/*"))
+
+          Perron::Site::Builder::Assets.new.prepare
+          Perron::Site::Builder::PublicFiles.new.copy
+        end
+
+        puts "🚀 Starting site build…"
+        puts "-" * 15
+
+        paths.each { render_page(it) }
+
+        puts "-" * 15
+        puts "✅ Build complete"
+      end
+
+      private
+
+      def paths
+        Set.new.tap do |paths|
+          Perron::Site.collections.each { Perron::Site::Builder::Paths.new(it, paths).get }
+        end.to_a
+      end
+
+      def render_page(path) = Perron::Site::Builder::Page.new(path).render
+    end
+  end
+end

data/lib/perron/site/collection.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Perron
+  class Collection
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+      @collection_path = File.join(Rails.root, Perron.configuration.input, name)
+
+      raise Errors::CollectionNotFoundError, "No such collection: #{name}" unless File.exist?(@collection_path) && File.directory?(@collection_path)
+    end
+
+    def all(resource_class = "Content::#{name.classify}".safe_constantize)
+      @all ||= Dir.glob("#{@collection_path}/**/*.*").map do |file_path|
+        resource_class.new(file_path)
+      end.select(&:published?)
+    end
+
+    def find(slug, resource_class = Resource)
+      resource = all(resource_class).find { it.slug == slug }
+
+      return resource if resource
+
+      raise Errors::ResourceNotFoundError, "Resource not found with slug: #{slug}"
+    end
+  end
+end

data/lib/perron/site/resource/class_methods.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Perron
+  class Resource
+    module ClassMethods
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def find(slug) = collection.find(slug, name.constantize)
+
+        def all = collection.all(self)
+
+        def count = all.size
+
+        def first = all[0]
+
+        def second = all[1]
+
+        def third = all[2]
+
+        def fourth = all[3]
+
+        def fifth = all[4]
+
+        def forty_two = all[41]
+
+        def last = all.last
+
+        def take(n) = all.first(n)
+
+        def collection = Collection.new(collection_name)
+
+        def model_name
+          @model_name ||= ActiveModel::Name.new(self, nil, name.demodulize.to_s)
+        end
+
+        private
+
+        def collection_name = name.demodulize.underscore.pluralize
+      end
+    end
+  end
+end

data/lib/perron/site/resource/context.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Perron
+  class Resource
+    class Context
+      def initialize(resource)
+        @resource = resource
+      end
+
+      def binding = super
+    end
+  end
+end

data/lib/perron/site/resource/core.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Perron
+  class Resource
+    module Core
+      extend ActiveSupport::Concern
+
+      def persisted? = true
+
+      def to_model = self
+
+      def model_name = self.class.model_name
+    end
+  end
+end