marquery 0.1.0

data/lib/marquery/collection.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "attributable"
+require_relative "renderable"
+
+module Marquery
+  module Collection
+    def self.included(base)
+      base.include(Marquery::Renderable)
+      base.include(Marquery::Attributable)
+    end
+
+    attr_reader :title, :description, :content
+
+    def initialize(attrs = {})
+      attrs = attrs.transform_keys(&:to_sym)
+      assign_standard_attributes(attrs)
+      assign_declared_attributes(attrs)
+    end
+
+    def to_h
+      {title:, description:, content:, assets:}.tap do |base|
+        self.class.attributes.each_key do |name|
+          base[name] = public_send(name)
+        end
+      end
+    end
+
+    private
+
+    def assign_standard_attributes(attrs)
+      @title = attrs.fetch(:title, "")
+      @description = attrs[:description]
+      @content = attrs.fetch(:content, "")
+      @assets = attrs.fetch(:assets, {})
+    end
+  end
+end

data/lib/marquery/entry.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "model"
+
+module Marquery
+  class Entry
+    include Marquery::Model
+  end
+end

data/lib/marquery/error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Marquery
+  class Error < StandardError; end
+
+  class EntryNotFound < Error
+    def initialize(slug)
+      super("Entry not found: #{slug}")
+    end
+  end
+
+  class AssetNotFound < Error
+    def initialize(name)
+      super("Asset not found: #{name}")
+    end
+  end
+
+  class ParseError < Error; end
+end

data/lib/marquery/helpers.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "renderable"
+require_relative "renderer"
+
+module Marquery
+  module Helpers
+    extend self
+
+    def markdown(content, renderer: Marquery::Renderer)
+      case content
+      when nil
+        ""
+      when Marquery::Renderable
+        content.to_html
+      when String
+        renderer.new.markdown_to_html(content)
+      else
+        raise(
+          ArgumentError,
+          "markdown expects a String, nil, or Marquery::Renderable, got #{content.class}"
+        )
+      end
+    end
+  end
+end

data/lib/marquery/index.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "collection"
+
+module Marquery
+  class Index
+    include Marquery::Collection
+  end
+end

data/lib/marquery/markdown_to_html.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Marquery
+  module MarkdownToHtml
+    def markdown_to_html(_content)
+      raise NotImplementedError, "#{self.class} must implement #markdown_to_html"
+    end
+  end
+end

data/lib/marquery/model.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "attributable"
+require_relative "renderable"
+
+module Marquery
+  module Model
+    def self.included(base)
+      base.include(Marquery::Renderable)
+      base.include(Marquery::Attributable)
+    end
+
+    attr_reader :slug, :title, :description, :content, :date, :source
+
+    def initialize(attrs = {})
+      attrs = attrs.transform_keys(&:to_sym)
+      assign_standard_attributes(attrs)
+      assign_declared_attributes(attrs)
+    end
+
+    def active? = @active
+
+    def ==(other)
+      other.is_a?(self.class) && other.slug == slug
+    end
+    alias_method :eql?, :==
+
+    def hash = [self.class, slug].hash
+
+    def to_h
+      {
+        slug:,
+        title:,
+        description:,
+        content:,
+        date:,
+        active: active?,
+        source:,
+        assets:
+      }.tap do |base|
+        self.class.attributes.each_key do |name|
+          base[name] = public_send(name)
+        end
+      end
+    end
+
+    private
+
+    def assign_standard_attributes(attrs)
+      @slug = attrs.fetch(:slug)
+      @title = attrs.fetch(:title)
+      @description = attrs[:description]
+      @content = attrs.fetch(:content, "")
+      @date = attrs[:date]
+      @active = attrs.fetch(:active, true)
+      @source = attrs[:source]
+      @assets = attrs.fetch(:assets, {})
+    end
+  end
+end

data/lib/marquery/order.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Marquery
+  module Order
+    ASC = :asc
+    DESC = :desc
+
+    VALID = [ASC, DESC].freeze
+
+    def self.validate!(value)
+      return value if VALID.include?(value)
+
+      raise ArgumentError, "Invalid order: #{value.inspect} (expected :asc or :desc)"
+    end
+  end
+end

