polites 0.1.0

data/lib/polites/list_indenter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Polites
+  # Modify the AST for a parsed sheet to group list items in a nested structure,
+  # rather than a flat structure using levels.
+  class ListIndenter
+    List = Struct.new(:children)
+
+    # @param [Array<Polites::Node>] items
+    # @return [Array<Polites::Node>]
+    def call(items)
+      items
+        .chunk { |i| i.is_a?(Block::List) }.to_a
+        .inject([]) do |acc, (k, contents)|
+        acc + (k ? [List.new(indent(contents))] : contents)
+      end
+    end
+
+    private
+
+    def indent(items)
+      items
+        .chunk { |item| item.level > items.first.level }
+        .inject([]) do |acc, (indented, subitems)|
+        if indented
+          acc.last.children << List.new(indent(subitems))
+          acc
+        else
+          acc + subitems
+        end
+      end
+    end
+  end
+end

data/lib/polites/markup.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Polites
+  # The markup section defines the markup used in a Polites document, specifying
+  # both its versions and patterns defined in {Tag}s.
+  class Markup
+    # @return [String]
+    attr_reader :version
+
+    # @return [String]
+    attr_reader :identifier
+
+    # @return [String]
+    attr_reader :display_name
+
+    # @return [Array<Tag>]
+    attr_reader :tags
+
+    # @param [String] version
+    # @param [String] identifier
+    # @param [String] display_name
+    # @param [Array<Tag>] tags
+    def initialize(version, identifier, display_name, tags = [])
+      @version = version
+      @identifier = identifier
+      @display_name = display_name
+      @tags = tags
+      freeze
+    end
+  end
+end

data/lib/polites/nanoc.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative './nanoc/data_source'
+require_relative './nanoc/extract_file_filter'
+require_relative './nanoc/embedded_images_filter'
+
+module Polites
+  # The {Polites::Nanoc} module provides integration with the
+  # [Nanoc](https://nanoc.ws) static site generator. It allows you to
+  # configure a Polites external directory as a data source in a Nanoc site,
+  # so you can transform Polites files straight into HTML documents.
+  #
+  # This gem consists of the following parts:
+  #
+  # * {Polites::Nanoc::DataSource} implements the data source that reads .ulyz
+  #   files from disk and creates Nanoc HTML items from them.
+  # * {Polites::Nanoc::EmbeddedImagesFilter} implements a filter you can use to
+  #   transform the image paths in your HTML to the pats generated by your Nanoc
+  #   rules.
+  # * {Polites::Nanoc::ExtractFileFilter} is a filter that will extract embedded
+  #   files from the .ulyz zip file to actual output files on disk in your Nanoc
+  #   site.
+  #
+  # @example Nanoc configuration using Polites data source
+  #    # in nanoc.yaml
+  #    data_sources:
+  #      - type: polites
+  #        items_root: /articles/
+  #        path: path/to/articles
+  # @example Require Ulussyes::Nanoc in your site
+  #   # lib/default.rb
+  #   require 'polites/nanoc'
+  # @example Nanoc rule to compile Ulussyes articles
+  #   compile "/articles/*.ulyz" do
+  #     filter :polites_embedded_images
+  #     layout "/default.*"
+  #     write item.identifier.without_ext + "/index.html"
+  #   end
+  # @example Nanoc rule to extract embedded media
+  #   compile(%r{\A/articles/.+\.ulyz/media/.+\Z}) do
+  #     filter :extract_file
+  #     write item.identifier.to_s.sub(".ulyz", "")
+  #   end
+  module Nanoc
+  end
+end

