dato_dast 0.0.1

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "dato_dast"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/dato_dast.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "lib/dato_dast/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "dato_dast"
+  spec.version       = DatoDast::VERSION
+  spec.authors       = ["John DeWyze"]
+  spec.email         = ["john@dewyze.dev"]
+
+  spec.summary       = "Gem for converting DatoCMS Structured Text to Html"
+  spec.description   = "This gem provides a way to convert DatoCMS structured text to Html, as well as an extension for Middleman."
+  spec.homepage      = "https://github.com/dewyze/dato_dast"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+
+  spec.metadata["homepage_uri"] = "https://github.com/dewyze/dato_dast"
+  spec.metadata["source_code_uri"] = "https://github.com/dewyze/dato_dast"
+  spec.metadata["changelog_uri"] = "https://github.com/dewyze/dato_dast/blob/main/CHANGELOG.md."
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport"
+  spec.add_development_dependency "pry-byebug"
+end

data/lib/dato_dast/configuration.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module DatoDast
+  class Configuration
+    TYPE_CONFIG = {
+      Nodes::Block.type => { "node" => Nodes::Block },
+      Nodes::Blockquote.type => { "tag" => "blockquote", "node" => Nodes::AttributedQuote },
+      Nodes::Code.type => { "tag" => "code", "node" => Nodes::Code, "wrappers" => ["pre"] },
+      Nodes::Generic.type => { "node" => Nodes::Generic },
+      Nodes::Heading.type => { "tag" => ->(node) { "h#{node.level}" }, "node" => Nodes::Heading },
+      Nodes::ItemLink.type => { "tag" => "a", "node" => Nodes::ItemLink, "url_key" => :slug },
+      Nodes::Link.type => { "tag" => "a", "node" => Nodes::Link },
+      Nodes::List.type => { "tag" => ->(node) { node.style == "bulleted" ? "ul" : "ol" }, "node" => Nodes::List },
+      Nodes::ListItem.type => { "tag" => "li", "node" => Nodes::ListItem },
+      Nodes::Paragraph.type => { "tag" => "p", "node" => Nodes::Paragraph },
+      Nodes::Root.type => { "tag" => "div", "node" => Nodes::Root },
+      Nodes::Span.type => { "node" => Nodes::Span },
+      Nodes::ThematicBreak.type => { "tag" => "hr", "node" => Nodes::ThematicBreak },
+    }.freeze
+
+    MARK_CONFIG = {
+      Marks::CODE => { "tag" => "code" },
+      Marks::EMPHASIS => { "tag" => "em" },
+      Marks::HIGHLIGHT => { "tag" => "mark" },
+      Marks::STRIKETHROUGH => { "tag" => "strike" },
+      Marks::STRONG => { "tag" => "strong" },
+      Marks::UNDERLINE => { "tag" => "u" },
+    }.freeze
+
+    BLOCK_RENDER_KEYS = ["node", "render_value", "structure"].freeze
+
+    attr_reader :blocks, :host, :marks, :types
+    attr_accessor :highlight, :item_links, :smart_links
+
+    def initialize
+      @blocks = {}
+      @highlight = true
+      @host = nil
+      @item_links = {}
+      @marks = MARK_CONFIG.transform_values { |value| value.dup }
+      @smart_links = true
+      @types = TYPE_CONFIG.transform_values { |value| value.dup }
+    end
+
+    def host=(new_host)
+      uri = URI(new_host)
+
+      if uri.host.present?
+        @host = uri.host
+      else
+        @host = uri.to_s
+      end
+    end
+
+    def blocks=(new_blocks)
+      validate_blocks_configuration(new_blocks)
+
+      @blocks = new_blocks
+    end
+
+    def marks=(new_marks)
+      validate_marks_configuration(new_marks)
+
+      @marks.merge!(new_marks)
+    end
+
+    def types=(new_types)
+      validate_types(new_types)
+
+      @types.merge!(new_types)
+    end
+
+    def add_wrapper(type, wrapper)
+      wrappers = Array.wrap(@types[type]["wrappers"])
+      wrappers << wrapper
+      @types[type]["wrappers"] = wrappers
+    end
+
+    private
+
+    def validate_blocks_configuration(blocks_config)
+      invalid_blocks = []
+
+      blocks_config.each do |block, block_config|
+        next if block_config.is_a?(Proc)
+
+        intersection = block_config.keys & BLOCK_RENDER_KEYS
+        invalid_blocks << block unless intersection.length == 1
+      end
+
+      raise Errors::InvalidBlocksConfiguration.new(invalid_blocks) if invalid_blocks.present?
+    end
+
+    def validate_types(types_config)
+      invalid_configs = []
+      invalid_nodes = []
+
+      types_config.each do |type, type_config|
+        node = type_config["node"]
+        if node
+          invalid_nodes << type unless node.instance_methods.include?(:render)
+        else
+          invalid_configs << type
+        end
+      end
+
+      raise Errors::InvalidTypesConfiguration.new(invalid_configs) if invalid_configs.present?
+      raise Errors::InvalidNodes.new(invalid_nodes) if invalid_nodes.present?
+    end
+
+    def validate_marks_configuration(marks_config)
+      invalid_marks = []
+
+      marks_config.each do |mark, mark_config|
+        invalid_marks << mark unless mark_config.keys.include?("tag")
+      end
+
+      raise Errors::InvalidMarksConfiguration.new(invalid_marks) if invalid_marks.present?
+    end
+  end
+end