data/lib/marquery/parser.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "date"
+require "pathname"
+require "time"
+require "yaml"
+
+require_relative "error"
+require_relative "order"
+
+module Marquery
+  class Parser
+    DATE_REGEX = /\A(?<date>\d{8})_(?<name>[^.]+)/
+    CONTENT_REGEX = /\A(?:---\n(?<frontmatter>.*?)\n---\n)?(?<body>.*)\z/m
+    ASSET_EXTENSIONS = %w[.avif .gif .jpeg .jpg .mp3 .mp4 .ogg .pdf .png .svg .webm .webp].freeze
+    PERMITTED_YAML_CLASSES = [Date, Time, Symbol].freeze
+
+    Result = Struct.new(:index, :entries, keyword_init: true)
+
+    def initialize(dir:, model:, index:, order_by:, assets_dir: nil)
+      @dir = Pathname.new(dir.to_s)
+      @assets_dir = assets_dir ? Pathname.new(assets_dir.to_s) : nil
+      @model = model
+      @index = index
+      @order_field, @order_direction = order_by
+    end
+
+    def call
+      Result.new(index: load_index, entries: sort(load_entries))
+    end
+
+    private
+
+    def load_index
+      file = @dir.join("_index.md")
+      return @index.new unless file.file?
+
+      match = match_content(file.read)
+      attrs = {
+        content: match[:body].to_s.strip,
+        assets: collect_assets(@dir.join("_index"))
+      }
+      attrs.merge!(parse_frontmatter(match[:frontmatter]))
+      @index.new(**attrs)
+    end
+
+    def load_entries
+      return [] unless @dir.directory?
+
+      Pathname
+        .glob(@dir.join("*.md"))
+        .reject { _1.basename.to_s == "_index.md" }
+        .map { load_entry(_1) }
+    end
+
+    def load_entry(path)
+      basename = path.basename.to_s
+      unless filename_match = basename.match(DATE_REGEX)
+        raise Marquery::ParseError, "Invalid filename: #{path}"
+      end
+
+      name = filename_match[:name]
+      date_str = filename_match[:date]
+      content_match = match_content(path.read)
+
+      attrs = {
+        slug: parameterize(name),
+        title: humanize(name),
+        date: parse_date(date_str),
+        source: path.to_s,
+        content: content_match[:body].to_s.strip,
+        assets: assets_for(path, date_str)
+      }
+      attrs.merge!(parse_frontmatter(content_match[:frontmatter]))
+      @model.new(**attrs)
+    end
+
+    def assets_for(path, date_str)
+      hash = {}
+      if @assets_dir
+        hash.merge!(collect_assets(@assets_dir.join("_shared")))
+        hash.merge!(collect_assets(@assets_dir.join(date_str)))
+      end
+      hash.merge!(collect_assets(Pathname.new(path.to_s.sub(/\.md\z/, ""))))
+      hash
+    end
+
+    def collect_assets(dir)
+      return {} unless dir.directory?
+
+      dir.children.sort.each_with_object({}) do |child, memo|
+        basename = child.basename.to_s
+        next if basename.start_with?(".")
+        next if child.directory?
+        next unless ASSET_EXTENSIONS.include?(child.extname.downcase)
+
+        memo[basename] = child.to_s.delete_prefix("./")
+      end
+    end
+
+    def match_content(text)
+      match = text.match(CONTENT_REGEX)
+      raise Marquery::ParseError, "Unable to parse content" unless match
+
+      {frontmatter: match[:frontmatter], body: match[:body]}
+    end
+
+    def parse_frontmatter(text)
+      return {} if text.nil? || text.strip.empty?
+
+      parsed = YAML.safe_load(text, permitted_classes: PERMITTED_YAML_CLASSES, aliases: false)
+      raise Marquery::ParseError, "Frontmatter must be a YAML mapping" unless parsed.is_a?(Hash)
+
+      parsed.transform_keys(&:to_sym)
+    end
+
+    def parse_date(date_str)
+      Time.strptime(date_str, "%Y%m%d")
+    rescue ArgumentError => exception
+      raise Marquery::ParseError, "Invalid date prefix #{date_str.inspect}: #{exception.message}"
+    end
+
+    def sort(entries)
+      sorted = entries.sort_by { _1.public_send(@order_field) }
+      @order_direction == Marquery::Order::DESC ? sorted.reverse : sorted
+    end
+
+    def parameterize(str)
+      str
+        .tr("_", "-")
+        .downcase
+        .gsub(/[^a-z0-9-]/, "")
+        .squeeze("-")
+        .gsub(/\A-|-\z/, "")
+    end
+
+    def humanize(str)
+      cleaned = str.tr("_", " ").tr("-", " ").gsub(/\s+/, " ").strip
+      return cleaned if cleaned.empty?
+
+      cleaned[0].upcase + cleaned[1..]
+    end
+  end
+end

