md_to_notion 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9bd284bd98dbb6ec740f9f0cd2deebb57798ea9e0c0ab0793ae7bbe60af54fab
+  data.tar.gz: 3b561a30fcf2b69cdcce42ae2520a02bfccb3b275752d7e3afea4b8b2714fffe
+SHA512:
+  metadata.gz: 17f5672cd71bf21d6957cd2e1b9e36730e41ba2b2bafe5052a3a4a6bfa74557e74c5cbe90110f55673558425e11c8e7773c58bf9c260d2436eb5b0d0296e3d6d
+  data.tar.gz: 57bdcf190ded5abda03ecab6f5cc3d6562c6d4f8c7155722cf55147c5284467303f60b4fdcbddfc28bfd1c8dd12a8a5e578dc98f716e407fd1d85e64cf70c8ba

data/.eslintrc.json

@@ -0,0 +1 @@
+{}

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 2.7
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/.ruby-version

@@ -0,0 +1 @@
+2.7

data/Gemfile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in md_to_notion.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"
+
+gem "rubocop", "~> 1.21"
+
+gem "pry"

data/Gemfile.lock

@@ -0,0 +1,64 @@
+PATH
+  remote: .
+  specs:
+    md-to-notion (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    coderay (1.1.3)
+    diff-lcs (1.5.0)
+    json (2.6.3)
+    method_source (1.0.0)
+    parallel (1.22.1)
+    parser (3.2.0.0)
+      ast (~> 2.4.1)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.6.1)
+    rexml (3.2.5)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.0)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    rubocop (1.42.0)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.1.2.1)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.24.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.24.1)
+      parser (>= 3.1.1.0)
+    ruby-progressbar (1.11.0)
+    unicode-display_width (2.4.2)
+
+PLATFORMS
+  arm64-darwin-20
+  x86_64-linux
+
+DEPENDENCIES
+  md-to-notion!
+  pry
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  rubocop (~> 1.21)
+
+BUNDLED WITH
+   2.3.26

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 rieg-ec
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,156 @@
+# MdToNotion: Markdown to Notion
+
+Dependency-free gem to convert markdown and GitHub flavoured Markdown to Notion API blocks and richtext.
+
+NOTE: this is a work in progress. It works for simple markdown, but has not been tested with all markdown syntax.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add md_to_notion
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install md_to_notion
+
+## Usage
+
+```ruby
+MdToNotion::Parser.markdown_to_notion_blocks(
+  "# heading 1"
+)
+```
+
+<details>
+<summary>result</summary>
+
+```json
+{
+    "type": "heading_1",
+    "heading_1": {
+      "rich_text": [
+        {
+          "type": "text",
+          "text": {
+            "content": "heading 1",
+            "link": null
+          },
+          "annotations": {
+            "bold": false,
+            "italic": false,
+            "strikethrough": false,
+            "underline": false,
+            "code": false
+          },
+          "href": null
+        }
+      ]
+    }
+  }
+```
+</details>
+
+<br>
+
+```ruby
+MdToNotion::Parser.markdown_to_notion_blocks(
+  "> quote with *italic"
+)
+```
+<details>
+<summary>result</summary>
+
+```json
+{
+  "type": "quote",
+  "quote": {
+    "rich_text": [
+      {
+        "type": "text",
+        "text": {
+          "content": "quote with ",
+          "link": null
+        },
+        "annotations": {
+          "bold": false,
+          "italic": false,
+          "strikethrough": false,
+          "underline": false,
+          "code": false
+        },
+        "href": null
+      },
+      {
+        "type": "text",
+        "text": {
+          "content": "italic",
+          "link": null
+        },
+        "annotations": {
+          "bold": false,
+          "italic": true,
+          "strikethrough": false,
+          "underline": false,
+          "code": false
+        },
+        "href": null
+      }
+    ]
+  }
+}
+```
+</details>
+
+<br>
+
+```ruby
+MdToNotion::Parser.markdown_to_notion_blocks <<~CODE
+``ruby
+puts 'it works with code blocks too!'
+``
+CODE
+```
+<details>
+<summary>result</summary>
+
+```json
+{
+  "type": "code",
+  "code": {
+    "rich_text": [
+      {
+        "type": "text",
+        "text": {
+          "content": "puts 'it works with code blocks too!'",
+          "content": null
+        },
+        "annotations": {
+          "bold": false,
+          "italic": false,
+          "strikethrough": false,
+          "underline": false,
+          "code": false
+        },
+        "href": null
+      }
+    ],
+    "language": "ruby"
+  }
+}
+```
+</details>
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/rieg-ec/md_to_notion.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/md_to_notion/blocks.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module MdToNotion
+  module Block
+    def self.heading_1(texts)
+      {
+        type: "heading_1",
+        heading_1: {
+          rich_text: texts.map { |t| rich_text(t) }
+        }
+      }
+    end
+
+    def self.heading_2(texts)
+      {
+        type: "heading_2",
+        heading_2: {
+          rich_text: texts.map { |t| rich_text(t) }
+        }
+      }
+    end
+
+    def self.heading_3(texts)
+      {
+        type: "heading_3",
+        heading_3: {
+          rich_text: texts.map { |t| rich_text(t) }
+        }
+      }
+    end
+
+    def self.paragraph(texts, children: nil)
+      block = {
+        type: "paragraph",
+        paragraph: {
+          rich_text: texts.map { |t| rich_text(t) }
+        }
+      }
+
+      block[:paragraph][:children] = children if children
+      block
+    end
+
+    def self.quote(texts, children: nil)
+      block = {
+        type: "quote",
+        quote: {
+          rich_text: texts.map { |t| rich_text(t) }
+        }
+      }
+
+      block[:quote][:children] = children if children
+      block
+    end
+
+    def self.code(text, lang: nil)
+      {
+        type: "code",
+        code: {
+          rich_text: [rich_text({ text: text })],
+          language: lang
+        }
+      }
+    end
+
+    def self.bulleted_list_item(texts, children: nil)
+      block = {
+        type: "bulleted_list_item",
+        bulleted_list_item: {
+          rich_text: texts.map { |t| rich_text(t) }
+        }
+      }
+
+      block[:bulleted_list_item][:children] = children if children
+      block
+    end
+
+    def self.numbered_list(texts, children: nil)
+      block = {
+        type: "numbered_list_item",
+        numbered_list_item: {
+          rich_text: texts.map { |t| rich_text(t) }
+        }
+      }
+
+      block[:numbered_list_item][:children] = children if children
+      block
+    end
+
+    def self.image
+      {
+        type: "image",
+        image: {
+          type: "external",
+          external: {
+            url: link
+          }
+        }
+      }
+    end
+
+    def self.rich_text(token, annotations: {}, href: nil, link: nil)
+      default_annotations = {
+        bold: token[:type] == :bold,
+        italic: token[:type] == :italic,
+        strikethrough: token[:type] == :strikethrough,
+        underline: token[:type] == :underline,
+        code: token[:type] == :code
+      }
+
+      {
+        type: "text",
+        text: {
+          content: token[:text],
+          link: link
+        },
+        annotations: default_annotations.merge(annotations),
+        href: href
+      }
+    end
+  end
+end

