commonmarker 2.9.0 → 2.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 051a8f17a827d1329de0031ac4f933b3a78aee387707562979698f810bb64a87
-  data.tar.gz: e4f6e3c99d4c680db8d41f6d2bea08fb394db91cd628fed345a47c8b2f078e9f
+  metadata.gz: 23a7f4c3d26ba5e9b9301c9af8db67520fdda959f6cf8faab5564e9276d8d7bc
+  data.tar.gz: 7ee7de8566813969b327b94d3e0c8b6a8e536a38906522cb7eb9f13206186811
 SHA512:
-  metadata.gz: dce8bf8e72268b9304ad04bc91d741be82f6e35de32a6914cacbce2be17b89ea1349c04dc45e83b06f91eeecb3eb36b697d099044b53926a1cafdb9bf7003894
-  data.tar.gz: 9dbcbfea2785a3e5567f605e0b96ff87e78cee59aa4219b524a55fd1d4241261acbc76fd5d3950565ca457795e0b957a3b19c5a27f6284eddce227de41653cff
+  metadata.gz: eafbbb68ab07ac0ab161437cb6327ea55e232d6c412ea1be6f7d4b6474fae61607d905efc028000c5be2a9c193719e7b5dda16b69d4be2dbcdef112c65c82ed5
+  data.tar.gz: f2c79a17c4dec72cdd65979d59952097a286f125a593935986088788cb936f1a99e0dc13f2493afc8c96e309dc175900989956e39fa0044bc9bc8bbd893578c2

data/README.md

