Merge branch 'move-rb-ipynbdiff-to-vendor' into 'master'

Moves ipynbdiff to vendor

See merge request !90696

.gitlab/ci/rules.gitlab-ci.yml

@@ -1495,6 +1495,12 @@
       changes: ["vendor/gems/mail-smtp_pool/**/*"]
     - <<: *if-merge-request-labels-run-all-rspec
 
+.vendor:rules:ipynbdiff:
+  rules:
+    - <<: *if-merge-request
+      changes: ["vendor/gems/ipynbdiff/**/*"]
+    - <<: *if-merge-request-labels-run-all-rspec
+
 ##################
 # Releases rules #
 ##################

.gitlab/ci/vendored-gems.gitlab-ci.yml

@@ -5,3 +5,10 @@ vendor mail-smtp_pool:
   trigger:
     include: vendor/gems/mail-smtp_pool/.gitlab-ci.yml
     strategy: depend
+vendor ipynbdiff:
+  extends:
+    - .vendor:rules:ipynbdiff
+  needs: []
+  trigger:
+    include: vendor/gems/ipynbdiff/.gitlab-ci.yml
+    strategy: depend

Gemfile

@@ -546,6 +546,6 @@ gem 'ipaddress', '~> 0.8.3'
 
 gem 'parslet', '~> 1.8'
 
-gem 'ipynbdiff', '0.4.7'
+gem 'ipynbdiff', path: 'vendor/gems/ipynbdiff'
 
 gem 'ed25519', '~> 1.3.0'

Gemfile.lock

+PATH
+  remote: vendor/gems/ipynbdiff
+  specs:
+    ipynbdiff (0.4.7)
+      diffy (~> 3.3)
+      json (~> 2.5, >= 2.5.1)
+
 PATH
   remote: vendor/gems/mail-smtp_pool
   specs:
@@ -667,9 +674,6 @@ GEM
     invisible_captcha (1.1.0)
       rails (>= 4.2)
     ipaddress (0.8.3)
-    ipynbdiff (0.4.7)
-      diffy (~> 3.3)
-      json (~> 2.5, >= 2.5.1)
     jaeger-client (1.1.0)
       opentracing (~> 0.3)
       thrift
@@ -1575,7 +1579,7 @@ DEPENDENCIES
   icalendar
   invisible_captcha (~> 1.1.0)
   ipaddress (~> 0.8.3)
-  ipynbdiff (= 0.4.7)
+  ipynbdiff!
   jira-ruby (~> 2.1.4)
   js_regex (~> 3.7)
   json (~> 2.5.1)

vendor/gems/ipynbdiff/.gitignore

+*.gem
+.bundle

vendor/gems/ipynbdiff/.gitlab-ci.yml

+# You can override the included template(s) by including variable overrides
+# SAST customization: https://docs.gitlab.com/ee/user/application_security/sast/#customizing-the-sast-settings
+# Secret Detection customization: https://docs.gitlab.com/ee/user/application_security/secret_detection/#customizing-settings
+# Dependency Scanning customization: https://docs.gitlab.com/ee/user/application_security/dependency_scanning/#customizing-the-dependency-scanning-settings
+# Note that environment variables can be set in several places
+# See https://docs.gitlab.com/ee/ci/variables/#cicd-variable-precedence
+workflow:
+  rules:
+    - if: $CI_MERGE_REQUEST_ID
+
+.rspec:
+  cache:
+    key: ipynbdiff
+    paths:
+      - vendor/gems/ipynbdiff/vendor/ruby
+  before_script:
+    - cd vendor/gems/ipynbdiff
+    - ruby -v                                   # Print out ruby version for debugging
+    - gem install bundler --no-document         # Bundler is not installed with the image
+    - bundle config set --local path 'vendor'   # Install dependencies into ./vendor/ruby
+    - bundle config set with 'development'
+    - bundle install -j $(nproc)
+  script:
+    - bundle exec rspec
+
+rspec-2.7:
+  image: "ruby:2.7"
+  extends: .rspec
+
+rspec-3.0:
+  image: "ruby:3.0"
+  extends: .rspec

vendor/gems/ipynbdiff/Gemfile

+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

vendor/gems/ipynbdiff/Gemfile.lock

