pakyow-presenter 0.11.3 → 1.0.0.rc1

data/lib/pakyow/presenter/significant_nodes.rb

@@ -0,0 +1,309 @@
+# frozen_string_literal: true
+
+require "string_doc"
+
+require "pakyow/presenter/presenters/endpoint"
+require "pakyow/presenter/presenters/form"
+
+module Pakyow
+  module Presenter
+    # @api private
+    FORM_TAG = "form".freeze
+    # @api private
+    OPTION_TAG = "option".freeze
+    # @api private
+    OPTGROUP_TAG = "optgroup".freeze
+    # @api private
+    INPUT_TAG = "input".freeze
+    # @api private
+    LABEL_TAG = "label".freeze
+    # @api private
+    TITLE_TAG = "title".freeze
+    # @api private
+    BODY_TAG = "body".freeze
+    # @api private
+    HEAD_TAG = "head".freeze
+    # @api private
+    META_TAG = "meta".freeze
+    # @api private
+    HTML_TAG = "html".freeze
+    # @api private
+    SCRIPT_TAG = "script".freeze
+    # @api private
+    SELECT_TAG = "select".freeze
+    # @api private
+    TEXTAREA_TAG = "textarea".freeze
+
+    # @api private
+    class SignificantNode
+      def self.within_binding?(node)
+        if BindingNode.significant?(node)
+          true
+        elsif !node.is_a?(Oga::XML::Document)
+          within_binding?(node.parent)
+        else
+          false
+        end
+      end
+
+      def self.binding_within?(node)
+        node.children.any? { |child|
+          BindingNode.significant?(child) || binding_within?(child)
+        }
+      end
+
+      def self.within_form?(node)
+        if FormNode.significant?(node)
+          true
+        elsif !node.is_a?(Oga::XML::Document)
+          within_form?(node.parent)
+        else
+          false
+        end
+      end
+    end
+
+    # @api private
+    class PrototypeNode < SignificantNode
+      StringDoc.significant :prototype, self
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && node.attribute(:prototype)
+      end
+    end
+
+    # @api private
+    class EndpointNode < SignificantNode
+      StringDoc.significant :endpoint, self
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && node.attribute(:endpoint)
+      end
+
+      def self.decorate(node)
+        node.set_label(:presenter_type, Presenters::Endpoint)
+      end
+    end
+
+    # @api private
+    class EndpointActionNode < SignificantNode
+      StringDoc.significant :endpoint_action, self
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && node.attribute(:"endpoint-action")
+      end
+    end
+
+    # @api private
+    class ContainerNode < SignificantNode
+      StringDoc.significant :container, self
+
+      CONTAINER_REGEX = /@container\s*([a-zA-Z0-9\-_]*)/.freeze
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Comment) && node.text.strip.match(CONTAINER_REGEX)
+      end
+    end
+
+    # @api private
+    class PartialNode < SignificantNode
+      StringDoc.significant :partial, self
+
+      PARTIAL_REGEX = /@include\s*([a-zA-Z0-9\-_]*)/.freeze
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Comment) && node.to_xml.strip.match(PARTIAL_REGEX)
+      end
+    end
+
+    # @api private
+    class BindingNode < SignificantNode
+      StringDoc.significant :binding, self, descend: false
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && node.attribute(:binding) && node.name != FORM_TAG
+      end
+    end
+
+    # @api private
+    class WithinBindingNode < SignificantNode
+      StringDoc.significant :within_binding, self
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && within_binding?(node)
+      end
+    end
+
+    # @api private
+    class BindingWithinNode < SignificantNode
+      StringDoc.significant :binding_within, self
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && binding_within?(node)
+      end
+    end
+
+    # @api private
+    class MultipartBinding < SignificantNode
+      StringDoc.significant :multipart_binding, self
+
+      def self.significant?(node)
+        BindingNode.significant?(node) &&
+          node.attribute(:binding).value.include?(".") &&
+          !node.attribute(:binding).value.start_with?("@")
+      end
+    end
+
+    # @api private
+    class ComponentNode < SignificantNode
+      StringDoc.significant :component, self
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && node.attribute(:ui)
+      end
+
+      def self.decorate(node)
+        node.set_label(:components, node.attributes[:"data-ui"].split(";").map { |component_string|
+          Component.parse(component_string)
+        })
+      end
+    end
+
+    # @api private
+    class ModeNode < SignificantNode
+      StringDoc.significant :mode, self
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && node.attribute(:mode)
+      end
+    end
+
+    # @api private
+    class FormNode < SignificantNode
+      StringDoc.significant :form, self, descend: false
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && node.attribute(:binding) && node.name == FORM_TAG
+      end
+
+      def self.decorate(node)
+        node.set_label(:presenter_type, Presenters::Form)
+        node.set_label(:view_type, Form)
+      end
+    end
+
+    # @api private
+    class WithinFormNode < SignificantNode
+      StringDoc.significant :within_form, self
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && within_form?(node)
+      end
+    end
+
+    # @api private
+    class OptionNode < SignificantNode
+      StringDoc.significant :option, self
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && node.name == OPTION_TAG
+      end
+    end
+
+    # @api private
+    class OptgroupNode < SignificantNode
+      StringDoc.significant :optgroup, self
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && node.name == OPTGROUP_TAG
+      end
+    end
+
+    # @api private
+    class MethodOverrideNode < SignificantNode
+      StringDoc.significant :method_override, self
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && node.name == INPUT_TAG && node.attribute(:name).to_s == "_method"
+      end
+    end
+
+    # @api private
+    class LabelNode < SignificantNode
+      StringDoc.significant :label, self
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && node.name == LABEL_TAG
+      end
+    end
+
+    # @api private
+    class TitleNode < SignificantNode
+      StringDoc.significant :title, self
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && node.name == TITLE_TAG
+      end
+    end
+
+    # @api private
+    class BodyNode < SignificantNode
+      StringDoc.significant :body, self
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && node.name == BODY_TAG
+      end
+    end
+
+    # @api private
+    class HeadNode < SignificantNode
+      StringDoc.significant :head, self
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && node.name == HEAD_TAG
+      end
+    end
+
+    # @api private
+    class MetaNode < SignificantNode
+      StringDoc.significant :meta, self
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && node.name == META_TAG
+      end
+    end
+
+    # @api private
+    class HTMLNode < SignificantNode
+      StringDoc.significant :html, self
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && node.name == HTML_TAG
+      end
+    end
+
+    # @api private
+    class TemplateNode < SignificantNode
+      StringDoc.significant :template, self
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && node.name == SCRIPT_TAG && node[:type] == "text/template"
+      end
+    end
+
+    # @api private
+    class FieldNode < SignificantNode
+      StringDoc.significant :field, self
+
+      FIELD_TAGS = [
+        INPUT_TAG,
+        SELECT_TAG,
+        TEXTAREA_TAG
+      ].freeze
+
+      def self.significant?(node)
+        node.is_a?(Oga::XML::Element) && FIELD_TAGS.include?(node.name)
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/templates.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require "pakyow/support/deep_dup"
+require "pakyow/support/core_refinements/string/normalization"
+
+module Pakyow
+  module Presenter
+    class Templates
+      using Support::DeepDup
+      using Support::Refinements::String::Normalization
+
+      attr_reader :name, :path, :layouts, :pages, :includes, :config
+
+      DEFAULT_LAYOUTS_PATH = "layouts"
+      DEFAULT_PARTIALS_PATH = "includes"
+      DEFAULT_PAGES_PATH = "pages"
+
+      def initialize(name, path, processor: nil, config: {})
+        @name, @path, @processor = name, Pathname(path), processor
+        build_config(config)
+        load_templates
+      end
+
+      def view?(path)
+        @info.key?(path)
+      end
+
+      def paths
+        @info.keys
+      end
+
+      def info(path)
+        if view?(path)
+          @info[path]
+        end
+      end
+
+      def layout(name_or_path)
+        if name_or_path.is_a?(Symbol)
+          layout_with_name(name_or_path)
+        else
+          info(name_or_path) & [:layout]
+        end
+      end
+
+      def page(path)
+        info(path) & [:page]
+      end
+
+      def partials(path)
+        info(path) & [:partials] || {}
+      end
+
+      def partial(path, name)
+        partials(path)[name.to_sym]
+      end
+
+      def layouts_path
+        path.join(@config[:paths][:layouts])
+      end
+
+      def partials_path
+        path.join(@config[:paths][:partials])
+      end
+
+      def pages_path
+        path.join(@config[:paths][:pages])
+      end
+
+      def template?(path)
+        return false if path.basename.to_s.start_with?(".")
+        return false unless path.extname == ".html" || @processor&.process?(path.extname)
+
+        true
+      end
+
+      # Yields each template.
+      #
+      def each
+        @info.each do |_path, info|
+          yield info[:layout]
+          yield info[:page]
+          info[:partials].each do |_name, partial|
+            yield partial
+          end
+        end
+      end
+
+      private
+
+      def build_config(config)
+        @config = {
+          prefix: config[:prefix] || "/",
+          paths: {
+            layouts: config.dig(:paths, :layouts) || DEFAULT_LAYOUTS_PATH,
+            pages: config.dig(:paths, :pages) || DEFAULT_PAGES_PATH,
+            partials: config.dig(:paths, :partials) || DEFAULT_PARTIALS_PATH,
+          }
+        }
+      end
+
+      def load_templates
+        load_layouts
+        load_partials
+        load_path_info
+      end
+
+      def load_layouts
+        @layouts = if File.exist?(layouts_path)
+          layouts_path.children.each_with_object({}) { |file, layouts|
+            next unless template?(file)
+            layout = load_view_of_type_at_path(Layout, file)
+            layouts[layout.name] = layout
+          }
+        else
+          {}
+        end
+      end
+
+      def load_partials
+        @includes = if File.exist?(partials_path)
+          partials_path.children.each_with_object({}) { |file, partials|
+            next unless template?(file)
+            partial = load_view_of_type_at_path(Partial, file, normalize_path(file))
+            partials[partial.name] = partial
+          }
+        else
+          {}
+        end
+      end
+
+      def load_path_info
+        @info = {}
+
+        Pathname.glob(File.join(pages_path, "**/*")) do |path|
+          # TODO: better way to skip partials?
+          next if path.basename.to_s.start_with?("_")
+
+          next unless template?(path)
+
+          begin
+            if page = page_at_path(path)
+              @info[File.join(@config[:prefix], normalize_path(path, pages_path))] = {
+                page: page,
+                layout: layout_with_name(page.info(:layout)),
+                partials: @includes.merge(partials_at_path(path))
+              }
+            end
+          rescue FrontMatterParsingError => e
+            message = "Could not parse front matter for #{path}:\n\n#{e.context}"
+
+            if e.wrapped_exception
+              message << "\n#{e.wrapped_exception.problem} at line #{e.wrapped_exception.line} column #{e.wrapped_exception.column}"
+            end
+
+            raise FrontMatterParsingError.new(message)
+          end
+        end
+      end
+
+      def layout_with_name(name)
+        @layouts[name.to_sym]
+      end
+
+      def page_at_path(path)
+        if File.directory?(path)
+          if Dir.glob(File.join(path, "index.*")).empty?
+            index_page_at_path(path)
+          end
+        else
+          load_view_of_type_at_path(Page, path, normalize_path(path))
+        end
+      end
+
+      def index_page_at_path(path)
+        # TODO: don't ascend above store path
+        path.ascend do |parent_path|
+          next unless info = info(normalize_path(parent_path))
+          next unless page = info[:page]
+          return page
+        end
+      end
+
+      # TODO: do we always need to make it relative, etc here?
+      # maybe break up these responsibilities to the bare minimum required
+      def normalize_path(path, relative_from = @path)
+        path = path.expand_path
+        relative_from = relative_from.expand_path
+
+        # make it relative
+        path = path.relative_path_from(relative_from)
+        # we can short-circuit here
+        return "/" if path.to_s == "."
+
+        # remove the extension
+        path = path.sub_ext("")
+
+        # remove index from the end
+        path = path.sub("index", "")
+
+        # actually normalize it
+        String.normalize_path(path.to_s)
+      end
+
+      def partials_at_path(path)
+        # FIXME: don't ascend above store path
+        path.ascend.select(&:directory?).each_with_object({}) { |parent_path, partials|
+          parent_path.children.select { |child|
+            child.basename.to_s.start_with?("_")
+          }.each_with_object(partials) { |child, child_partials|
+            partial = load_view_of_type_at_path(Partial, child, normalize_path(child))
+            child_partials[partial.name] ||= partial
+          }
+        }
+      end
+
+      def load_view_of_type_at_path(type, path, logical_path = nil)
+        content = File.read(path)
+        info, content = FrontMatterParser.parse_and_scrub(content)
+
+        if @processor
+          content = @processor.process(content, File.extname(path).delete(".").to_sym)
+        end
+
+        type.load(path, info: info, content: content, logical_path: logical_path)
+      end
+    end
+  end
+end