@@ -140,6 +140,24 @@ doc.to_commonmark
 # => # The site\n\nGitHub\n
 ```
 
+### Reading and writing node content
+
+`string_content` reads and writes the text of nodes whose content is plain text (like `:text`, `:code`, and `:code_block`).
+
+`literal` reads and writes the raw string a node carries, for every node type that has one (like `:text`, `:code`, `:code_block`, `:html_block`, `:html_inline`, `:raw`, `:math`, and `:frontmatter`).
+
+The two exist separately because they mean different things. Rewriting `string_content` only ever swaps text for text. Rewriting `literal` on an `:html_block`, `:html_inline`, or `:raw` node writes markup that is emitted unescaped:
+
+```ruby
+doc = Commonmarker.parse("A <b>bold</b> claim")
+
+doc.walk do |node|
+  node.literal = "<i>" if node.type == :html_inline && node.literal == "<b>"
+end
+```
+
+Note that a `:frontmatter` node's literal includes its delimiters and trailing newlines, so anything you assign must include them too.
+
 ## Options and plugins
 
 ### Options
@@ -169,21 +187,21 @@ Note that there is a distinction in comrak for "parse" options and "render" opti
 
 ### Render options
 
-| Name                 | Description                                                                                            | Default |
-| -------------------- | ------------------------------------------------------------------------------------------------------ | ------- |
-| `hardbreaks`         | [Soft line breaks](http://spec.commonmark.org/0.27/#soft-line-breaks) translate into hard line breaks. | `true`  |
-| `github_pre_lang`    | GitHub-style `<pre lang="xyz">` is used for fenced code blocks with info tags.                         | `true`  |
-| `full_info_string`   | Gives info string data after a space in a `data-meta` attribute on code blocks.                        | `false` |
-| `width`              | The wrap column when outputting CommonMark.                                                            | `80`    |
-| `unsafe`             | Allow rendering of raw HTML and potentially dangerous links.                                           | `false` |
-| `escape`             | Escape raw HTML instead of clobbering it.                                                              | `false` |
-| `sourcepos`          | Include source position attribute in HTML and XML output.                                              | `false` |
-| `escaped_char_spans` | Wrap escaped characters in span tags.                                                                  | `true`  |
-| `ignore_empty_links` | Ignores empty links, leaving the Markdown text in place.                                               | `false` |
-| `gfm_quirks`         | Outputs HTML with GFM-style quirks; namely, not nesting `<strong>` inlines.                            | `false` |
-| `prefer_fenced`      | Always output fenced code blocks, even where an indented one could be used.                            | `false` |
-| `tasklist_classes`   | Add CSS classes to the HTML output of the tasklist extension                                           | `false` |
-| `compact_html`       | Suppress newlines in pretty-printed HTML output.                                                       | `false` |
+| Name                 | Description                                                                                                              | Default      |
+| -------------------- | ------------------------------------------------------------------------------------------------------------------------ | ------------ |
+| `hardbreaks`         | [Soft line breaks](http://spec.commonmark.org/0.27/#soft-line-breaks) translate into hard line breaks.                   | `true`       |
+| `github_pre_lang`    | GitHub-style `<pre lang="xyz">` is used for fenced code blocks with info tags.                                           | `true`       |
+| `full_info_string`   | Gives info string data after a space in a `data-meta` attribute on code blocks.                                          | `false`      |
+| `width`              | The wrap column when outputting CommonMark.                                                                              | `80`         |
+| `unsafe`             | Allow rendering of raw HTML and potentially dangerous links.                                                             | `false`      |
+| `escape`             | Escape raw HTML instead of clobbering it.                                                                                | `false`      |
+| `sourcepos`          | Include source position attribute in HTML and XML output.                                                                | `false`      |
+| `escaped_char_spans` | Wrap escaped characters in span tags.                                                                                    | `true`       |
+| `ignore_empty_links` | Ignores empty links, leaving the Markdown text in place.                                                                 | `false`      |
+| `gfm_quirks`         | Outputs HTML with GFM-style quirks; namely, not nesting `<strong>` inlines.                                              | `false`      |
+| `prefer_fenced`      | Always output fenced code blocks, even where an indented one could be used.                                              | `false`      |
+| `tasklist_classes`   | Add CSS classes to the HTML output of the tasklist extension                                                             | `false`      |
+| `compact_html`       | Suppress newlines in pretty-printed HTML output.                                                                         | `false`      |
 | `alert_style`        | The style of alert output: `"specific"` (`<div class="markdown-alert">`) or `"semantic"` (`<aside class="admonition">`). | `"specific"` |
 
 As well, there are several extensions which you can toggle in the same manner:

data/ext/commonmarker/src/node.rs

@@ -31,6 +31,39 @@ pub struct CommonmarkerNode {
 /// SAFETY: This is safe because we only access this data when the GVL is held.
 unsafe impl Send for CommonmarkerNode {}
 
+/// Reports whether a node value supports a given property, where "property" is
+/// a method name with any trailing `=` or `?` removed.
+///
+/// `None` means the property is not type-dependent at all
+/// (`walk`, `type`, `delete`, ...).
+fn value_supports(value: &ComrakNodeValue, property: &str) -> Option<bool> {
+    let supported = match property {
+        "string_content" => matches!(
+            value,
+            ComrakNodeValue::Text(_) | ComrakNodeValue::Code(_) | ComrakNodeValue::CodeBlock(_)
+        ),
+        "literal" => matches!(
+            value,
+            ComrakNodeValue::Text(_)
+                | ComrakNodeValue::Code(_)
+                | ComrakNodeValue::CodeBlock(_)
+                | ComrakNodeValue::HtmlBlock(_)
+                | ComrakNodeValue::HtmlInline(_)
+                | ComrakNodeValue::Raw(_)
+                | ComrakNodeValue::Math(_)
+                | ComrakNodeValue::FrontMatter(_)
+        ),
+        "url" | "title" => matches!(value, ComrakNodeValue::Link(_) | ComrakNodeValue::Image(_)),
+        "header_level" => matches!(value, ComrakNodeValue::Heading(_)),
+        "list_type" | "list_start" | "list_tight" => matches!(value, ComrakNodeValue::List(_)),
+        "fenced" | "fence_info" => matches!(value, ComrakNodeValue::CodeBlock(_)),
+        "alert_type" => matches!(value, ComrakNodeValue::Alert(_)),
+        _ => return None,
+    };
+
+    Some(supported)
+}
+
 impl CommonmarkerNode {
     pub fn new(ruby: &Ruby, args: &[Value]) -> Result<Self, magnus::Error> {
         let args = scan_args::scan_args::<_, (), (), (), _, ()>(args)?;
@@ -784,6 +817,63 @@ impl CommonmarkerNode {
         }
     }
 
+    /// Returns `true` or `false` if the given method is only available for
+    /// certain node types, and `nil` if its availability does not depend on
+    /// the node's type. Backs `Node#respond_to?`.
+    fn supports_method(rb_self: &Self, name: Symbol) -> Option<bool> {
+        let node = rb_self.inner.borrow();
+        let name = name.to_string();
+        let property = name.trim_end_matches('=').trim_end_matches('?');
+
+        value_supports(&node.data.value, property)
+    }
+
+    fn get_literal(ruby: &Ruby, rb_self: &Self) -> Result<String, magnus::Error> {
+        let node = rb_self.inner.borrow();
+
+        match &node.data.value {
+            ComrakNodeValue::Text(text) => Ok(text.to_string()),
+            ComrakNodeValue::Code(code) => Ok(code.literal.to_string()),
+            ComrakNodeValue::CodeBlock(code_block) => Ok(code_block.literal.to_string()),
+            ComrakNodeValue::HtmlBlock(html_block) => Ok(html_block.literal.to_string()),
+            ComrakNodeValue::HtmlInline(html_inline) => Ok(html_inline.to_string()),
+            ComrakNodeValue::Raw(raw) => Ok(raw.to_string()),
+            ComrakNodeValue::Math(math) => Ok(math.literal.to_string()),
+            ComrakNodeValue::FrontMatter(front_matter) => Ok(front_matter.to_string()),
+            _ => Err(magnus::Error::new(
+                ruby.exception_type_error(),
+                "node does not have a literal",
+            )),
+        }
+    }
+
+    fn set_literal(
+        ruby: &Ruby,
+        rb_self: &Self,
+        new_literal: String,
+    ) -> Result<bool, magnus::Error> {
+        let mut node = rb_self.inner.borrow_mut();
+
+        match node.data.value {
+            ComrakNodeValue::Text(ref mut text) => *text = new_literal.into(),
+            ComrakNodeValue::Code(ref mut code) => code.literal = new_literal,
+            ComrakNodeValue::CodeBlock(ref mut code_block) => code_block.literal = new_literal,
+            ComrakNodeValue::HtmlBlock(ref mut html_block) => html_block.literal = new_literal,
+            ComrakNodeValue::HtmlInline(ref mut html_inline) => *html_inline = new_literal,
+            ComrakNodeValue::Raw(ref mut raw) => *raw = new_literal,
+            ComrakNodeValue::Math(ref mut math) => math.literal = new_literal,
+            ComrakNodeValue::FrontMatter(ref mut front_matter) => *front_matter = new_literal,
+            _ => {
+                return Err(magnus::Error::new(
+                    ruby.exception_type_error(),
+                    "node does not have a literal",
+                ))
+            }
+        }
+
+        Ok(true)
+    }
+
     fn get_title(ruby: &Ruby, rb_self: &Self) -> Result<String, magnus::Error> {
         let node = rb_self.inner.borrow();
 
@@ -1292,6 +1382,14 @@ pub fn init(ruby: &Ruby, m_commonmarker: RModule) -> Result<(), magnus::Error> {
         method!(CommonmarkerNode::set_string_content, 1),
     )?;
 
+    c_node.define_method("literal", method!(CommonmarkerNode::get_literal, 0))?;
+    c_node.define_method("literal=", method!(CommonmarkerNode::set_literal, 1))?;
+
+    c_node.define_method(
+        "node_supports?",
+        method!(CommonmarkerNode::supports_method, 1),
+    )?;
+
     c_node.define_method("url", method!(CommonmarkerNode::get_url, 0))?;
     c_node.define_method("url=", method!(CommonmarkerNode::set_url, 1))?;
     c_node.define_method("title", method!(CommonmarkerNode::get_title, 0))?;

data/lib/commonmarker/config.rb

@@ -68,8 +68,8 @@ module Commonmarker
       syntax_highlighter: {
         theme: "base16-ocean.dark",
         path: "",
-      },
-    }
+      }.freeze,
+    }.freeze
 
     class << self
       include Commonmarker::Utils

