brandish 0.1.1

data/lib/brandish/processors/html.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "brandish/processors/html/group"
+require "brandish/processors/html/header"
+require "brandish/processors/html/markup"
+require "brandish/processors/html/output"
+require "brandish/processors/html/style"
+require "brandish/processors/html/script"
+
+module Brandish
+  module Processors
+    # Processors for generating HTML output.  This implements the {Common}
+    # processors.
+    module HTML
+    end
+  end
+end

data/lib/brandish/processors/html/group.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "hanami/helpers/html_helper"
+require "hanami/helpers/escape_helper"
+
+module Brandish
+  module Processors
+    module HTML
+      # A "group."  This is used for grouping together elements for styling,
+      # like the "div" element in HTML.  This uses `div` as one of the
+      # element names, but that doesn't mean that it includes all of the same
+      # attributes.  This accepts the `"class"`, `"id"`, and `"name"` headers.
+      #
+      # @see Common::Group
+      class Group < Common::Group
+        include Processor::Block
+        include Hanami::Helpers::HtmlHelper
+        include Hanami::Helpers::EscapeHelper
+        register %i(html group) => self
+        self.names = %i(group g div)
+
+        # Creates a div element with the proper class and id values.  This
+        # currently ignores the name value.
+        #
+        # @return [::String]
+        def perform
+          html.div(raw(accepted_body), class: class_value, id: id_value).to_s
+        end
+      end
+    end
+  end
+end

data/lib/brandish/processors/html/header.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "hanami/helpers/html_helper"
+
+module Brandish
+  module Processors
+    module HTML
+      # A processor that defines the `header` command.  This creates a list
+      # internally of all of the headers in the document, to later be used to
+      # possibly create a table of contents, if needed.
+      #
+      # This takes no options.
+      #
+      # Pairs:
+      #
+      # - `"level"` - Optional.  Defaults to `1`.  The "level" of the header.
+      #   This should be a value between 1 and 6.
+      # - `"value"` - Required.  The name of the header.
+      # - `"id"` - Optional.  The ID of the header.  This is a unique value
+      #   to reference to this header.  If no value is given, it defaults
+      #   to a modified `"value"`.
+      # - `"class"` - Optional.  The class name of the header.
+      class Header < Processors::Common::Header
+        include Hanami::Helpers::HtmlHelper
+        register %i(html header) => self
+        pair :class
+
+        # The tags to use for each header level.  This is just `h1` through
+        # `h6`.
+        #
+        # @return [::Symbol]
+        TAGS = %i(h1 h2 h3 h4 h5 h6).freeze
+
+        # Renders the proper HTML tag for the header, including the proper
+        # id, and an optional class value from the pairs.
+        #
+        # @return [::String]
+        def header_render
+          html.tag(TAGS.fetch(header_level - 1), header_value, id: header_id,
+            class: @pairs.fetch("class", "")).to_s
+        end
+      end
+    end
+  end
+end

data/lib/brandish/processors/html/markup.rb

