nokolexbor 0.7.0-aarch64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1853f48d77d8dc95236e11a3a41e2e38e276c28e6cc89a18100786892c359707
+  data.tar.gz: d4ebcf31410396478657ecedc405622b5c97ed431c2dd9afea8c199efb2d27cd
+SHA512:
+  metadata.gz: 588c9575348817533f15249f6fab58ea84823b4e33d6300db70b7b1a4052e278868b19263f1fc9ec822d3098e9314422b792440aa8e8976e859fcbb0ccc21c43
+  data.tar.gz: bee83d0ff2ecc3bc390f574d26eeef91df0791deac17caa80fe4bdfc206a7f419030cea1c70dc1273d6e71d68c39178fc356efa2c1b0e6fa5d2d9756f3727584

data/lib/nokolexbor/builder.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Nokolexbor
+  # A DSL for programmatically building HTML documents.
+  #
+  # == No-arg block (instance_eval style) – tag names are called bare:
+  #
+  #   Nokolexbor do
+  #     body do
+  #       h1 'Hello world'
+  #       p 'This little p'
+  #       ul do
+  #         li 'Go to market'
+  #         li 'Go to bed'
+  #       end
+  #     end
+  #   end
+  #
+  # == Block-parameter style – tag names are called on the builder argument:
+  #
+  #   Nokolexbor::Builder.new do |b|
+  #     b.body do
+  #       b.h1 'Hello world'
+  #     end
+  #   end
+  #
+  # == Building into an existing node:
+  #
+  #   Nokolexbor::Builder.with(existing_node) do
+  #     span 'injected'
+  #   end
+  #
+  class Builder
+    # The Document used to create new nodes
+    attr_accessor :doc
+
+    # The node that currently receives new children
+    attr_accessor :parent
+
+    # Arity of the outermost block (drives instance_eval vs yield dispatch)
+    attr_accessor :arity
+
+    # A context object for use when the block has no arguments
+    attr_accessor :context
+
+    # Build into an existing +root+ node.
+    def self.with(root, &block)
+      new(root, &block)
+    end
+
+    # @param root [Node, nil]
+    #   When given, new nodes are appended under +root+ and +root.document+
+    #   is used as the owning document.  When omitted a fresh {Document} and
+    #   a {DocumentFragment} container are created.
+    def initialize(root = nil, &block)
+      if root
+        @doc    = root.document
+        @parent = root
+      else
+        @doc    = Document.new
+        @parent = DocumentFragment.new(@doc)
+      end
+
+      @context = nil
+      @arity   = nil
+
+      return unless block
+
+      @arity = block.arity
+      if @arity <= 0
+        # Capture outer self so that outer methods / ivars remain accessible
+        # via method_missing delegation while the builder acts as self.
+        @context = eval("self", block.binding)
+        instance_eval(&block)
+      else
+        yield self
+      end
+    end
+
+    # Insert a Text node containing +string+.
+    def text(string)
+      insert(@doc.create_text_node(string))
+    end
+
+    # Insert a CDATA node containing +string+.
+    def cdata(string)
+      insert(@doc.create_cdata(string))
+    end
+
+    # Insert a Comment node containing +string+.
+    def comment(string)
+      insert(@doc.create_comment(string))
+    end
+
+    # Append raw HTML (parsed into nodes) under the current parent.
+    def <<(string)
+      @doc.fragment(string).children.each { |x| insert(x) }
+    end
+
+    # Serialize the built content to an HTML string.
+    def to_html
+      @parent.to_html
+    end
+    alias_method :to_s, :to_html
+
+    # Ruby's Kernel#p, Kernel#pp, etc. are defined on Object and therefore on
+    # Builder itself.  They must be overridden so they fall through to
+    # method_missing and create the corresponding HTML element instead of
+    # printing values to stdout.
+    def p(*args, &block) # :nodoc:
+      method_missing(:p, *args, &block)
+    end
+
+    def method_missing(method, *args, &block) # :nodoc:
+      # Only delegate to the outer context for methods the user defined there.
+      # Standard Object / Kernel methods (like :p, :pp, :puts …) must not be
+      # forwarded to @context because all objects respond to them, which would
+      # bypass element creation entirely.
+      if @context && !OBJECT_INSTANCE_METHODS.include?(method) && @context.respond_to?(method)
+        @context.send(method, *args, &block)
+      else
+        node = @doc.create_element(method.to_s.sub(/[_!]$/, ""), *args)
+        insert(node, &block)
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false) # :nodoc:
+      (@context && !OBJECT_INSTANCE_METHODS.include?(method) && @context.respond_to?(method)) || super
+    end
+
+    # Methods defined on plain Object that should never be forwarded to @context
+    # as HTML element creation fallbacks.
+    OBJECT_INSTANCE_METHODS = Object.instance_methods.to_set.freeze
+
+    private
+
+    # Add +node+ as a child of @parent; if a block is given, push @parent
+    # to +node+ for the duration of that block, then restore it.
+    # Returns a {NodeBuilder} for the inserted node so attributes / classes
+    # can be chained: <tt>div.container.hero!</tt>
+    def insert(node, &block)
+      node = @parent.add_child(node)
+      if block
+        old_parent = @parent
+        @parent    = node
+        @arity   ||= block.arity
+        begin
+          if @arity <= 0
+            instance_eval(&block)
+          else
+            yield(self)
+          end
+        ensure
+          @parent = old_parent
+        end
+      end
+      NodeBuilder.new(node, self)
+    end
+
+    # Wraps a built node and exposes a fluent API for setting classes and ids:
+    #
+    #   div.container        # => <div class="container">
+    #   div.box.highlight    # => <div class="box highlight">
+    #   div.thing!           # => <div id="thing">
+    #   div.container.hero!  # => <div class="container" id="hero">
+    #
+    class NodeBuilder # :nodoc:
+      def initialize(node, doc_builder)
+        @node        = node
+        @doc_builder = doc_builder
+      end
+
+      def []=(k, v)
+        @node[k] = v
+      end
+
+      def [](k)
+        @node[k]
+      end
+
+      def method_missing(method, *args, &block)
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+
+        case method.to_s
+        when /^(.*)!$/
+          @node["id"]  = Regexp.last_match(1)
+          @node.content = args.first if args.first
+        when /^(.*)=$/
+          @node[Regexp.last_match(1)] = args.first
+        else
+          @node["class"] =
+            ((@node["class"] || "").split(/\s/) + [method.to_s]).join(" ")
+          @node.content = args.first if args.first
+        end
+
+        opts.each do |k, v|
+          @node[k.to_s] = ((@node[k.to_s] || "").split(/\s/) + [v.to_s]).join(" ")
+        end
+
+        if block
+          old_parent           = @doc_builder.parent
+          @doc_builder.parent  = @node
+          arity = @doc_builder.arity || block.arity
+          value = if arity <= 0
+            @doc_builder.instance_eval(&block)
+          else
+            yield(@doc_builder)
+          end
+          @doc_builder.parent = old_parent
+          return value
+        end
+
+        self
+      end
+
+      def respond_to_missing?(_method, _include_private = false) # :nodoc:
+        true
+      end
+    end
+  end
+end

