prosemirror 0.0.1 → 0.2.0

data/lib/prosemirror/schema.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  # A set of node and mark types, with rendering options.
+  #
+  #   schema = Prosemirror::Schema.tiptap(case: :camel).with(ImageBlock)
+  #   schema.parse(json).to_html
+  class Schema < Literal::Data
+    DEFAULT_URL_SCHEMES = %w[http https mailto tel].freeze
+
+    prop :nodes, _Array(_Class(NodeType)), &Coerce::FROZEN
+    prop :marks, _Array(_Class(MarkType)), &Coerce::FROZEN
+    prop :top_node, Symbol, default: :doc, &Coerce::SYMBOL
+    # `:snake` or `:camel`, for type names in JSON output.
+    prop :case, _Union(:snake, :camel), default: :snake, reader: false
+    # The URL schemes allowed in links and images. Relative URLs are always allowed.
+    prop :url_schemes, _Array(String), default: DEFAULT_URL_SCHEMES do |schemes|
+      schemes.map(&:downcase).freeze
+    end
+    # Called with each URL before it is checked, to rewrite it.
+    prop :resolve_url, _Callable?, reader: false
+    # Raise `InvalidDocument` instead of fixing invalid documents.
+    prop :strict, _Boolean, default: false, reader: false, predicate: :public
+    # Called with an `InvalidDocument` error for each problem fixed.
+    prop :on_invalid, _Callable?, reader: false
+
+    # Tiptap's StarterKit and common extensions.
+    def self.tiptap(**)
+      new(
+        nodes: [
+          Nodes::Doc, Nodes::Paragraph, Nodes::Text, Nodes::Heading, Nodes::Blockquote, Nodes::BulletList,
+          Nodes::OrderedList, Nodes::ListItem, Nodes::CodeBlock, Nodes::HardBreak, Nodes::HorizontalRule,
+          Nodes::Image, Nodes::Table, Nodes::TableRow, Nodes::TableHeader, Nodes::TableCell
+        ],
+        # In Tiptap's order, which sorts and nests marks.
+        marks: [
+          Marks::Link, Marks::Bold, Marks::Code, Marks::Italic, Marks::Strike, Marks::Underline,
+          Marks::Subscript, Marks::Superscript, Marks::Highlight
+        ],
+        **
+      )
+    end
+
+    # ProseMirror's prosemirror-schema-basic and prosemirror-schema-list.
+    def self.prosemirror(**)
+      new(
+        nodes: [
+          Nodes::Doc, Nodes::Paragraph, Nodes::Blockquote, Nodes::HorizontalRule, Nodes::Heading,
+          Nodes::Basic::CodeBlock, Nodes::Text, Nodes::Basic::Image, Nodes::HardBreak, Nodes::Basic::OrderedList,
+          Nodes::BulletList, Nodes::ListItem
+        ],
+        marks: [Marks::Basic::Link, Marks::Basic::Em, Marks::Basic::Strong, Marks::Basic::Code],
+        **
+      )
+    end
+
+    def after_initialize
+      @node_lookup = lookup(@nodes)
+      @mark_lookup = lookup(@marks)
+      @textblocks = @nodes.to_h { |type| [type, textblock_type?(type)] }
+      @content_matches = @nodes.to_h { |type| [type, ContentMatch.compile(type.content, self)] }
+      raise ArgumentError, "the schema has no #{@top_node} node type" unless node_type(@top_node)
+    end
+
+    # The start state of a node type's content expression.
+    def content_match(type)
+      @content_matches.fetch(type)
+    end
+
+    # The node types with this name or in this group, in schema order.
+    def node_types_named(name)
+      @nodes.select { |type| type.type_name == name || type.group.include?(name) }
+    end
+
+    # A node of this type, created empty and filled with the content it requires, or nil when its
+    # type, or one it requires, has required attributes.
+    def create_and_fill(type)
+      return nil if type.required_attrs?
+
+      fill = content_match(type).fill_before([], self, to_end: true)
+      content = fill&.map { |child| create_and_fill(child) }
+      return nil if content.nil? || content.include?(nil)
+
+      Node.new(type: type.type_name, attrs: type.default_attrs, content: content)
+    end
+
+    # A copy of the schema with other options.
+    def with_options(**)
+      self.class.new(**to_h, **)
+    end
+
+    # A copy of the schema with more types. A type replaces the type with the same name.
+    def with(*types)
+      nodes = types.select { |type| type.is_a?(Class) && type < NodeType }
+      marks = types.select { |type| type.is_a?(Class) && type < MarkType }
+      raise ArgumentError, "not a node or mark type" if nodes.size + marks.size != types.size
+
+      self.class.new(**to_h, nodes: merge_types(@nodes, nodes), marks: merge_types(@marks, marks))
+    end
+
+    # The node type for a name, alias, or camelCase name.
+    def node_type(name)
+      @node_lookup[Naming.snake(name).to_sym]
+    end
+
+    def mark_type(name)
+      @mark_lookup[Naming.snake(name).to_sym]
+    end
+
+    # Build a document from JSON, given as a Hash or a String.
+    def parse(json)
+      Document.new(JSONParser.new(self).parse(json), schema: self)
+    end
+
+    # Build a document from HTML, with the parse rules of the schema's types. Needs the `herb` gem.
+    def parse_html(html)
+      Document.new(HTMLParser.new(self).parse(html), schema: self)
+    end
+
+    # The type name as written in JSON.
+    def json_type_name(name)
+      (@case == :camel) ? Naming.camel(name) : name.to_s
+    end
+
+    # The set of marks with this mark added, in schema order, as ProseMirror's `Mark#addToSet`: a mark
+    # replaces the marks it excludes, and isn't added when a mark of the set excludes it.
+    def add_mark(mark, set)
+      type = mark_type(mark.type)
+      result = []
+      placed = false
+      set.each do |other|
+        return set if other == mark
+
+        other_type = mark_type(other.type)
+        next if type.excludes?(other_type)
+        return set if other_type.excludes?(type)
+
+        if !placed && mark_rank(other.type) > mark_rank(mark.type)
+          result << mark
+          placed = true
+        end
+        result << other
+      end
+      result << mark unless placed
+      result
+    end
+
+    # Whether a URL's scheme is allowed, or the URL is relative. Browsers ignore leading control characters
+    # and spaces, and tabs and newlines anywhere in a URL.
+    def allowed_url?(url)
+      return false unless url.is_a?(String)
+
+      normalized = url.delete("\t\n\r").sub(/\A[\x00-\x20]+/, "")
+      scheme = normalized[%r{\A([^/?#]*):}, 1]
+      return true if scheme.nil?
+
+      scheme.match?(/\A[a-z][a-z\d+.-]*\z/i) && @url_schemes.include?(scheme.downcase)
+    end
+
+    # The order of marks in a node. Marks of unknown types come last.
+    def mark_rank(name)
+      @marks.index(mark_type(name)) || @marks.size
+    end
+
+    # Whether nodes of this type contain inline content, like a paragraph.
+    def textblock?(type)
+      @textblocks.fetch(type, false)
+    end
+
+    # The URL after `resolve_url`, when its scheme is allowed. Otherwise nil, and the problem is reported.
+    def safe_url(url)
+      return nil unless url.is_a?(String)
+
+      resolved = @resolve_url ? @resolve_url.call(url) : url
+      return report("URL could not be resolved: #{url.inspect}") unless resolved.is_a?(String)
+      return report("URL scheme not allowed: #{resolved.inspect}") unless allowed_url?(resolved)
+
+      resolved.gsub("&", "&amp;")
+    end
+
+    # Raise in strict mode, otherwise call `on_invalid`.
+    def report(message, path: nil)
+      error = InvalidDocument.new(message, path: path)
+      raise error if @strict
+
+      @on_invalid&.call(error)
+      nil
+    end
+
+    # The document as JSON, as a Hash.
+    def serialize(node)
+      hash = {"type" => json_type_name(node.type)}
+      hash["text"] = node.text if node.text?
+      attrs = serialize_node_attrs(node)
+      hash["attrs"] = attrs unless attrs.empty?
+      hash["content"] = node.content.map { |child| serialize(child) } unless node.content.empty?
+      hash["marks"] = node.marks.map { |mark| serialize_mark(mark) } unless node.marks.empty?
+      hash
+    end
+
+    private
+
+    def lookup(types)
+      types.each_with_object({}) do |type, table|
+        [type.type_name, *type.aliases].each { |name| table[name] ||= type }
+        table[type.type_name] = type
+      end
+    end
+
+    def merge_types(types, additions)
+      additions.reduce(types) do |list, addition|
+        index = list.index { |type| type.type_name == addition.type_name }
+        index ? list.dup.tap { |copy| copy[index] = addition } : list + [addition]
+      end
+    end
+
+    def textblock_type?(type)
+      return false if type.leaf?
+
+      type.content.names.any? do |name|
+        name == :text || name == :inline || node_types_named(name).any?(&:inline?)
+      end
+    end
+
+    # Declared attributes with their JSON names, then the unknown ones, as they were.
+    def serialize_node_attrs(node)
+      type = node_type(node.type)
+      attrs = type ? type.serialize_attrs(node.attrs) : node.attrs.transform_keys(&:to_s)
+      attrs.merge(node.unknown_attrs)
+    end
+
+    def serialize_mark(mark)
+      hash = {"type" => json_type_name(mark.type)}
+      type = mark_type(mark.type)
+      attrs = type ? type.serialize_attrs(mark.attrs) : mark.attrs.transform_keys(&:to_s)
+      attrs = attrs.merge(mark.unknown_attrs)
+      hash["attrs"] = attrs unless attrs.empty?
+      hash
+    end
+  end
+end

data/lib/prosemirror/text_serializer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  # Extracts the text of a document, as ProseMirror's `textBetween` and Tiptap's `getText` do:
+  # textblocks and leaf blocks with text are separated by `block_separator`,
+  # and leaf nodes such as hard breaks are replaced by their `leaf_text`.
+  class TextSerializer
+    def initialize(schema, block_separator: "\n\n")
+      @schema = schema
+      @block_separator = block_separator
+    end
+
+    def call(root)
+      text = +""
+      first = true
+
+      root.descendants do |node|
+        node_type = @schema.node_type(node.type)
+        node_text = text_of(node, node_type)
+
+        if separated?(node_type, node_text)
+          text << @block_separator unless first
+          first = false
+        end
+        text << node_text
+      end
+
+      text
+    end
+
+    private
+
+    def text_of(node, node_type)
+      return node.text if node.text?
+      return "" unless node_type&.leaf?
+
+      node_type.text_for(node)
+    end
+
+    def separated?(node_type, node_text)
+      return false unless node_type&.block?
+
+      node_type.leaf? ? !node_text.empty? : @schema.textblock?(node_type)
+    end
+  end
+end

data/lib/prosemirror/type_definition.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  # Class-level declarations shared by node types and mark types.
+  module TypeDefinition
+    # The name of the type, as a snake_case Symbol. It defaults to the class name (`BulletList` → `:bullet_list`),
+    # and subclasses of a concrete type keep its name.
+    def type_name(name = nil)
+      return @type_name = Naming.snake(name).to_sym if name
+
+      @type_name ||= concrete_superclass&.type_name || derived_type_name
+    end
+
+    # Other names accepted on input for this type, such as `:strong` for `:bold`.
+    def aliases(*names)
+      return @aliases = names.map { |n| Naming.snake(n).to_sym } unless names.empty?
+
+      inherited_setting(:@aliases, [])
+    end
+
+    # Declare an attribute. Same as Literal's `prop`, with these options:
+    # - `json:` the attribute name in JSON, when it differs from the property name (`"textAlign"`);
+    # - `aliases:` other JSON names accepted on input (`["order"]`);
+    # - `parse_html:` a block reading the attribute from an HTML element, when importing HTML. By default,
+    #   the HTML attribute with the JSON name is read.
+    def prop(name, type, kind = :keyword, json: nil, aliases: [], parse_html: nil, **, &)
+      attribute_names[name] = {json: (json || name).to_s, aliases: aliases.map(&:to_s), parse_html:}.freeze
+      super(name, type, kind, **, &)
+    end
+
+    # Declare how to recognize this type in HTML. See ParseRule for the options. The block, if given, is the
+    # rule's `get_attrs`. A subclass that declares rules replaces the rules of its parent.
+    def parse_html(tag: nil, style: nil, **options, &get_attrs)
+      (@parse_rules ||= []) << ParseRule.new(type: self, tag:, style:, get_attrs:, **options)
+    end
+
+    def parse_rules
+      inherited_setting(:@parse_rules, [])
+    end
+
+    # The attributes read from an HTML element, by JSON name, without the missing ones.
+    def attrs_from_html(element)
+      attribute_names.each_value.with_object({}) do |names, attrs|
+        value = names[:parse_html] ? names[:parse_html].call(element) : element[names[:json]]
+        attrs[names[:json]] = value unless value.nil?
+      end
+    end
+
+    def attribute_names
+      @attribute_names ||= concrete_superclass ? concrete_superclass.attribute_names.dup : {}
+    end
+
+    # Build valid attributes from JSON attributes (a Hash with String or Symbol keys).
+    # Invalid values are converted when the meaning is clear, or replaced by their default.
+    # Returns nil when a required attribute is missing or invalid.
+    def build_attrs(given, report:)
+      given = given.is_a?(Hash) ? given.transform_keys(&:to_s) : {}
+
+      literal_properties.each_with_object({}) do |property, attrs|
+        json_name = attribute_names.dig(property.name, :json)
+        key = attribute_key(given, attribute_names.fetch(property.name))
+
+        if key
+          value = coerce_attribute(property, given[key])
+          next attrs[property.name] = value if property.type === value
+
+          report.call("invalid attribute #{json_name}: #{given[key].inspect}")
+        elsif !optional_attribute?(property)
+          report.call("missing attribute #{json_name}")
+        end
+        return nil unless optional_attribute?(property)
+
+        attrs[property.name] = default_attribute(property)
+      end
+    end
+
+    # Whether an attribute has no default, so that a node of this type can't be created empty.
+    def required_attrs?
+      literal_properties.any? { |property| !optional_attribute?(property) }
+    end
+
+    # The attributes of a node of this type created empty: the defaults.
+    def default_attrs
+      build_attrs({}, report: ->(_) {})
+    end
+
+    # The JSON attributes this type doesn't declare, with String keys, so that `to_h` gives them back.
+    def unknown_attrs(given)
+      return {} unless given.is_a?(Hash)
+
+      known = attribute_names.values.flat_map do |names|
+        [names[:json], *names[:aliases]].flat_map { |name| [name, Naming.snake(name), Naming.camel(name)] }
+      end
+      given.transform_keys(&:to_s).except(*known)
+    end
+
+    # Attributes as JSON, with their JSON names.
+    def serialize_attrs(attrs)
+      attrs.to_h { |name, value| [attribute_names.dig(name, :json) || name.to_s, value] }
+    end
+
+    def base_type?
+      false
+    end
+
+    private
+
+    def concrete_superclass
+      superclass unless superclass.base_type?
+    end
+
+    def derived_type_name
+      raise ArgumentError, "anonymous types need a type_name" if name.nil?
+
+      Naming.snake(name.split("::").last).to_sym
+    end
+
+    def inherited_setting(ivar, default)
+      return instance_variable_get(ivar) if instance_variable_defined?(ivar)
+      return default if superclass.base_type?
+
+      superclass.send(:inherited_setting, ivar, default)
+    end
+
+    def attribute_key(given, names)
+      [names[:json], *names[:aliases]].each do |name|
+        [name, Naming.snake(name), Naming.camel(name)].each do |candidate|
+          return candidate if given.key?(candidate)
+        end
+      end
+      nil
+    end
+
+    def coerce_attribute(property, value)
+      property.coercion ? property.coerce(value, context: self) : value
+    rescue
+      value
+    end
+
+    def optional_attribute?(property)
+      # Checks whether the Literal type accepts nil, so `.nil?` would be wrong here.
+      property.default? || property.type === nil # standard:disable Style/NilComparison
+    end
+
+    def default_attribute(property)
+      property.default? ? property.default_value(self) : nil
+    end
+  end
+end

data/lib/prosemirror/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Prosemirror
-  VERSION = "0.0.1"
+  VERSION = "0.2.0"
 end

data/lib/prosemirror.rb

@@ -1,8 +1,49 @@
 # frozen_string_literal: true
 
-require_relative "prosemirror/version"
+# Phlex 2.4.1 checks attribute values against Date without loading it. Remove once a release includes the fix:
+# https://github.com/yippee-fun/phlex/issues/974
+require "date"
+require "json"
+require "literal"
+require "phlex"
+require "zeitwerk"
 
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect(
+  "html" => "HTML", "html_parser" => "HTMLParser", "html_renderer" => "HTMLRenderer", "json_parser" => "JSONParser"
+)
+loader.setup
+
+# Render ProseMirror and Tiptap documents.
 module Prosemirror
   class Error < StandardError; end
-  # Your code goes here...
+
+  # Raised in strict mode, and passed to `on_invalid`, when a document doesn't match its schema.
+  class InvalidDocument < Error
+    attr_reader :path
+
+    def initialize(message, path: nil)
+      @path = path
+      super(path ? "#{path}: #{message}" : message)
+    end
+  end
+
+  class << self
+    attr_writer :schema
+
+    # The schema used when none is given. Defaults to `Schema.tiptap`.
+    def schema
+      @schema ||= Schema.tiptap
+    end
+
+    # Build a document from ProseMirror JSON, given as a Hash or a String.
+    def parse(json, schema: self.schema)
+      schema.parse(json)
+    end
+
+    # Build a document from HTML, with the schema's parse rules. Needs the `herb` gem.
+    def from_html(html, schema: self.schema)
+      schema.parse_html(html)
+    end
+  end
 end

metadata

@@ -1,38 +1,136 @@
 --- !ruby/object:Gem::Specification
 name: prosemirror
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Hans Lemuet
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-03 00:00:00.000000000 Z
-dependencies: []
-description:
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: literal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: phlex
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: Render ProseMirror and Tiptap JSON documents to safe HTML or plain text,
+  with typed attributes and custom node types.
 email:
 - hans@etamin.studio
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rubocop.yml"
 - CHANGELOG.md
-- Gemfile
+- COOKBOOK.md
+- LICENSE.txt
 - README.md
-- Rakefile
+- ROADMAP.md
+- TYPES.md
 - lib/prosemirror.rb
+- lib/prosemirror/coerce.rb
+- lib/prosemirror/content_expression.rb
+- lib/prosemirror/content_match.rb
+- lib/prosemirror/document.rb
+- lib/prosemirror/html/builder.rb
+- lib/prosemirror/html/element.rb
+- lib/prosemirror/html/entities.rb
+- lib/prosemirror/html/entities.txt
+- lib/prosemirror/html/selector.rb
+- lib/prosemirror/html/splitter.rb
+- lib/prosemirror/html/text.rb
+- lib/prosemirror/html_parser.rb
+- lib/prosemirror/html_renderer.rb
+- lib/prosemirror/json_parser.rb
+- lib/prosemirror/mark.rb
+- lib/prosemirror/mark_type.rb
+- lib/prosemirror/marks/basic/code.rb
+- lib/prosemirror/marks/basic/em.rb
+- lib/prosemirror/marks/basic/link.rb
+- lib/prosemirror/marks/basic/strong.rb
+- lib/prosemirror/marks/bold.rb
+- lib/prosemirror/marks/code.rb
+- lib/prosemirror/marks/highlight.rb
+- lib/prosemirror/marks/italic.rb
+- lib/prosemirror/marks/link.rb
+- lib/prosemirror/marks/strike.rb
+- lib/prosemirror/marks/subscript.rb
+- lib/prosemirror/marks/superscript.rb
+- lib/prosemirror/marks/underline.rb
+- lib/prosemirror/naming.rb
+- lib/prosemirror/node.rb
+- lib/prosemirror/node_type.rb
+- lib/prosemirror/nodes/basic/code_block.rb
+- lib/prosemirror/nodes/basic/image.rb
+- lib/prosemirror/nodes/basic/ordered_list.rb
+- lib/prosemirror/nodes/blockquote.rb
+- lib/prosemirror/nodes/bullet_list.rb
+- lib/prosemirror/nodes/code_block.rb
+- lib/prosemirror/nodes/doc.rb
+- lib/prosemirror/nodes/hard_break.rb
+- lib/prosemirror/nodes/heading.rb
+- lib/prosemirror/nodes/horizontal_rule.rb
+- lib/prosemirror/nodes/image.rb
+- lib/prosemirror/nodes/list_item.rb
+- lib/prosemirror/nodes/ordered_list.rb
+- lib/prosemirror/nodes/paragraph.rb
+- lib/prosemirror/nodes/table.rb
+- lib/prosemirror/nodes/table_cell.rb
+- lib/prosemirror/nodes/table_header.rb
+- lib/prosemirror/nodes/table_row.rb
+- lib/prosemirror/nodes/text.rb
+- lib/prosemirror/parse_rule.rb
+- lib/prosemirror/rendering.rb
+- lib/prosemirror/schema.rb
+- lib/prosemirror/text_serializer.rb
+- lib/prosemirror/type_definition.rb
 - lib/prosemirror/version.rb
-- prosemirror.gemspec
 - sig/prosemirror.rbs
 homepage: https://github.com/etaminstudio/prosemirror
-licenses: []
+licenses:
+- MIT
 metadata:
-  homepage_uri: https://github.com/etaminstudio/prosemirror
   source_code_uri: https://github.com/etaminstudio/prosemirror
   changelog_uri: https://github.com/etaminstudio/prosemirror/blob/main/CHANGELOG.md
-post_install_message:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -40,15 +138,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key:
+rubygems_version: 4.0.20
 specification_version: 4
-summary: Convert HTML to ProseMirror JSON and back.
+summary: Render ProseMirror and Tiptap documents to HTML and text.
 test_files: []

data/.rubocop.yml

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

data/Gemfile

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-source "https://rubygems.org"
-
-# Specify your gem's dependencies in prosemirror.gemspec
-gemspec
-
-gem "rake", "~> 13.0"
-
-gem "minitest", "~> 5.0"
-
-gem "rubocop", "~> 1.21"