@@ -0,0 +1,131 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "hanami/helpers/escape_helper"
+
+module Brandish
+  module Processors
+    module HTML
+      # Markup support for the HTML format.  For more information, and available
+      # options, see the {Processors::Common::Markup} processor.
+      #
+      # This markup processor provides the following engines:
+      #
+      # - `:kramdown` - A Markdown formatter.  More information on this
+      #   markup format can be found at <https://github.com/gettalong/kramdown>.
+      #   Available options are: `:template`, `:auto_ids` (not recommended),
+      #   `:auto_id_stripping` (not recommended), `:auto_id_prefix` (not
+      #   recommended), `:parse_block_html`, `:parse_span_html`,
+      #   `:html_to_native`, `:link_defs`, `:footnote_nr`, `:enable_coderay`,
+      #   `:coderay_wrap`, `:coderay_line_numbers`,
+      #   `:coderay_line_number_start`, `:coderay_tab_width`,
+      #   `:coderay_bold_every`, `:coderay_css`, `:coderay_default_lang`,
+      #   `:entity_output`, `:toc_levels` (not recommended), `:line_width`,
+      #   `:latex_headers` (does nothing), `:smart_quotes`,
+      #   `:remove_block_html_tags`, `:remove_span_html_tags`,
+      #   `:header_offset`, `:hard_wrap`, `:syntax_highlighter`,
+      #   `:syntax_highlighter_opts`, `:math_engine`, `:math_engine_opts`,
+      #   `:footnote_backlink`, and `:gfm_quirks`.  Requires the kramdown
+      #   gem.
+      # - `:rdiscount` - A Markdown formatter.  More information on this
+      #   markup format can be found at <https://github.com/davidfstr/rdiscount>.
+      #   The options for this engine are specified in an array, not a
+      #   hash.  Available options are: `:smart`, `:filter_styles`,
+      #   `:filter_html`, `:fold_lines`, `:footnotes`, `:generate_toc` (not
+      #   recommended), `:no_image`, `:no_links`, `:no_tables`, `:strict`,
+      #   `:autolink`, `:safelink`, `:no_pseudo_protocals`, `:no_superscript`,
+      #   and `:no_strikethrough`.  Requires the rdiscount gem.
+      # - `:minidown` - A Markdown formatter.  More information on this
+      #   markup format can be found at <https://github.com/jjyr/minidown>.
+      #   Available options are: `:code_block_handler`.
+      # - `:redcloth` - A Textile formatter.  More information on this
+      #   markup format can be found at <https://github.com/jgarber/redcloth>.
+      #   Available options are: `:filter_html`, `:sanitize_html`,
+      #   `:filter_styles`, `:filter_classes`, `:filter_ids`,
+      #   `:hard_breaks` (deprecated, default), `:lite_mode`,
+      #   and `:no_span_caps`.
+      # - `:redcarpet` - A Markdown formatter.  More information on this
+      #   markup format can be found at <https://github.com/vmg/redcarpet>.
+      #   This is the preferred format for Brandish due to its integration.
+      #   The options that are valid for this formatter can be found on
+      #   {Brandish::Markup::Redcarpet::Format}.
+      # - `:creole` - A creole formatter.  More information on this markup
+      #   format can be found at <https://github.com/larsch/creole>.
+      #   Available options are: `:allowed_schemes`, `:extensions`,
+      #   and `:no_escape`.
+      # - `:sanitize` - A sanitizer, to remove non-whitelisted elements.
+      #   More information on this can be found at <https://github.com/rgrove/sanitize>.
+      #   The option can be a symbol or a hash; the hash is passed directly
+      #   to sanitize.  The symbol is mapped to one of the corresponding
+      #   default configs.  Symbol values are: `:restricted`, `:basic`,
+      #   `:relaxed`, and `:basic`.
+      # - `:escape` - Escapes the content to prevent conflict with the
+      #   resulting format.
+      #
+      # @note
+      #   This class provides the `html:markup` processor.
+      class Markup < Processors::Common::Markup
+        include Hanami::Helpers::EscapeHelper
+        register %i(html markup) => self
+
+        engine(:kramdown, {}, nil, :markup_kramdown)
+        engine(:rdiscount, [:smart], nil, :markup_rdiscount)
+        engine(:minidown, {}, :initialize_minidown, :markup_minidown)
+        engine(:redcloth, [], nil, :markup_redcloth)
+        engine(:redcarpet, {}, :initialize_redcarpet, :markup_redcarpet)
+        engine(:creole, { extensions: true }, nil, :markup_creole)
+        engine(:sanitize, :relaxed, nil, :markup_sanitize)
+        engine(:escape, nil, nil, :markup_escape)
+
+      private
+
+        def markup_kramdown(value, options)
+          Kramdown::Document.new(value, options).to_html
+        end
+
+        def markup_rdiscount(value, options)
+          ::RDiscount.new(value, *options).to_html
+        end
+
+        def initialize_minidown
+          @parser = ::Minidown::Parser.new(engine_options)
+        end
+
+        def markup_minidown(value, _)
+          @parser.render(value)
+        end
+
+        def markup_redcloth(value, options)
+          ::RedCloth.new(value, options).to_html
+        end
+
+        def initialize_redcarpet
+          data = engine_options.merge(format: :html, context: @context)
+          @format = ::Brandish::Markup::Redcarpet::Format.new(data)
+        end
+
+        def markup_redcarpet(value, _options)
+          @format.render(value)
+        end
+
+        def markup_creole(value, options)
+          ::Creole::Parser.new(value, options).to_html
+        end
+
+        def initialize_sanitize
+          return unless engine_options.is_a?(::Symbol)
+          @_engine_options =
+            ::Sanitize::Config.const_get(engine_options.to_s.upcase)
+        end
+
+        def markup_sanitize(value, options)
+          ::Sanitize.fragment(value, options)
+        end
+
+        def markup_escape(value, _options)
+          h(value)
+        end
+      end
+    end
+  end
+end