data/lib/marquery/query.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require_relative "entry"
+require_relative "index"
+require_relative "order"
+require_relative "parser"
+require_relative "registry"
+
+module Marquery
+  module Query
+    extend Forwardable
+    include Enumerable
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.instance_variable_set(:@marquery_model, Marquery::Entry)
+      base.instance_variable_set(:@marquery_index, Marquery::Index)
+      base.instance_variable_set(:@order_field, :date)
+      base.instance_variable_set(:@order_direction, Marquery::Order::DESC)
+      base.instance_variable_set(:@dir, nil)
+      base.instance_variable_set(:@assets_dir, nil)
+      base.instance_variable_set(:@marquery_data, nil)
+      base.instance_variable_set(:@loaded, false)
+      Marquery::Registry.register(base)
+    end
+
+    module ClassMethods
+      def model(klass = nil)
+        @marquery_model = klass if klass
+        @marquery_model
+      end
+
+      def index(klass = nil)
+        @marquery_index = klass if klass
+        @marquery_index
+      end
+
+      def order_by(field = nil, direction = nil)
+        if field
+          @order_field = field.to_sym
+          @order_direction = Marquery::Order.validate!(direction) if direction
+        end
+        [@order_field, @order_direction]
+      end
+
+      def dir(path = nil)
+        @dir = path.to_s if path
+        @dir ||= derive_dir
+      end
+
+      def assets_dir(path = nil)
+        @assets_dir = path.to_s unless path.nil?
+        @assets_dir
+      end
+
+      def data_path
+        File.join(Marquery.config.data_dir, dir)
+      end
+
+      def assets_path
+        return nil unless assets_dir
+
+        File.join(Marquery.config.data_dir, assets_dir)
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def load!
+        @marquery_data = Marquery::Parser.new(
+          dir: data_path,
+          assets_dir: assets_path,
+          model: model,
+          index: index,
+          order_by: order_by
+        ).call
+        @loaded = true
+        self
+      end
+
+      def reload!
+        @loaded = false
+        @marquery_data = nil
+        load!
+      end
+
+      def all_entries
+        load! unless loaded?
+        @marquery_data.entries
+      end
+
+      def index_entry
+        load! unless loaded?
+        @marquery_data.index
+      end
+
+      private
+
+      def derive_dir
+        derived = name
+          .to_s
+          .sub(/Query\z/, "")
+          .gsub("::", "")
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .downcase
+
+        return derived unless derived.empty?
+
+        raise(
+          Marquery::Error,
+          "Cannot derive directory for #{inspect}; call `dir \"...\"` explicitly"
+        )
+      end
+    end
+
+    attr_reader :entries
+
+    def initialize(entries = nil)
+      @entries = (entries || self.class.all_entries).freeze
+    end
+
+    def each(&block)
+      return enum_for(:each) unless block
+
+      entries.each(&block)
+      self
+    end
+
+    def all = entries
+
+    def_delegators :entries, :size, :length, :count, :empty?, :first, :last
+
+    def find(slug)
+      find_by_slug(slug) || raise(Marquery::EntryNotFound.new(slug))
+    end
+
+    def find_by_slug(slug)
+      entries.find { |entry| entry.slug == slug }
+    end
+
+    def filter(&block)
+      return self unless block
+
+      new_query(entries.select(&block))
+    end
+    alias_method :select, :filter
+
+    def reject(&block)
+      return self unless block
+
+      new_query(entries.reject(&block))
+    end
+
+    def sort_by(&block)
+      new_query(entries.sort_by(&block))
+    end
+
+    def reverse
+      new_query(entries.reverse)
+    end
+
+    def shuffle(random: Random.new)
+      new_query(entries.shuffle(random: random))
+    end
+
+    def previous(entry)
+      idx = entries.index(entry)
+      return nil if idx.nil? || idx.zero?
+
+      entries[idx - 1]
+    end
+
+    def next(entry)
+      idx = entries.index(entry)
+      return nil if idx.nil?
+
+      entries[idx + 1]
+    end
+
+    private
+
+    def new_query(new_entries)
+      self.class.new(new_entries)
+    end
+  end
+end