data/lib/dato_dast/errors/block_field_missing.rb

@@ -0,0 +1,15 @@
+module DatoDast
+  module Errors
+    class BlockFieldMissing < StandardError
+      MESSAGE = <<~MSG.strip
+        A structure type of 'field' requires the block to have the specified field.
+
+        The following block configuration is invalid:
+      MSG
+
+      def initialize(item_type)
+        super(MESSAGE + " " + item_type)
+      end
+    end
+  end
+end

data/lib/dato_dast/errors/block_node_missing_render_function.rb

@@ -0,0 +1,15 @@
+module DatoDast
+  module Errors
+    class BlockNodeMissingRenderFunction < StandardError
+      MESSAGE = <<~MSG.strip
+        A node class provided for a block must have a 'render' method.
+
+        The node object for the following block item type is invalid:
+      MSG
+
+      def initialize(keys)
+        super(MESSAGE + " " + keys.join(", "))
+      end
+    end
+  end
+end

data/lib/dato_dast/errors/invalid_block_structure_type.rb

@@ -0,0 +1,6 @@
+module DatoDast
+  module Errors
+    class InvalidBlockStructureType < StandardError
+    end
+  end
+end

data/lib/dato_dast/errors/invalid_blocks_configuration.rb

@@ -0,0 +1,18 @@
+module DatoDast
+  module Errors
+    class InvalidBlocksConfiguration < StandardError
+      MESSAGE = <<~MSG.strip
+        A block configuration requires exactly one of the following keys:
+        - "node"
+        - "render_value"
+        - "structure"
+
+        The following block configurations are invalid:
+      MSG
+
+      def initialize(keys)
+        super(MESSAGE + " " + keys.join(", "))
+      end
+    end
+  end
+end

data/lib/dato_dast/errors/invalid_marks_configuration.rb

@@ -0,0 +1,15 @@
+module DatoDast
+  module Errors
+    class InvalidMarksConfiguration < StandardError
+      MESSAGE = <<~MSG.strip
+        A mark configuration requires only the "tag" key.
+
+        The following mark configurations are invalid:
+      MSG
+
+      def initialize(keys)
+        super(MESSAGE + " " + keys.join(", "))
+      end
+    end
+  end
+end

data/lib/dato_dast/errors/invalid_nodes.rb

@@ -0,0 +1,15 @@
+module DatoDast
+  module Errors
+    class InvalidNodes < StandardError
+      MESSAGE = <<~MSG.strip
+        A node class must have a 'render' instance method.
+
+        The node objects for the following types are invalid:
+      MSG
+
+      def initialize(keys)
+        super(MESSAGE + " " + keys.join(", "))
+      end
+    end
+  end
+end