data/lib/md_to_notion/lexer.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require_relative "./tokens"
+
+module MdToNotion
+  class Lexer
+    include Tokens
+
+    class InvalidTokenSyntaxError < StandardError; end
+
+    def initialize(markdown)
+      @markdown = markdown
+      @tokens = []
+      @stack = []
+      @index = 0
+    end
+
+    def tokenize
+      while @index < @markdown.length
+        begin
+          next_char = @markdown[@index]
+
+          if next_char == " "
+            @index += 1
+            next @stack << " "
+          elsif next_char == "#"
+            tokenize_heading
+          elsif next_char == "["
+            tokenize_link
+          elsif next_char == "!"
+            tokenize_image
+          elsif next_char == ">"
+            tokenize_quote
+          elsif next_char == "-"
+            tokenize_bullet_list
+          elsif next_char =~ /\d+/
+            tokenize_numbered_list
+          elsif next_char == "`" && peek(2) == "```"
+            tokenize_block_code
+          elsif next_char == "\n"
+            @index += 1
+          else
+            tokenize_paragraph
+          end
+        rescue InvalidTokenSyntaxError
+          tokenize_paragraph
+        end
+
+        @stack = []
+      end
+
+      @tokens
+    end
+
+    private
+
+    def peek(n = 1)
+      @markdown[@index..@index + n]
+    end
+
+    def tokenize_heading
+      line = @markdown[@index..].split("\n").first
+      if line =~ HEADING_1
+        @tokens << heading_1(::Regexp.last_match(0))
+      elsif line =~ HEADING_2
+        @tokens << heading_2(::Regexp.last_match(0))
+      elsif line =~ HEADING_3
+        @tokens << heading_3(::Regexp.last_match(0))
+      else
+        return raise InvalidTokenSyntaxError, "Invalid heading: #{line}"
+      end
+
+      @index += ::Regexp.last_match(0).length
+    end
+
+    def tokenize_block_code
+      raise InvalidTokenSyntaxError, "Invalid code block: #{@markdown[@index..]}" \
+        unless @markdown[@index..] =~ CODE_BLOCK
+
+      @tokens << code_block(::Regexp.last_match(0))
+      @index += ::Regexp.last_match(0).length
+    end
+
+    def tokenize_bullet_list
+      line = @markdown[@index..].split("\n").first
+      raise InvalidTokenSyntaxError, "Invalid bullet list: #{line}" \
+        unless line =~ BULLET_LIST
+
+      nesting = @stack.count(" ")
+      @stack = []
+
+      @tokens << bullet_list(::Regexp.last_match(0), nesting: nesting)
+      @index += ::Regexp.last_match(0).length
+    end
+
+    def tokenize_link
+      line = @markdown[@index..].split("\n").first
+      raise InvalidTokenSyntaxError, "Invalid link syntax: #{line}" \
+        unless line =~ LINK
+
+      @tokens << link(::Regexp.last_match(0))
+      @index += ::Regexp.last_match(0).length
+    end
+
+    def tokenize_image
+      line = @markdown[@index..].split("\n").first
+      raise InvalidTokenSyntaxError, "Invalid image syntax: #{line}" \
+        unless line =~ IMAGE
+
+      @tokens << image(::Regexp.last_match(0))
+      @index += ::Regexp.last_match(0).length
+    end
+
+    def tokenize_quote
+      line = @markdown[@index..].split("\n").first
+      raise InvalidTokenSyntaxError, "Invalid quote syntax: #{line}" \
+        unless line =~ QUOTE
+
+      @tokens << quote(::Regexp.last_match(0))
+      @index += ::Regexp.last_match(0).length
+    end
+
+    def tokenize_numbered_list
+      line = @markdown[@index..].split("\n").first
+      raise InvalidTokenSyntaxError, "Invalid numbered list: #{line}" \
+        unless line =~ NUMBERED_LIST
+
+      nesting = @stack.count(" ")
+      @stack = []
+
+      @tokens << numbered_list(::Regexp.last_match(0), nesting: nesting)
+      @index += ::Regexp.last_match(0).length
+    end
+
+    def tokenize_paragraph
+      line = @markdown[@index..].split("\n").first
+      @tokens << paragraph(line)
+      @index += line.length
+    end
+
+    def tokenize_strikethrough
+      line = @markdown[@index..].split("\n").first
+      raise InvalidTokenSyntaxError, "Invalid strikethrough syntax: #{line}" \
+        unless line =~ STRIKETHROUGH
+
+      @tokens << strikethrough(::Regexp.last_match(0))
+      @index += ::Regexp.last_match(0).length
+    end
+  end
+end