data/lib/nokolexbor/document.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Nokolexbor
+  class Document < Nokolexbor::Node
+    # Create an {Element} with +name+ belonging to this document, optionally setting contents or
+    # attributes.
+    #
+    # @param name [String]
+    # @param contents_or_attrs [#to_s, Hash]
+    #
+    # @return [Element]
+    #
+    # @example An empty element without attributes
+    #   doc.create_element("div")
+    #   # => <div></div>
+    #
+    # @example An element with contents
+    #   doc.create_element("div", "contents")
+    #   # => <div>contents</div>
+    #
+    # @example An element with attributes
+    #   doc.create_element("div", {"class" => "container"})
+    #   # => <div class='container'></div>
+    #
+    # @example An element with contents and attributes
+    #   doc.create_element("div", "contents", {"class" => "container"})
+    #   # => <div class='container'>contents</div>
+    #
+    # @example Passing a block to mutate the element
+    #   doc.create_element("div") { |node| node["class"] = "blue" }
+    #   # => <div class='blue'></div>
+    def create_element(name, *contents_or_attrs, &block)
+      elm = Nokolexbor::Element.new(name, self, &block)
+      contents_or_attrs.each do |arg|
+        case arg
+        when Hash
+          arg.each do |k, v|
+            elm[k.to_s] = v.to_s
+          end
+        else
+          elm.content = arg.to_s
+        end
+      end
+      elm
+    end
+
+    # Create a {Text} with +string+.
+    #
+    # @return [Text]
+    def create_text_node(string, &block)
+      Nokolexbor::Text.new(string.to_s, self, &block)
+    end
+
+    # Create a {CDATA} containing +string+.
+    #
+    # @return [CDATA]
+    def create_cdata(string, &block)
+      Nokolexbor::CDATA.new(string.to_s, self, &block)
+    end
+
+    # Create a {Comment} containing +string+.
+    #
+    # @return [Comment]
+    def create_comment(string, &block)
+      Nokolexbor::Comment.new(string.to_s, self, &block)
+    end
+
+    # A reference to +self+.
+    #
+    # @return [Document]
+    def document
+      self
+    end
+
+    # Get the meta tag encoding for this document. If there is no meta tag, nil is returned.
+    #
+    # @return [String]
+    def meta_encoding
+      if (meta = at_css("meta[charset]"))
+        meta[:charset]
+      elsif (meta = meta_content_type)
+        meta["content"][/charset\s*=\s*([\w-]+)/i, 1]
+      end
+    end
+
+    # Set the meta tag encoding for this document.
+    #
+    # If an meta encoding tag is already present, its content is
+    # replaced with the given text.
+    #
+    # Otherwise, this method tries to create one at an appropriate
+    # place supplying head and/or html elements as necessary, which
+    # is inside a head element if any, and before any text node or
+    # content element (typically <body>) if any.
+    def meta_encoding=(encoding)
+      if (meta = meta_content_type)
+        meta["content"] = format("text/html; charset=%s", encoding)
+        encoding
+      elsif (meta = at_css("meta[charset]"))
+        meta["charset"] = encoding
+      else
+        meta = Nokolexbor::Node.new("meta", self)
+        meta["charset"] = encoding
+
+        if (head = at_css("head"))
+          head.prepend_child(meta)
+        else
+          set_metadata_element(meta)
+        end
+        encoding
+      end
+    end
+
+    def meta_content_type
+      xpath("//meta[@http-equiv and boolean(@content)]").find do |node|
+        node["http-equiv"] =~ /\AContent-Type\z/i
+      end
+    end
+    private :meta_content_type
+
+    def set_metadata_element(element)
+      if (head = at_css("head"))
+        head << element
+      elsif (html = at_css("html"))
+        head = html.prepend_child(Nokolexbor::Node.new("head", self))
+        head.prepend_child(element)
+      elsif (first = children.find do |node|
+               case node
+               when Nokolexbor::Node
+                 true
+               end
+             end)
+        # We reach here only if the underlying document model
+        # allows <html>/<head> elements to be omitted and does not
+        # automatically supply them.
+        first.add_previous_sibling(element)
+      else
+        html = add_child(Nokolexbor::Node.new("html", self))
+        head = html.add_child(Nokolexbor::Node.new("head", self))
+        head.prepend_child(element)
+      end
+    end
+
+    # Parse HTML into a {Document}.
+    #
+    # @param string_or_io [String, #read]
+    #   The HTML to be parsed. It may be a String, or any object that
+    #   responds to #read such as an IO, or StringIO.
+    #
+    # @return [Document]
+    def self.parse(string_or_io)
+      html = string_or_io
+      if string_or_io.respond_to?(:read)
+        html = string_or_io.read
+      end
+
+      if html.respond_to?(:encoding) && html.encoding != Encoding::UTF_8
+        html = html.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+      end
+
+      parse_native(html)
+    end
+
+    private
+
+    IMPLIED_XPATH_CONTEXTS = ["//"].freeze # :nodoc:
+  end
+end

data/lib/nokolexbor/document_fragment.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Nokolexbor
+  class DocumentFragment < Nokolexbor::Node
+    # Create a {DocumentFragment} from +tags+.
+    #
+    # @return [DocumentFragment]
+    def self.parse(tags)
+      new(Nokolexbor::Document.new, tags, nil)
+    end
+
+    #  Create a new {DocumentFragment} from +tags+.
+    #
+    #  If +ctx+ is present, it is used as a context node for the
+    #  subtree created.
+    def initialize(document, tags = nil, ctx = nil)
+      return self unless tags
+
+      ctx ||= document
+      node_set = ctx.parse(tags)
+      node_set.each { |child| child.parent = self } unless node_set.empty?
+      nil
+    end
+
+    # @return [String] The name of {DocumentFragment}
+    def name
+      "#document-fragment"
+    end
+
+    alias_method :outer_html, :inner_html
+    alias_method :to_html, :outer_html
+    alias_method :to_s, :outer_html
+    alias_method :serialize, :outer_html
+
+    # Create a {DocumentFragment} from +data+.
+    #
+    # @return [DocumentFragment]
+    def fragment(data)
+      document.fragment(data)
+    end
+  end
+end