data/lib/dato_dast/errors/invalid_types_configuration.rb

@@ -0,0 +1,15 @@
+module DatoDast
+  module Errors
+    class InvalidTypesConfiguration < StandardError
+      MESSAGE = <<~MSG.strip
+        A type configuration requires the "node" key.
+
+        The following type configurations are invalid:
+      MSG
+
+      def initialize(keys)
+        super(MESSAGE + " " + keys.join(", "))
+      end
+    end
+  end
+end

data/lib/dato_dast/errors/missing_render_value_function.rb

@@ -0,0 +1,15 @@
+module DatoDast
+  module Errors
+    class MissingRenderValueFunction < StandardError
+      MESSAGE = <<~MSG.strip
+        A structure type of 'value' requires a render value function.
+
+        The following block configuration is invalid:
+      MSG
+
+      def initialize(item_type)
+        super(MESSAGE + " " + item_type)
+      end
+    end
+  end
+end

data/lib/dato_dast/errors.rb

@@ -0,0 +1,8 @@
+require "dato_dast/errors/block_field_missing"
+require "dato_dast/errors/block_node_missing_render_function"
+require "dato_dast/errors/invalid_block_structure_type"
+require "dato_dast/errors/invalid_blocks_configuration"
+require "dato_dast/errors/invalid_marks_configuration"
+require "dato_dast/errors/invalid_nodes"
+require "dato_dast/errors/invalid_types_configuration"
+require "dato_dast/errors/missing_render_value_function"

data/lib/dato_dast/extensions/middleman.rb

@@ -0,0 +1,35 @@
+require "middleman-core"
+
+module DatoDast
+  module Extensions
+    class Middleman < Middleman::Extension
+      option :blocks, {}, "Configuration hash for blocks"
+      option :host, nil, "Host for your site, used in conjunction with 'smart_links' option"
+      option :highlight, true, "Toggle whether to attempt to higlight code blocks"
+      option :item_links, {}, "Configuration hash item links types and the url field"
+      option :marks, {}, "Configuration hash for a given mark"
+      option :smart_links, true, "Open Link items in new windows and ItemLinks in the same window"
+      option :types, {}, "Configuration hash for a given block node type"
+
+      def after_configuration
+        DatoDast.configure do |config|
+          config.blocks = options[:blocks]
+          config.highlight = options[:highlight]
+          config.host = options[:host]
+          config.item_links = options[:item_links]
+          config.marks = options[:marks]
+          config.smart_links = options[:smart_links]
+          config.types = options[:types]
+        end
+      end
+
+      helpers do
+        def structured_text(object, config = nil)
+          DatoDast.structured_text(object, config)
+        end
+      end
+    end
+
+    ::Middleman::Extensions.register(:dato_dast, DatoDast::Extensions::Middleman)
+  end
+end

data/lib/dato_dast/html_tag.rb

@@ -0,0 +1,74 @@
+module DatoDast
+  class HtmlTag
+    EMPTY = ""
+    NEWLINE = "\n"
+
+    def self.parse(tag, object = nil)
+      case tag
+      when String
+        new(tag)
+      when Hash
+        html_tag = tag["tag"]
+        css_class = tag["css_class"]
+        meta = tag["meta"]
+
+        HtmlTag.new(html_tag, { "css_class" => css_class, "meta" => meta, "object" => object })
+      when HtmlTag
+        tag
+      when nil
+        HtmlTag.new(nil)
+      else
+        nil
+      end
+    end
+
+    def initialize(tag, options = {})
+      @tag = tag
+      @css_class = options["css_class"] || ""
+      @meta = options["meta"] || {}
+      @object = options["object"]
+    end
+
+    def open
+      return EMPTY unless tag
+
+      "<#{tag}#{css_class}#{meta}>" + NEWLINE
+    end
+
+    def close
+      return EMPTY unless tag
+
+      NEWLINE + "</#{tag}>"
+    end
+
+    private
+
+    def tag
+      if @tag.is_a?(Proc)
+        @tag.call(@object)
+      else
+        @tag
+      end
+    end
+
+    def css_class
+      return "" if @css_class.blank?
+
+      klass = @css_class.is_a?(Proc) ? @css_class.call(@object) : @css_class
+
+      " class=\"#{klass}\""
+    end
+
+    def meta
+      return "" if @meta.blank?
+
+      if @meta.is_a?(Proc)
+        " " + @meta.call(@object)
+      else
+        @meta.reduce("") do |html, pair|
+          html + " #{pair["id"]}=\"#{pair["value"]}\""
+        end
+      end
+    end
+  end
+end