data/lib/polites/nanoc/data_source.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require_relative '../settings'
+require_relative '../parser'
+require_relative '../file'
+require_relative '../html_formatter'
+
+module Polites
+  module Nanoc
+    # A data source for Nanoc that creates Nanoc content items from Polites files
+    # in a particular directory.
+    class DataSource < ::Nanoc::DataSource
+      identifier :polites
+
+      def up
+        @root = Pathname(@config[:path])
+        @settings = Settings.from_directory(@root)
+        @extension = ".#{@settings['defaultPathExtensions']}"
+        @input_files = @root.glob("*#{@extension}")
+        @parser = Polites::Parser.new
+        @formatter = Polites::HtmlFormatter.new
+      end
+
+      def items
+        @input_files.flat_map do |input_file|
+          File.open(input_file) do |file|
+            sheet = @parser.parse_sheet(file.content)
+
+            inline_file_items = sheet.inline_files.map do |image|
+              build_file_item(file.media(image.image), image.image, input_file, image.filename)
+            end
+
+            file_items = sheet.attached_files.map do |id|
+              build_file_item(file.media(id), id, input_file)
+            end
+
+            [
+              new_item(
+                @formatter.call(sheet),
+                {
+                  keywords: sheet.keywords,
+                  image: sheet.attached_files.first,
+                  image_caption: sheet.notes.any? ? @formatter.call(sheet.notes.first) : nil,
+                  inline_file_items: inline_file_items,
+                  filename: input_file.to_s,
+                  mtime: input_file.mtime
+                },
+                identifier(input_file)
+              ),
+              *inline_file_items,
+              *file_items
+            ]
+          end
+        end
+      end
+
+      private
+
+      def build_file_item(entry, id, input_file, filename = nil)
+        p = filename ? Pathname(filename) : Pathname(entry.name).basename
+        i = "#{identifier(input_file)}/media#{identifier(p, p.extname)}"
+        new_item(
+          input_file.expand_path.to_s,
+          {
+            explicit_filename: filename,
+            id: id,
+            subpath: entry.name,
+            mtime: input_file.mtime
+          },
+          i,
+          binary: true
+        )
+      end
+
+      def identifier(path, extension = @extension)
+        "/#{path
+          .relative_path_from(@root)
+          .basename(extension)
+          .to_s
+          .then { |s| underscore(s) }}#{extension}"
+      end
+
+      def underscore(str)
+        str
+          .gsub(/[^a-zA-Z0-9\-_]/, '-')
+          .squeeze('-')
+          .gsub(/^-*|-*$/, '')
+          .downcase
+      end
+    end
+  end
+end

data/lib/polites/nanoc/embedded_images_filter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Polites
+  module Nanoc
+    # Nanoc filter for replacing the Polites-generated filename to images with
+    # actual output filenames as generated by Nanoc.
+    class EmbeddedImagesFilter < ::Nanoc::Filter
+      identifier :polites_embedded_images
+
+      def run(content, _params = {})
+        return content unless @item[:inline_file_items]&.any?
+
+        @item[:inline_file_items].inject(content) do |acc, inline_file_item|
+          actual_item = @items.find do |item|
+            item.attributes[:id] == inline_file_item.attributes[:id]
+          end
+          acc.gsub(/(?<=src=")(#{actual_item.attributes[:explicit_filename]}|#{actual_item.attributes[:id]})(?=")/, actual_item.path)
+        end
+      end
+    end
+  end
+end

data/lib/polites/nanoc/extract_file_filter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../file'
+
+module Polites
+  module Nanoc
+    # Nanoc binary filter to extract files from a zip file to a given output file.
+    # This allows a single Polites file to be linked to multiple Nanoc items,
+    # which are extracted when needed during the compilation process.
+    class ExtractFileFilter < ::Nanoc::Filter
+      identifier :extract_file
+      type :binary
+
+      def run(filename, _params = {})
+        File.open(filename) do |f|
+          f.extract_to(@item[:subpath], output_filename)
+        end
+      end
+    end
+  end
+end

data/lib/polites/node.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Polites
+  # The Node is the basic building block of the AST we parse Polites document
+  # contents into.
+  class Node
+    # @return [Array<Node>]
+    attr_reader :children
+
+    # @param [Array<Node>] children
+    def initialize(children = [])
+      @children = children
+    end
+
+    # Assemble the text contents of this node and all its children combined.
+    #
+    # @return [String]
+    def text
+      @children.map(&:text).join
+    end
+
+    def eql?(other)
+      other.is_a?(self.class) && children.eql?(other.children)
+    end
+
+    alias == eql?
+  end
+end