+PATH
+  remote: .
+  specs:
+    ipynbdiff (0.4.7)
+      diffy (~> 3.3)
+      json (~> 2.5, >= 2.5.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    binding_ninja (0.2.3)
+    coderay (1.1.3)
+    diff-lcs (1.5.0)
+    diffy (3.4.2)
+    json (2.6.2)
+    method_source (1.0.0)
+    parser (3.1.2.0)
+      ast (~> 2.4.1)
+    proc_to_ast (0.1.0)
+      coderay
+      parser
+      unparser
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rake (13.0.6)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-parameterized (0.5.1)
+      binding_ninja (>= 0.2.3)
+      parser
+      proc_to_ast
+      rspec (>= 2.13, < 4)
+      unparser
+    rspec-support (3.11.0)
+    unparser (0.6.5)
+      diff-lcs (~> 1.3)
+      parser (>= 3.1.0)
+
+PLATFORMS
+  x86_64-darwin-20
+  x86_64-linux
+
+DEPENDENCIES
+  bundler (~> 2.2)
+  ipynbdiff!
+  pry (~> 0.14)
+  rake (~> 13.0)
+  rspec (~> 3.10)
+  rspec-parameterized (~> 0.5.1)
+
+BUNDLED WITH
+   2.3.16

vendor/gems/ipynbdiff/LICENSE

+The MIT License (MIT)
+
+Copyright (c) 2016-2021 GitLab B.V.
+
+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.

vendor/gems/ipynbdiff/README.md

+# IpynbDiff: Better diff for Jupyter Notebooks
+
+This is a simple diff tool that cleans up Jupyter notebooks, transforming each [notebook](example/1/from.ipynb)
+into a [readable markdown file](example/1/from_html.md), keeping the output of cells, and running the
+diff after. Markdowns are generated using an opinionated Jupyter to Markdown conversion. This means
+that the entire file is readable on the diff.
+
+The result are diffs that are much easier to read:
+
+| Diff                                | IpynbDiff                                             |
+| ----------------------------------- | ----------------------------------------------------- |
+| [Diff text](example/diff.txt)       | [IpynbDiff text](example/ipynbdiff_percent.txt)       |
+| ![Diff image](example/img/diff.png) | ![IpynbDiff image](example/img/ipynbdiff_percent.png) |
+
+This started as a port of [ipynbdiff](https://gitlab.com/gitlab-org/incubation-engineering/mlops/poc/ipynbdiff),
+but now has extended functionality although not working as git driver.
+
+## Usage
+
+### Generating diffs
+
+```ruby
+IpynbDiff.diff(from_path, to_path, options)
+```
+
+Options:
+
+```ruby
+@default_transform_options = {
+  preprocess_input: true, # Whether the input should be transformed
+  write_output_to: nil, # Pass a path to save the output to a file
+  format: :text, # These are the formats Diffy accepts https://github.com/samg/diffy
+  sources_are_files: false, # Weather to use the from/to as string or path to a file
+  raise_if_invalid_notebook: false, # Raises an error if the notebooks are invalid, otherwise returns nil
+  transform_options: @default_transform_options, # See below for transform options
+  diff_opts: {
+    include_diff_info: false # These are passed to Diffy https://github.com/samg/diffy
+  }
+}
+```
+
+### Transforming the notebooks
+
+It might be necessary to have the transformed files in addition to the diff.
+
+```ruby
+IpynbDiff.transform(notebook, options)
+```
+
+Options:
+
+```ruby
+@default_transform_options = {
+    include_frontmatter: false, # Whether to include or not the notebook metadata (kernel, language, etc)
+}
+```

vendor/gems/ipynbdiff/ipynbdiff.gemspec

+# frozen_string_literal: true
+
+lib = File.expand_path('lib/..', __dir__)
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
+
+require 'lib/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'ipynbdiff'
+  s.version     = IpynbDiff::VERSION
+  s.summary     = 'Human Readable diffs for Jupyter Notebooks'
+  s.description = 'Better diff for Jupyter Notebooks by first preprocessing them and removing clutter'
+  s.authors     = ['Eduardo Bonet']
+  s.email       = 'ebonet@gitlab.com'
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  s.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec|example)/}) }
+  end
+  s.homepage =
+    'https://gitlab.com/gitlab-org/incubation-engineering/mlops/rb-ipynbdiff'
+  s.license       = 'MIT'
+
+  s.require_paths = ['lib']
+
+  s.add_runtime_dependency 'diffy', '~> 3.3'
+  s.add_runtime_dependency 'json', '~> 2.5', '>= 2.5.1'
+
+  s.add_development_dependency 'bundler', '~> 2.2'
+  s.add_development_dependency 'pry', '~> 0.14'
+  s.add_development_dependency 'rake', '~> 13.0'
+  s.add_development_dependency 'rspec', '~> 3.10'
+  s.add_development_dependency 'rspec-parameterized', '~> 0.5.1'
+end