data/lib/brandish/processors/html/output.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "mustache"
+require "brandish/processors/html/output/document"
+
+module Brandish
+  module Processors
+    module HTML
+      # Outputs the result of processing the document.  Without this processor,
+      # the document is not output, and most other processors have no effect.
+      #
+      # Options:
+      #
+      # - `:template` - Optional.  The name of the template to use.  This
+      #   defaults to the format used.
+      # - `:path` - Optional.  The full path, including the file name,
+      #   to output the file.  This overwrites `:directory` and `:file`.
+      #   Defaults to `:directory`/`:file`.
+      # - `:directory` - Optional.  The directory to the file to output
+      #   the file.  Overwritten by `:path`.  Defaults to the output path
+      #   of the project.
+      # - `:file` - Optional.  The name of the file to output to.  Overwritten
+      #   by `:path`.  Defaults to the name of the entry file, with the
+      #   extension substituted by `".html"`.
+      #
+      # @see Common::Output
+      class Output < Common::Output
+        register %i(html output) => self
+
+        # Sets up the output processor.  This creates a {Document} and puts
+        # it on the `:document` context option.
+        #
+        # @see Common::Output#setup
+        # @return [void]
+        def setup
+          super
+
+          @document = @context[:document] = Document.new
+          @document.title = @context.configure.root.basename.to_s
+        end
+
+      private
+
+        def find_path
+          @options.fetch(:path) do
+            directory = @options.fetch(:directory, ".")
+            file = @options.fetch(:file) do
+              ::Pathname.new(@context.form.entry).sub_ext(".html")
+            end
+
+            directory.expand_path(@context.configure.output) / file
+          end
+        end
+
+        def template_data
+          @document.data.merge("content" => @root.flatten)
+        end
+      end
+    end
+  end
+end

data/lib/brandish/processors/html/output/document.rb

@@ -0,0 +1,127 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Brandish
+  module Processors
+    module HTML
+      class Output < Common::Output
+        # A "document."  This contains meta information for the document,
+        # such as the title, author, description, styles, and scripts that
+        # are used to set up the HTML document.
+        #
+        # @api private
+        class Document
+          # The title of the document.  This is used for the `<title>` tag.
+          #
+          # @return [::String, nil]
+          attr_accessor :title
+
+          # The author for the document.  This is used for a `<meta>` tag.
+          #
+          # @return [::String, nil]
+          attr_accessor :author
+
+          # The description of the document.  This is used for a `<meta>` tag.
+          #
+          # @return [::String, nil]
+          attr_accessor :description
+
+          # Initialize the document.
+          def initialize
+            @title = ""
+            @author = ""
+            @description = ""
+            @styles = []
+            @scripts = []
+          end
+
+          # Adds a given style with the given type.  The type is the kind of
+          # style it is; this should be either one of `:inline` or `:linked`.
+          #
+          # @param type [::Symbol] The style type.
+          # @param content [::String] The contents of the style.  For an
+          #   inline style, this is the stylesheet itself; for a linked
+          #   style, this is the link to the stylesheet.
+          # @return [self]
+          def add_style(type, content)
+            inline = type == :inline
+            linked = type == :linked
+
+            @styles << {
+              "inline?" => inline,
+              "linked?" => linked,
+              "content" => content.to_s
+            }
+            self
+          end
+
+          # Adds a given script with the given type.  The type of the kind of
+          # script it is; this should be either one of `:inline` or `:linked`.
+          #
+          # @param type [::Symbol] The style type.
+          # @param content [::String] The contents of the script.  For an
+          #   inline style, this is the script it self; for a linked script,
+          #   this is the link to the script.
+          # @return [self]
+          def add_script(type, content)
+            inline = type == :inline
+            linked = type == :linked
+
+            @scripts << {
+              "inline?" => inline,
+              "linked?" => linked,
+              "content" => content.to_s
+            }
+            self
+          end
+
+          # Adds an inline style.
+          #
+          # @see #add_style
+          # @param content [::String] The stylesheet itself.
+          # @return (see #add_style)
+          def add_inline_style(content)
+            add_style(:inline, content)
+          end
+
+          # Adds an linked style.
+          #
+          # @see #add_style
+          # @param content [::String] The link to the stylesheet.
+          # @return (see #add_style)
+          def add_linked_style(content)
+            add_style(:linked, URI.escape(content.to_s))
+          end
+
+          # Adds an inline script.
+          #
+          # @see #add_script
+          # @param content [::String] The script itself.
+          # @return (see #add_script)
+          def add_inline_script(content)
+            add_script(:inline, content)
+          end
+
+          # Adds an linked script.
+          #
+          # @see #add_script
+          # @param content [::String] The link to the script.
+          # @return (see #add_script)
+          def add_linked_script(content)
+            add_script(:linked, URI.escape(content.to_s))
+          end
+
+          # The data from this document.  This is used to pass all of the
+          # proper information to the templating library.
+          #
+          # @return [::Object]
+          def data
+            { "title" => @title, "author" => @author,
+              "description" => @description,
+              "styles" => @styles, "scripts" => @scripts }.freeze
+          end
+        end
+      end
+    end
+  end
+end