data/lib/dato_dast/marks.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module DatoDast
+  class Marks
+    CODE = "code"
+    EMPHASIS = "emphasis"
+    HIGHLIGHT = "highlight"
+    STRIKETHROUGH = "strikethrough"
+    STRONG = "strong"
+    UNDERLINE = "underline"
+  end
+end

data/lib/dato_dast/nodes/attributed_quote.rb

@@ -0,0 +1,20 @@
+module DatoDast
+  module Nodes
+    class AttributedQuote < Base
+      def attribution
+        @node["attribution"]
+      end
+
+      def render
+        <<~HTML
+          <figure>
+          #{super}
+          <figcaption>
+          #{attribution}
+          </figcaption>
+          </figure>
+        HTML
+      end
+    end
+  end
+end

data/lib/dato_dast/nodes/base.rb

@@ -0,0 +1,113 @@
+module DatoDast
+  module Nodes
+    class Base
+      EMPTY = ""
+      NEWLINE = "\n"
+
+      def self.type
+        name.demodulize.camelize(:lower)
+      end
+
+      def initialize(node, links = [], blocks = [], config = nil)
+        @node = node
+        @links = links
+        @blocks = blocks
+        @config = config
+      end
+
+      def config
+        @config ||= DatoDast.configuration
+      end
+
+      def type
+        @node["type"]
+      end
+
+      def children
+        @node["children"]
+      end
+
+      def wrappers
+        @node["wrappers"] || Array.wrap(node_config["wrappers"])
+      end
+
+      def tag
+        if node_config && node_config["tag"].is_a?(Proc)
+          node_config["tag"].call(proc_object)
+        else
+          @node["tag"] || node_config["tag"]
+        end
+      end
+
+      def css_class
+        if node_config && node_config["css_class"].is_a?(Proc)
+          node_config["css_class"].call(proc_object)
+        else
+          @node["css_class"] || node_config["css_class"]
+        end
+      end
+
+      def meta
+        if node_config && node_config["meta"].is_a?(Proc)
+          node_config["meta"].call(proc_object)
+        else
+          @node["meta"] || node_config["meta"]
+        end
+      end
+
+      def node_config
+        @node_config ||= config.types[type]
+      end
+
+      def tag_info
+        {
+          "tag" => tag,
+          "css_class" => css_class,
+          "meta" => meta,
+        }
+      end
+
+      def render
+        open_wrappers +
+          html_tag.open +
+          render_value +
+          html_tag.close +
+          close_wrappers
+      end
+
+      def render_value
+        render_children
+      end
+
+      def render_children
+        return EMPTY unless children.present?
+
+        children.map do |child|
+          Nodes.wrap(child, @links, @blocks, config).render
+        end.join("\n").gsub(/\n+/, "\n")
+      end
+
+      private
+
+      def html_tag
+        @html_tag ||= HtmlTag.parse(tag_info)
+      end
+
+      def open_wrappers
+        wrapper_tags.map(&:open).join("")
+      end
+
+      def close_wrappers
+        wrapper_tags.reverse.map(&:close).join("")
+      end
+
+      def wrapper_tags
+        @wrapper_tags ||= wrappers.map { |wrappers| HtmlTag.parse(wrappers, proc_object) }
+      end
+
+      def proc_object
+        self
+      end
+    end
+  end
+end