vendor/gems/ipynbdiff/lib/diff.rb

+# frozen_string_literal: true
+
+# Custom differ for Jupyter Notebooks
+module IpynbDiff
+  require 'delegate'
+
+  # The result of a diff object
+  class Diff < SimpleDelegator
+    require 'diffy'
+
+    attr_reader :from, :to
+
+    def initialize(from, to, diffy_opts)
+      super(Diffy::Diff.new(from.as_text, to.as_text, **diffy_opts))
+
+      @from = from
+      @to = to
+    end
+  end
+end

vendor/gems/ipynbdiff/lib/ipynb_symbol_map.rb

+# frozen_string_literal: true
+
+module IpynbDiff
+  class InvalidTokenError < StandardError
+  end
+
+  # Creates a symbol map for a ipynb file (JSON format)
+  class IpynbSymbolMap
+    class << self
+      def parse(notebook, objects_to_ignore = [])
+        IpynbSymbolMap.new(notebook, objects_to_ignore).parse('')
+      end
+    end
+
+    attr_reader :current_line, :char_idx, :results
+
+    WHITESPACE_CHARS = ["\t", "\r", ' ', "\n"].freeze
+
+    VALUE_STOPPERS = [',', '[', ']', '{', '}', *WHITESPACE_CHARS].freeze
+
+    def initialize(notebook, objects_to_ignore = [])
+      @chars = notebook.chars
+      @current_line = 0
+      @char_idx = 0
+      @results = {}
+      @objects_to_ignore = objects_to_ignore
+    end
+
+    def parse(prefix = '.')
+      raise_if_file_ended
+
+      skip_whitespaces
+
+      if (c = current_char) == '"'
+        parse_string
+      elsif c == '['
+        parse_array(prefix)
+      elsif c == '{'
+        parse_object(prefix)
+      else
+        parse_value
+      end
+
+      results
+    end
+
+    def parse_array(prefix)
+      # [1, 2, {"some": "object"}, [1]]
+
+      i = 0
+
+      current_should_be '['
+
+      loop do
+        raise_if_file_ended
+
+        break if skip_beginning(']')
+
+        new_prefix = "#{prefix}.#{i}"
+
+        add_result(new_prefix, current_line)
+
+        parse(new_prefix)
+
+        i += 1
+      end
+    end
+
+    def parse_object(prefix)
+      # {"name":"value", "another_name": [1, 2, 3]}
+
+      current_should_be '{'
+
+      loop do
+        raise_if_file_ended
+
+        break if skip_beginning('}')
+
+        prop_name = parse_string(return_value: true)
+
+        next_and_skip_whitespaces
+
+        current_should_be ':'
+
+        next_and_skip_whitespaces
+
+        if @objects_to_ignore.include? prop_name
+          skip
+        else
+          new_prefix = "#{prefix}.#{prop_name}"
+
+          add_result(new_prefix, current_line)
+
+          parse(new_prefix)
+        end
+      end
+    end
+
+    def parse_string(return_value: false)
+      current_should_be '"'
+      init_idx = @char_idx
+
+      loop do
+        increment_char_index
+
+        raise_if_file_ended
+
+        if current_char == '"' && !prev_backslash?
+          init_idx += 1
+          break
+        end
+      end
+
+      @chars[init_idx...@char_idx].join if return_value
+    end
+
+    def add_result(key, line_number)
+      @results[key] = line_number
+    end
+
+    def parse_value
+      increment_char_index until raise_if_file_ended || VALUE_STOPPERS.include?(current_char)
+    end
+
+    def skip_whitespaces
+      while WHITESPACE_CHARS.include?(current_char)
+        raise_if_file_ended
+        check_for_new_line
+        increment_char_index
+      end
+    end
+
+    def increment_char_index
+      @char_idx += 1
+    end
+
+    def next_and_skip_whitespaces
+      increment_char_index
+      skip_whitespaces
+    end
+
+    def current_char
+      raise_if_file_ended
+
+      @chars[@char_idx]
+    end
+
+    def prev_backslash?
+      @chars[@char_idx - 1] == '\\' && @chars[@char_idx - 2] != '\\'
+    end
+
+    def current_should_be(another_char)
+      raise InvalidTokenError unless current_char == another_char
+    end
+
+    def check_for_new_line
+      @current_line += 1 if current_char == "\n"
+    end
+
+    def raise_if_file_ended
+      @char_idx >= @chars.size && raise(InvalidTokenError)
+    end
+
+    def skip
+      raise_if_file_ended
+
+      skip_whitespaces
+
+      if (c = current_char) == '"'
+        parse_string
+      elsif c == '['
+        skip_array
+      elsif c == '{'
+        skip_object
+      else
+        parse_value
+      end
+    end
+
+    def skip_array
+      loop do
+        raise_if_file_ended
+
+        break if skip_beginning(']')
+
+        skip
+      end
+    end
+
+    def skip_object
+      loop do
+        raise_if_file_ended
+
+        break if skip_beginning('}')
+
+        parse_string
+
+        next_and_skip_whitespaces
+
+        current_should_be ':'
+
+        next_and_skip_whitespaces
+
+        skip
+      end
+    end
+
+    def skip_beginning(closing_char)
+      check_for_new_line
+
+      next_and_skip_whitespaces
+
+      return true if current_char == closing_char
+
+      next_and_skip_whitespaces if current_char == ','
+    end
+  end
+end