data/lib/brandish/processors/html/script.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "brandish/processors/html/script/babel"
+require "brandish/processors/html/script/coffee"
+require "brandish/processors/html/script/vanilla"
+
+module Brandish
+  module Processors
+    module HTML
+      # A script asset.  This is a JavaScript asset.
+      #
+      # Engines:
+      #
+      # - `"babel"`, `"babel-file"` - A command.  This takes the contents
+      #   of the resolved file, transpiles it, and outputs it into
+      #   the output path, given by `#load_file_paths`.
+      # - `"babel-inline"` - A block.  Similar to `"babel"`; however, it
+      #   takes the block, uses {Parser::Node::Root#flatten} on it,
+      #   transpiles the result, and adds that as an inline script.
+      # - `"coffee"`, `"coffee-file"` - A command.  This takes the contents
+      #   of the resolved file, transpiles it, and outputs it into
+      #   the output path, given by `#load_file_paths`.
+      # - `"coffee-inline"` - A block.  Similar to `"coffee"`; however, it
+      #   takes the block, uses {Parser::Node::Root#flatten} on it,
+      #   transpiles the result, and adds that as an inline script.
+      # - `"file"` - A command.  Takes a file, and copies it over to the
+      #   destination, based on the values given in `#load_file_paths`.
+      # - `"remote"`, `"remote-file"` - A command.  Takes a URI (supports 
+      #   `http`, `https`, and `ftp`), and outputs the directory into the
+      #   `"output"` pair (or a uri path assumed from the URI).
+      # - `"inline"` - A block.  This performs {Parser::Node::Root#flatten}
+      #   on the body, and pushes the result as an inline style.
+      # - `"remote-inline"` - A command.  Similar to `"remote"`; however,
+      #   this takes the remote styles as an inline style.
+      #
+      # Pairs:
+      #
+      # - `"src"`, `"file"`, `"name"`, or `"link"` - Required.  At least one
+      #   of these options are required.  They all perform the same function.
+      #   This defines the name or path of the asset to add or process.
+      # - `"type"` - Required.  The type of the asset to process.  This defines
+      #   how the asset is handled.
+      class Script < Common::Asset
+        register %i(html script) => self
+        self.names = %i(script scripting)
+
+        include Script::Babel
+        include Script::Coffee
+        include Script::Vanilla
+
+        # (see Common::Asset::Paths#asset_kind_path)
+        def asset_kind_path
+          "assets/scripts"
+        end
+
+        # (see Common::Asset::Paths#asset_kind_extension)
+        def asset_kind_extension
+          ".js"
+        end
+      end
+    end
+  end
+end