data/lib/polites/parser.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require_relative '../polites'
+require_relative './block'
+require_relative './text'
+require_relative './span'
+require_relative './sheet'
+require_relative './markup'
+require_relative './simple_tag'
+require_relative './range_tag'
+
+module Polites
+  # The parser takes XML content from a Polites file and parses it into our own
+  # abstract syntax tree built from {Node} elements. This can then be modified
+  # and formatted into the desired output.
+  class Parser
+    def initialize
+      reset
+    end
+
+    # Parse an entire sheet of content, including all its structural elements.
+    #
+    # @param [String] source
+    # @return [Sheet]
+    def parse_sheet(source)
+      sheet = Nokogiri(source).xpath('/sheet').first
+      Sheet.new(
+        version: sheet[:version],
+        app_version: sheet[:app_version],
+        markup: parse_markup(sheet),
+        content: parse_fragment(sheet),
+        keywords: parse_keywords(sheet),
+        files: parse_files(sheet),
+        notes: parse_notes(sheet)
+      )
+    end
+
+    # Parse just the markup section of a sheet into a {Markup} container.
+    #
+    # @param [Nokogiri::Node] element
+    # @return [Markup]
+    def parse_markup(element)
+      markup = element.xpath('markup').first
+      tags = markup.xpath('tag').map do |e|
+        if e[:pattern]
+          SimpleTag.new(e[:definition], e[:pattern])
+        elsif e[:startPattern] && e[:endPattern]
+          RangeTag.new(e[:definition], e[:startPattern], e[:endPattern])
+        end
+      end
+      Markup.new(markup[:version], markup[:identifier], markup[:displayName], tags)
+    end
+
+    # Parse a content fragment, which consists of multiple source elements but
+    # not necessarily an entire sheet.
+    #
+    # @param [String] source
+    # @return [Array<Node>]
+    def parse_fragment(source)
+      element = case source
+                when Nokogiri::XML::Element
+                  source
+                when String
+                  Nokogiri(source)
+                end
+      element.xpath('string/p').map do |el|
+        parse(el)
+      end
+    end
+
+    # Parse a unit into our AST. This will deal with anything passed in, but
+    # to parse multiple nodes successfully or to parse and entire sheet, see
+    # {parse_fragment} and {parse_sheet}.
+    #
+    # @param [Nokogiri::Node, String] source
+    # @raise [ParseError] when given a `source` we cannot deal with.
+    # @return [Node, Array<Node>]
+    def parse(source)
+      case source
+      when Nokogiri::XML::Element
+        parse_element(source)
+      when Nokogiri::XML::NodeSet
+        source.map { |s| parse(s) }.compact
+      when Nokogiri::XML::Text
+        Text.new(source.text)
+      when String
+        doc = Nokogiri(source)
+        if doc.children.any?
+          parse(doc.children)
+        else
+          Text.new(source)
+        end
+      else
+        raise ParseError, "unexpected #{source.inspect}"
+      end
+    end
+
+    private
+
+    def parse_element(source)
+      case source.name
+      when 'p'
+        block = Block.build(parse(source.children), **@current_block_attributes)
+        reset_block
+        block
+      when 'element'
+        span = Span.build(
+          parse(source.children),
+          kind: source[:kind],
+          **@current_span_attributes
+        )
+        reset_span
+        span
+      when 'tag'
+        @current_block_attributes[:kind] = source[:kind] if source[:kind]
+        @current_block_attributes[:level] += 1 if source.text == "\t"
+        nil
+      when 'attribute'
+        case source[:identifier]
+        when 'syntax'
+          @current_block_attributes[:syntax] = source.text
+        when 'text'
+          @current_span_attributes[:text] = parse_fragment(source)
+        when 'size'
+          parse(source.children)
+        else
+          @current_span_attributes[source[:identifier].downcase.to_sym] = source.text
+        end
+        nil
+      when 'size'
+        @current_span_attributes[:width] = source[:width].to_i
+        @current_span_attributes[:height] = source[:height].to_i
+        nil
+      when 'tags'
+        parse(source.children)
+        nil
+      else
+        raise ParseError, "unknown element name #{source.name}"
+      end
+    end
+
+    def parse_keywords(element)
+      element
+        .xpath('./attachment[@type="keywords"]')
+        .flat_map { |el| el.text.split(',') }
+    end
+
+    def parse_files(element)
+      element
+        .xpath('./attachment[@type="file"]')
+        .map(&:text)
+    end
+
+    def parse_notes(element)
+      element
+        .xpath('./attachment[@type="note"]')
+        .map { |el| parse_fragment(el) }
+    end
+
+    def reset
+      reset_block
+      reset_span
+    end
+
+    def reset_block
+      @current_block_attributes = { kind: 'paragraph', level: 0 }
+    end
+
+    def reset_span
+      @current_span_attributes = {}
+    end
+  end
+end