data/lib/marquery/registry.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Marquery
+  module Registry
+    @classes = []
+    @mutex = Mutex.new
+
+    class << self
+      def classes
+        @mutex.synchronize { @classes.dup }
+      end
+
+      def register(klass)
+        @mutex.synchronize do
+          @classes << klass unless @classes.include?(klass)
+        end
+      end
+
+      def reset!
+        @mutex.synchronize { @classes.clear }
+      end
+    end
+  end
+end

data/lib/marquery/renderable.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "renderer"
+
+module Marquery
+  ASSET_URI_REGEX = %r{asset:([^\s)"'<>]+)}
+
+  module Renderable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def renderer(klass = nil)
+        if klass
+          @marquery_renderer = klass
+          return klass
+        end
+
+        return @marquery_renderer if defined?(@marquery_renderer) && @marquery_renderer
+        return superclass.renderer if superclass.respond_to?(:renderer)
+
+        Marquery::Renderer
+      end
+    end
+
+    def assets = @assets ||= {}
+
+    def asset(name)
+      path = assets[name] || raise(Marquery::AssetNotFound.new(name))
+      "/#{path}"
+    end
+
+    def asset?(name)
+      path = assets[name]
+      path && "/#{path}"
+    end
+
+    def rewrite_assets(raw)
+      raw.gsub(Marquery::ASSET_URI_REGEX) { asset(::Regexp.last_match(1)) }
+    end
+
+    def process_content(raw)
+      preprocessor = Marquery.config.preprocessor
+      return preprocessor.call(raw, self) if preprocessor
+
+      rewrite_assets(raw)
+    end
+
+    def to_html
+      self.class.renderer.new.markdown_to_html(process_content(content))
+    end
+  end
+end

data/lib/marquery/renderer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "commonmarker"
+
+require_relative "markdown_to_html"
+
+module Marquery
+  class Renderer
+    include MarkdownToHtml
+
+    DEFAULT_OPTIONS = {
+      parse: {smart: true},
+      render: {unsafe: true, github_pre_lang: true},
+      extension: {
+        strikethrough: true,
+        table: true,
+        autolink: true,
+        tagfilter: true,
+        tasklist: true,
+        footnotes: true
+      }
+    }.freeze
+
+    def markdown_to_html(content)
+      Commonmarker.to_html(content.strip, options: DEFAULT_OPTIONS)
+    end
+  end
+end

data/lib/marquery/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Marquery
+  VERSION = "0.1.0"
+end

data/lib/marquery.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "marquery/version"
+require_relative "marquery/error"
+require_relative "marquery/order"
+require_relative "marquery/markdown_to_html"
+require_relative "marquery/renderer"
+require_relative "marquery/renderable"
+require_relative "marquery/attributable"
+require_relative "marquery/model"
+require_relative "marquery/entry"
+require_relative "marquery/collection"
+require_relative "marquery/index"
+require_relative "marquery/parser"
+require_relative "marquery/registry"
+require_relative "marquery/query"
+require_relative "marquery/helpers"
+
+module Marquery
+  class Configuration
+    attr_accessor :data_dir, :preprocessor
+
+    def initialize
+      @data_dir = "marquery"
+      @preprocessor = nil
+    end
+  end
+
+  class << self
+    def config
+      @config ||= Configuration.new
+    end
+
+    def configure
+      yield config
+      config
+    end
+
+    def reset_config!
+      @config = Configuration.new
+    end
+
+    def eager_load!
+      Marquery::Registry.classes.each(&:load!)
+    end
+  end
+end