data/lib/md_to_notion/parser.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "./lexer"
+require_relative "./blocks"
+
+module MdToNotion
+  module Parser
+    def self.markdown_to_ast(markdown)
+      lexer = Lexer.new(markdown)
+      lexer.tokenize
+    end
+
+    def self.markdown_to_notion_blocks(markdown)
+      ast = markdown_to_ast(markdown)
+      ast_to_notion_blocks(ast)
+    end
+
+    def self.ast_to_notion_blocks(ast)
+      ast.map do |token|
+        case token[:type]
+        when :heading_1
+          Block.heading_1(token[:rich_texts])
+        when :heading_2
+          Block.heading_2(token[:rich_texts])
+        when :heading_3
+          Block.heading_3(token[:rich_texts])
+        when :paragraph
+          Block.paragraph(token[:rich_texts])
+        when :code_block
+          Block.code(token[:text], lang: token[:lang])
+        when :bullet_list
+          Block.bulleted_list_item(token[:rich_texts])
+        when :numbered_list
+          Block.numbered_list(token[:rich_texts])
+        when :image
+          Block.image(token[:text], token[:rich_texts])
+        when :quote
+          Block.quote(token[:rich_texts])
+        end
+      end
+    end
+  end
+end

data/lib/md_to_notion/tokens.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module MdToNotion
+  module Tokens
+    HEADING_1 = /^# (.+)/.freeze
+    HEADING_2 = /^## (.+)/.freeze
+    HEADING_3 = /^### (.+)/.freeze
+    CODE_BLOCK = /^```(?:[^\n]+\n)?(.+?)\n```$/m.freeze
+    BULLET_LIST = /^- (.+)/.freeze
+    NUMBERED_LIST = /^([0-9]+)\. (.+)/.freeze
+    IMAGE = /!\[([^\]]+)\]\(([^)]+)\)/.freeze
+    QUOTE = /^> (.+)/.freeze
+
+    def heading_1(match)
+      { type: :heading_1, rich_texts: tokenize_rich_text(match.gsub(/^# /, "")) }
+    end
+
+    def heading_2(match)
+      { type: :heading_2, rich_texts: tokenize_rich_text(match.gsub(/^## /, "")) }
+    end
+
+    def heading_3(match)
+      { type: :heading_3, rich_texts: tokenize_rich_text(match.gsub(/^### /, "")) }
+    end
+
+    def code_block(match)
+      {
+        type: :code_block,
+        text: match.gsub(/^```[^\n]*\n/, "").gsub(/\n```$/, ""),
+        lang: match.gsub(/^```/, "").gsub(/\n.+$/m, "")
+      }
+    end
+
+    def bullet_list(match, nesting: 0)
+      {
+        type: :bullet_list,
+        rich_texts: tokenize_rich_text(match.gsub(/^- /, "")),
+        nesting: nesting
+      }
+    end
+
+    def numbered_list(match, nesting: 0)
+      {
+        type: :numbered_list,
+        rich_texts: tokenize_rich_text(match.gsub(/^[0-9]+\. /, "")),
+        number: match.gsub(/\..+$/, "").to_i,
+        nesting: nesting
+      }
+    end
+
+    def image(match)
+      {
+        type: :image,
+        rich_texts: tokenize_rich_text(match.gsub(/!\[([^\]]+)\]\(([^)]+)\)/, '\1')),
+        link: match.gsub(/!\[([^\]]+)\]\(([^)]+)\)/, '\2')
+      }
+    end
+
+    def paragraph(match)
+      { type: :paragraph, rich_texts: tokenize_rich_text(match) }
+    end
+
+    def quote(match)
+      { type: :quote, rich_texts: tokenize_rich_text(match.gsub(/^> /, "")) }
+    end
+
+    ## rich text objects
+
+    def tokenize_rich_text(text)
+      # use a regular expression to capture all the rich text elements and the text between them as separate groups
+      groups = text.scan(/(`[^`]*`|\*\*[^*]*\*\*|\*[^*]*\*|~~[^~]*~~|[^`*~]+)/).flatten
+
+      # map the groups to tokens
+      groups.map do |group|
+        case group
+        when /^`/
+          code(group)
+        when /^\*\*/
+          bold(group)
+        when /^\*/
+          italic(group)
+        when /^~~/
+          strikethrough(group)
+        else
+          text(group)
+        end
+      end
+    end
+
+    def code(text)
+      { type: :code, text: text.gsub(/^`/, "").gsub(/`$/, "") }
+    end
+
+    def italic(match)
+      { type: :italic, text: match.gsub(/\*/, "") }
+    end
+
+    def bold(match)
+      { type: :bold, text: match.gsub(/\*/, "") }
+    end
+
+    def text(match)
+      { type: :text, text: match }
+    end
+
+    def strikethrough(match)
+      { type: :strikethrough, text: match.gsub(/~~/, "") }
+    end
+  end
+end

data/lib/md_to_notion/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MdToNotion
+  VERSION = "0.1.0"
+end

data/lib/md_to_notion.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "md_to_notion/version"
+
+module MdToNotion
+  class Error < StandardError; end
+end

data/sig/md_to_notion.rbs

@@ -0,0 +1,4 @@
+module MdToNotion
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: md_to_notion
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- rieg-ec
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-01-08 00:00:00.000000000 Z
+dependencies: []
+description: Convert Markdown and GitHub Flavoured Markdown to Notion API Blocks and
+  RichText.
+email:
+- rieg.10199@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".eslintrc.json"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/md_to_notion.rb
+- lib/md_to_notion/blocks.rb
+- lib/md_to_notion/lexer.rb
+- lib/md_to_notion/parser.rb
+- lib/md_to_notion/tokens.rb
+- lib/md_to_notion/version.rb
+- sig/md_to_notion.rbs
+homepage: https://github.com/rieg-ec/md-to-notion
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/rieg-ec/md-to-notion
+  source_code_uri: https://github.com/rieg-ec/md-to-notion
+  changelog_uri: https://github.com/rieg-ec/md-to-notion/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.18
+signing_key: 
+specification_version: 4
+summary: Markdown to Notion converter.
+test_files: []