data/lib/commonmarker/node/inspect.rb

@@ -28,10 +28,8 @@ module Commonmarker
             :fence_info,
             :alert_type,
           ].filter_map do |name|
-            [name, __send__(name)]
-          rescue StandardError
-            nil
-          end.compact
+            [name, __send__(name)] if respond_to?(name)
+          end
 
           printer.seplist(attrs) do |name, value|
             printer.text("#{name}=")

data/lib/commonmarker/node.rb

@@ -8,6 +8,18 @@ module Commonmarker
     include Enumerable
     include Inspect
 
+    # Public: Whether this node responds to the given method.
+    #
+    # name        - A {Symbol} or {String} naming the method.
+    # include_all - A {Boolean} indicating whether to consider private methods.
+    #
+    # Returns a {Boolean}.
+    def respond_to?(name, include_all = false)
+      return false if node_supports?(name.to_sym) == false
+
+      super
+    end
+
     # Public: An iterator that "walks the tree," descending into children recursively.
     #
     # blk - A {Proc} representing the action to take for each child

data/lib/commonmarker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Commonmarker
-  VERSION = "2.9.0"
+  VERSION = "2.10.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: commonmarker
 version: !ruby/object:Gem::Version
-  version: 2.9.0
+  version: 2.10.0
 platform: ruby
 authors:
 - Garen Torikian
@@ -24,34 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !ruby/object:Gem::Dependency
-  name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
 description: A fast, safe, extensible parser for CommonMark. This wraps the comrak
   Rust crate.
 executables: []