vendor/gems/ipynbdiff/lib/ipynbdiff.rb

+# frozen_string_literal: true
+
+# Human Readable Jupyter Diffs
+module IpynbDiff
+  require 'transformer'
+  require 'diff'
+
+  def self.diff(from, to, raise_if_invalid_nb: false, include_frontmatter: false, hide_images: false, diffy_opts: {})
+    transformer = Transformer.new(include_frontmatter: include_frontmatter, hide_images: hide_images)
+
+    Diff.new(transformer.transform(from), transformer.transform(to), diffy_opts)
+  rescue InvalidNotebookError
+    raise if raise_if_invalid_nb
+  end
+
+  def self.transform(notebook, raise_errors: false, include_frontmatter: true, hide_images: false)
+    return unless notebook
+
+    Transformer.new(include_frontmatter: include_frontmatter, hide_images: hide_images).transform(notebook).as_text
+  rescue InvalidNotebookError
+    raise if raise_errors
+  end
+end

vendor/gems/ipynbdiff/lib/output_transformer.rb

+# frozen_string_literal: true
+
+module IpynbDiff
+  # Transforms Jupyter output data into markdown
+  class OutputTransformer
+    require 'symbolized_markdown_helper'
+    include SymbolizedMarkdownHelper
+
+    HIDDEN_IMAGE_OUTPUT = '    [Hidden Image Output]'
+
+    ORDERED_KEYS = {
+      'execute_result' => %w[image/png image/svg+xml image/jpeg text/markdown text/latex text/plain],
+      'display_data' => %w[image/png image/svg+xml image/jpeg text/markdown text/latex],
+      'stream' => %w[text]
+    }.freeze
+
+    def initialize(hide_images: false)
+      @hide_images = hide_images
+    end
+
+    def transform(output, symbol)
+      transformed = case (output_type = output['output_type'])
+                    when 'error'
+                      transform_error(output['traceback'], symbol / 'traceback')
+                    when 'execute_result', 'display_data'
+                      transform_non_error(ORDERED_KEYS[output_type], output['data'], symbol / 'data')
+                    when 'stream'
+                      transform_element('text', output['text'], symbol)
+                    end
+
+      transformed ? decorate_output(transformed, output, symbol) : []
+    end
+
+    def decorate_output(output_rows, output, symbol)
+      [
+        _,
+        _(symbol, %(%%%% Output: #{output['output_type']})),
+        _,
+        *output_rows
+      ]
+    end
+
+    def transform_error(traceback, symbol)
+      traceback.map.with_index do |t, idx|
+        t.split("\n").map do |l|
+          _(symbol / idx, l.gsub(/\[[0-9][0-9;]*m/, '').sub("\u001B", '    ').gsub(/\u001B/, '').rstrip)
+        end
+      end
+    end
+
+    def transform_non_error(accepted_keys, elements, symbol)
+      accepted_keys.filter { |key| elements.key?(key) }.map do |key|
+        transform_element(key, elements[key], symbol)
+      end
+    end
+
+    def transform_element(output_type, output_element, symbol_prefix)
+      new_symbol = symbol_prefix / output_type
+      case output_type
+      when 'image/png', 'image/jpeg'
+        transform_image(output_type + ';base64', output_element, new_symbol)
+      when 'image/svg+xml'
+        transform_image(output_type + ';utf8', output_element, new_symbol)
+      when 'text/markdown', 'text/latex', 'text/plain', 'text'
+        transform_text(output_element, new_symbol)
+      end
+    end
+
+    def transform_image(image_type, image_content, symbol)
+      return _(nil, HIDDEN_IMAGE_OUTPUT) if @hide_images
+
+      lines = image_content.is_a?(Array) ? image_content : [image_content]
+
+      single_line = lines.map(&:strip).join.gsub(/\s+/, ' ')
+
+      _(symbol, "    ![](data:#{image_type},#{single_line})")
+    end
+
+    def transform_text(text_content, symbol)
+      symbolize_array(symbol, text_content) { |l| "    #{l.rstrip}" }
+    end
+  end
+end

vendor/gems/ipynbdiff/lib/symbolized_markdown_helper.rb

+# frozen_string_literal: true
+
+module IpynbDiff
+  # Helper functions
+  module SymbolizedMarkdownHelper
+
+    def _(symbol = nil, content = '')
+      { symbol: symbol, content: content }
+    end
+
+    def symbolize_array(symbol, content, &block)
+      if content.is_a?(Array)
+        content.map.with_index { |l, idx| _(symbol / idx, block.call(l)) }
+      else
+        _(symbol, content)
+      end
+    end
+  end
+
+  # Simple wrapper for a string
+  class JsonSymbol < String
+    def /(other)
+      JsonSymbol.new((other.is_a?(Array) ? [self, *other] : [self, other]).join('.'))
+    end
+  end
+end

vendor/gems/ipynbdiff/lib/transformed_notebook.rb

+# frozen_string_literal: true
+
+module IpynbDiff
+  # Notebook that was transformed into md, including location of source cells
+  class TransformedNotebook
+    attr_reader :blocks
+
+    def as_text
+      @blocks.map { |b| b[:content] }.join("\n")
+    end
+
+    private
+
+    def initialize(lines = [], symbol_map = {})
+      @blocks = lines.map do |line|
+        { content: line[:content], source_symbol: (symbol = line[:symbol]), source_line: symbol && symbol_map[symbol] }
+      end
+    end
+  end
+end

vendor/gems/ipynbdiff/lib/transformer.rb

+# frozen_string_literal: true
+
+module IpynbDiff
+  class InvalidNotebookError < StandardError
+  end
+
+  # Returns a markdown version of the Jupyter Notebook
+  class Transformer
+    require 'json'
+    require 'yaml'
+    require 'output_transformer'
+    require 'symbolized_markdown_helper'
+    require 'ipynb_symbol_map'
+    require 'transformed_notebook'
+    include SymbolizedMarkdownHelper
+
+    @include_frontmatter = true
+    @objects_to_ignore = ['application/javascript', 'application/vnd.holoviews_load.v0+json']
+
+    def initialize(include_frontmatter: true, hide_images: false)
+      @include_frontmatter = include_frontmatter
+      @hide_images = hide_images
+      @output_transformer = OutputTransformer.new(hide_images: hide_images)
+    end
+
+    def validate_notebook(notebook)
+      notebook_json = JSON.parse(notebook)
+
+      return notebook_json if notebook_json.key?('cells')
+
+      raise InvalidNotebookError
+    rescue JSON::ParserError
+      raise InvalidNotebookError
+    end
+
+    def transform(notebook)
+      return TransformedNotebook.new unless notebook
+
+      notebook_json = validate_notebook(notebook)
+      transformed = transform_document(notebook_json)
+      symbol_map = IpynbSymbolMap.parse(notebook)
+
+      TransformedNotebook.new(transformed, symbol_map)
+    end
+
+    def transform_document(notebook)
+      symbol = JsonSymbol.new('.cells')
+
+      transformed_blocks = notebook['cells'].map.with_index do |cell, idx|
+        decorate_cell(transform_cell(cell, notebook, symbol / idx), cell, symbol / idx)
+      end
+
+      transformed_blocks.prepend(transform_metadata(notebook)) if @include_frontmatter
+      transformed_blocks.flatten
+    end
+
+    def decorate_cell(rows, cell, symbol)
+      tags = cell['metadata']&.fetch('tags', [])
+      type = cell['cell_type'] || 'raw'
+
+      [
+        _(symbol, %(%% Cell type:#{type} id:#{cell['id']} tags:#{tags&.join(',')})),
+        _,
+        rows,
+        _
+      ]
+    end
+
+    def transform_cell(cell, notebook, symbol)
+      cell['cell_type'] == 'code' ? transform_code_cell(cell, notebook, symbol) : transform_text_cell(cell, symbol)
+    end
+
+    def transform_code_cell(cell, notebook, symbol)
+      [
+        _(symbol / 'source', %(``` #{notebook.dig('metadata', 'kernelspec', 'language') || ''})),
+        symbolize_array(symbol / 'source', cell['source'], &:rstrip),
+        _(nil, '```'),
+        cell['outputs'].map.with_index do |output, idx|
+          @output_transformer.transform(output, symbol / ['outputs', idx])
+        end
+      ]
+    end
+
+    def transform_text_cell(cell, symbol)
+      symbolize_array(symbol / 'source', cell['source'], &:rstrip)
+    end
+
+    def transform_metadata(notebook_json)
+      as_yaml = {
+        'jupyter' => {
+          'kernelspec' => notebook_json['metadata']['kernelspec'],
+          'language_info' => notebook_json['metadata']['language_info'],
+          'nbformat' => notebook_json['nbformat'],
+          'nbformat_minor' => notebook_json['nbformat_minor']
+        }
+      }.to_yaml
+
+      as_yaml.split("\n").map { |l| _(nil, l) }.append(_(nil, '---'), _)
+    end
+  end
+end

vendor/gems/ipynbdiff/lib/version.rb

+# frozen_string_literal: true
+
+module IpynbDiff
+  VERSION = '0.4.7'
+end

vendor/gems/ipynbdiff/spec/ipynb_symbol_map_spec.rb

+# frozen_string_literal: true
+
+require 'rspec'
+require 'json'
+require 'rspec-parameterized'
+require 'ipynb_symbol_map'
+
+describe IpynbDiff::IpynbSymbolMap do
+  def res(*cases)
+    cases&.to_h || []
+  end
+
+  describe '#parse_string' do
+    using RSpec::Parameterized::TableSyntax
+
+    let(:mapper) { IpynbDiff::IpynbSymbolMap.new(input) }
+
+    where(:input, :result) do
+      # Empty string
+      '""' | ''
+      # Some string with quotes
+      '"he\nll\"o"' | 'he\nll\"o'
+    end
+
+    with_them do
+      it { expect(mapper.parse_string(return_value: true)).to eq(result) }
+      it { expect(mapper.parse_string).to be_nil }
+      it { expect(mapper.results).to be_empty }
+    end
+
+    it 'raises if invalid string' do
+      mapper = IpynbDiff::IpynbSymbolMap.new('"')
+
+      expect { mapper.parse_string }.to raise_error(IpynbDiff::InvalidTokenError)
+    end
+
+  end
+
+  describe '#parse_object' do
+    using RSpec::Parameterized::TableSyntax
+
+    let(:mapper) { IpynbDiff::IpynbSymbolMap.new(notebook, objects_to_ignore) }
+
+    before do
+      mapper.parse_object('')
+    end
+
+    where(:notebook, :objects_to_ignore, :result) do
+      # Empty object
+      '{   }' | [] | res
+      # Object with string
+      '{   "hello"  : "world"   }' | [] | res(['.hello', 0])
+      # Object with boolean
+      '{   "hello"  : true   }' | [] | res(['.hello', 0])
+      # Object with integer
+      '{   "hello"  : 1   }' | [] | res(['.hello', 0])
+      # Object with 2 properties in the same line
+      '{   "hello"  : "world" , "my" : "bad"   }' | [] | res(['.hello', 0], ['.my', 0])
+      # Object with 2 properties in the different lines line
+      "{   \"hello\"  : \"world\" , \n \n \"my\" : \"bad\"   }" | [] | res(['.hello', 0], ['.my', 2])
+      # Object with 2 properties, but one is ignored
+      "{   \"hello\"  : \"world\" , \n \n \"my\" : \"bad\"   }" | ['hello'] | res(['.my', 2])
+    end
+
+    with_them do
+      it { expect(mapper.results).to include(result) }
+    end
+  end
+
+  describe '#parse_array' do
+    using RSpec::Parameterized::TableSyntax
+
+    where(:notebook, :result) do
+      # Empty Array
+      '[]' | res
+      # Array with string value
+      '["a"]' | res(['.0', 0])
+      # Array with boolean
+      '[  true  ]' | res(['.0', 0])
+      # Array with integer
+      '[  1 ]' | res(['.0', 0])
+      # Two values on the same line
+      '["a", "b"]' | res(['.0', 0], ['.1', 0])
+      # With line breaks'
+      "[\n  \"a\"  \n , \n \"b\"  ]" | res(['.0', 1], ['.1', 3])
+    end
+
+    let(:mapper) { IpynbDiff::IpynbSymbolMap.new(notebook) }
+
+    before do
+      mapper.parse_array('')
+    end
+
+    with_them do
+      it { expect(mapper.results).to match_array(result) }
+    end
+  end
+
+  describe '#skip_object' do
+    subject { IpynbDiff::IpynbSymbolMap.parse(JSON.pretty_generate(source)) }
+  end
+
+  describe '#parse' do
+
+    let(:objects_to_ignore) { [] }
+
+    subject { IpynbDiff::IpynbSymbolMap.parse(JSON.pretty_generate(source), objects_to_ignore) }
+
+    context 'Empty object' do
+      let(:source) { {} }
+
+      it { is_expected.to be_empty }
+    end
+
+    context 'Object with inner object and number' do
+      let(:source) { { obj1: { obj2: 1 } } }
+
+      it { is_expected.to match_array(res(['.obj1', 1], ['.obj1.obj2', 2])) }
+    end
+
+    context 'Object with inner object and number, string and array with object' do
+      let(:source) { { obj1: { obj2: [123, 2, true], obj3: "hel\nlo", obj4: true, obj5: 123, obj6: 'a' } } }
+
+      it do
+        is_expected.to match_array(
+          res(['.obj1', 1],
+              ['.obj1.obj2', 2],
+              ['.obj1.obj2.0', 3],
+              ['.obj1.obj2.1', 4],
+              ['.obj1.obj2.2', 5],
+              ['.obj1.obj3', 7],
+              ['.obj1.obj4', 8],
+              ['.obj1.obj5', 9],
+              ['.obj1.obj6', 10])
+        )
+      end
+    end
+
+    context 'When index is exceeded because of failure' do
+      it 'raises an exception' do
+        source = '{"\\a": "a\""}'
+
+        mapper = IpynbDiff::IpynbSymbolMap.new(source)
+
+        expect(mapper).to receive(:prev_backslash?).at_least(1).time.and_return(false)
+
+        expect { mapper.parse('') }.to raise_error(IpynbDiff::InvalidTokenError)
+      end
+    end
+
+    context 'Object with inner object and number, string and array with object' do
+      let(:source) { { obj1: { obj2: [123, 2, true], obj3: "hel\nlo", obj4: true, obj5: 123, obj6: { obj7: 'a' } } } }
+      let(:objects_to_ignore) { %w(obj2 obj6) }
+      it do
+        is_expected.to match_array(
+                         res(['.obj1', 1],
+                             ['.obj1.obj3', 7],
+                             ['.obj1.obj4', 8],
+                             ['.obj1.obj5', 9],
+                       )
+                       )
+      end
+    end
+  end
+end