ipynbdiff 0.3.8 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbeaad80969c974720e75336301dc02822fbf183b278d8e5ddd5dd18c65ddde1
-  data.tar.gz: c186fa7fac873dff429cf3fd24c4a5cb61901670270850fd3d623c363db21182
+  metadata.gz: dd4b3e7e96694361ee62a498007e9bda9165b47b2ef9a31b41322cf8cdd8781f
+  data.tar.gz: 1680189fc74e0b8e8909d671ce3b77abff51e8ccd0d4304cf088b43a3254a311
 SHA512:
-  metadata.gz: 23e6a0c192d671fdcb394334a89d40eef9a58e39d934d1138e0ba37943c928d035d2f471e868b2af3d7f24a02f77d927b1e72d8cd3dd8df1f6ef9616796a8ab0
-  data.tar.gz: 9632766d4dd4e6e57775d59d7a14d01fb664156bd3c41b1af894481f4bf33f807b54ebad0f664184f606c37a6b8f818326e7238e320ba06135f192753c659f20
+  metadata.gz: fd5cf9cad8f9c20db2051a8b66a998a8174d066ca71e8a45c7bb5e1e274478919ed44fee1a38b296b7a5c679df686da96e402c750d51df0a68db7328260181a7
+  data.tar.gz: a7ba937ec71caa7a5a5a31cd47ea047f9b2518bd6c7f8a61f120b62deb7d3e6a07dc8ba76e8719b725dab8b6f78cb9b86771273a5a46d9798d744c2bc25d00bf

data/.VERSION.TMPL

@@ -0,0 +1,5 @@
+# lib/emoticon/version.rb
+
+module IpynbDiff
+  VERSION = "GEM_VERSION"
+end

data/.gitlab-ci.yml

@@ -1,6 +1,43 @@
+# 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
+image: ruby:2.7
+stages:
+- test
+- build
+- rubygems
 specs:
   stage: test
-  image: ruby:2.7
   script:
-    - bundle install
-    - bundle exec rspec
+  - bundle install
+  - bundle exec rspec
+build-gem:
+  stage: build
+  script:
+  - bundle install
+  - cat .VERSION.TMPL | sed s/GEM_VERSION/0.0.0/ > lib/version.rb
+  - gem build ipynbdiff.gemspec
+  artifacts:
+    paths:
+    - ipynbdiff-0.0.0.gem
+  needs:
+  - specs
+deploy-gem:
+  stage: rubygems
+  script:
+  - bundle install
+  - cat .VERSION.TMPL | sed s/GEM_VERSION/$CI_COMMIT_TAG/ > lib/version.rb
+  - gem build ipynbdiff.gemspec
+  - gem push ipynbdiff-$CI_COMMIT_TAG.gem
+  only:
+  - tags
+  except:
+  - branches
+  needs:
+  - build-gem
+  when: manual
+include:
+- template: Security/Dependency-Scanning.gitlab-ci.yml

data/.rubocop.yml

@@ -0,0 +1 @@
+inherit_from: .rubocop_todo.yml

data/.rubocop_todo.yml

@@ -0,0 +1,31 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2021-12-22 14:13:29 UTC using RuboCop version 1.23.0.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 1
+# Configuration parameters: Include.
+# Include: **/*.gemspec
+Gemspec/RequiredRubyVersion:
+  Exclude:
+    - 'ipynbdiff.gemspec'
+
+AllCops:
+  NewCops: enable
+
+Style/StringConcatenation:
+  Enabled: false
+
+# Offense count: 6
+# Configuration parameters: CountComments, CountAsOne, ExcludedMethods, IgnoredMethods.
+# IgnoredMethods: refine
+Metrics/BlockLength:
+  Enabled: false
+
+# Offense count: 3
+# Configuration parameters: CountComments, CountAsOne, ExcludedMethods, IgnoredMethods.
+Metrics/MethodLength:
+  Enabled: false

data/Gemfile

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
 gem 'diffy', '3.3.0'
 gem 'json', '2.5.1'
 gem 'rspec', '3.10.0'
+gem 'rspec-parameterized', '0.5.0'

data/Gemfile.lock

@@ -1,9 +1,18 @@
 GEM
   remote: https://rubygems.org/
   specs:
+    ast (2.4.2)
+    binding_ninja (0.2.3)
+    coderay (1.1.3)
     diff-lcs (1.4.4)
     diffy (3.3.0)
     json (2.5.1)
+    parser (3.0.2.0)
+      ast (~> 2.4.1)
+    proc_to_ast (0.1.0)
+      coderay
+      parser
+      unparser
     rspec (3.10.0)
       rspec-core (~> 3.10.0)
       rspec-expectations (~> 3.10.0)
@@ -16,15 +25,26 @@ GEM
     rspec-mocks (3.10.2)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
+    rspec-parameterized (0.5.0)
+      binding_ninja (>= 0.2.3)
+      parser
+      proc_to_ast
+      rspec (>= 2.13, < 4)
+      unparser
     rspec-support (3.10.2)
+    unparser (0.6.0)
+      diff-lcs (~> 1.3)
+      parser (>= 3.0.0)
 
 PLATFORMS
+  ruby
   x86_64-darwin-20
 
 DEPENDENCIES
   diffy (= 3.3.0)
   json (= 2.5.1)
   rspec (= 3.10.0)
+  rspec-parameterized (= 0.5.0)
 
 BUNDLED WITH
-   2.2.29
+   2.2.30

data/README.md

@@ -7,10 +7,10 @@ that the entire file is readable on the diff.
 
 The result are diffs that are much easier to read:
 
-| Diff | IpynbDiff - HTML | IpynbDiff - Percent |  
-| ------ | ------ | ------ |
-| [Here](example/diff.txt) | [Here](example/ipynbdiff.txt) | [Here](example/ipynbdiff_percent.txt) |
-| ![](example/img/diff.png) | ![](example/img/ipynbdiff_html.png) | ![](example/img/ipynbdiff_percent.png) | 
+| Diff | | IpynbDiff |  
+| ------ |  ------ |
+| [Here](example/diff.txt) |  [Here](example/ipynbdiff_percent.txt) |
+| ![](example/img/diff.png) |  ![](example/img/ipynbdiff_percent.png) | 
 
 
 This started as a port of This is a port of [ipynbdiff](https://gitlab.com/gitlab-org/incubation-engineering/mlops/ipynbdiff), 
@@ -52,7 +52,6 @@ Options:
 
 ```ruby
 @default_transform_options = {
-    include_metadata: false, # Whether to include or not the notebook metadata (kernel, language, etc)
-    cell_decorator: :html # :html is useful to add styling with css, :percent is better for text format
+    include_frontmatter: false, # Whether to include or not the notebook metadata (kernel, language, etc)
 }
 ```

data/ipynbdiff.gemspec

@@ -1,29 +1,38 @@
 # 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     = ENV['LIB_VERSION']
+  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('..', __FILE__)) do
+  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    =
+  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.0'
-  s.add_runtime_dependency 'json', '2.5.1'
+  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 'guard-rspec'
   s.add_development_dependency 'pry'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rspec-parametized'
+  s.metadata = {
+    'rubygems_mfa_required' => 'true'
+  }
 end

data/lib/diff.rb

@@ -0,0 +1,20 @@
+# 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

data/lib/ipynb_symbol_map.rb

@@ -0,0 +1,151 @@
+# 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)
+        IpynbSymbolMap.new(notebook).parse('')
+      end
+    end
+
+    attr_reader :current_line, :char_idx, :results
+
+    WHITESPACE_CHARS = ["\t", "\r", ' ', "\n"].freeze
+
+    VALUE_STOPPERS = [',', '[', ']', '{', '}', *WHITESPACE_CHARS].freeze
+
+    def initialize(notebook)
+      @chars = notebook.chars
+      @current_line = 0
+      @char_idx = 0
+      @results = {}
+    end
+
+    def parse(prefix = '.')
+      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
+        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
+        break if skip_beginning('}')
+
+        prop_name = parse_string
+
+        new_prefix = "#{prefix}.#{prop_name}"
+
+        add_result(new_prefix, current_line)
+
+        next_and_skip_whitespaces
+
+        current_should_be ':'
+
+        next_and_skip_whitespaces
+
+        parse(new_prefix)
+      end
+    end
+
+    def parse_string
+      value = ''
+      prev_char = nil
+
+      current_should_be '"'
+
+      loop do
+        increment_char_index
+        break if (c = current_char) == '"' && prev_char != '\\'
+
+        value += (prev_char = c)
+      end
+
+      value
+    end
+
+    def add_result(key, line_number)
+      @results[key] = line_number
+    end
+
+    def parse_value
+      increment_char_index until VALUE_STOPPERS.include?(current_char)
+    end
+
+    def skip_whitespaces
+      while WHITESPACE_CHARS.include?(current_char)
+        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
+      @chars[@char_idx]
+    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 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

data/lib/ipynbdiff.rb

@@ -3,55 +3,20 @@
 # Human Readable Jupyter Diffs
 module IpynbDiff
   require 'transformer'
-  require 'diffy'
+  require 'diff'
 
-  @default_transform_options = {
-    include_metadata: false,
-    cell_decorator: :html
-  }
+  def self.diff(from, to, raise_if_invalid_nb: false, include_frontmatter: false, diffy_opts: {})
+    transformer = Transformer.new(include_frontmatter: include_frontmatter)
 
-  @default_diff_options = {
-    preprocess_input: true,
-    write_output_to: nil,
-    format: :text,
-    sources_are_files: false,
-    raise_if_invalid_notebook: false,
-    transform_options: @default_transform_options,
-    diff_opts: {
-      include_diff_info: false
-    }
-  }.freeze
-
-  def self.prepare_input(to_prepare, options)
-    return '' unless to_prepare
-
-    prep = to_prepare
-    prep = File.read(prep) if options[:sources_are_files]
-    prep = transform(prep, raise_errors: true, options: options[:transform_options]) if options[:preprocess_input]
-    prep
-  end
-
-  def self.diff(
-    from_notebook,
-    to_notebook,
-    options = @default_diff_options
-  )
-    options = @default_diff_options.merge(options)
-
-    from = prepare_input(from_notebook, options)
-    to = prepare_input(to_notebook, options)
-
-    d = Diffy::Diff.new(from, to, **options[:diff_opts]).to_s(options[:format])
-    File.write(options[:write_output_to], d) if options[:write_output_to]
-    d
+    Diff.new(transformer.transform(from), transformer.transform(to), diffy_opts)
   rescue InvalidNotebookError
-    raise if options[:raise_if_invalid_notebook]
+    raise if raise_if_invalid_nb
   end
 
-  def self.transform(notebook, raise_errors: false, options: @default_transform_options)
-    options = @default_transform_options.merge(options)
+  def self.transform(notebook, raise_errors: false, include_frontmatter: true)
+    return unless notebook
 
-    Transformer.new(**options).transform(notebook)
+    Transformer.new(include_frontmatter: include_frontmatter).transform(notebook).as_text
   rescue InvalidNotebookError
     raise if raise_errors
   end

data/lib/output_transformer.rb

@@ -1,65 +1,79 @@
 # frozen_string_literal: true
 
 module IpynbDiff
-
   # Transforms Jupyter output data into markdown
   class OutputTransformer
+    require 'symbolized_markdown_helper'
+    include SymbolizedMarkdownHelper
 
     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]
+      'display_data' => %w[image/png image/svg+xml image/jpeg text/markdown text/latex],
+      'stream' => %w[text]
     }.freeze
 
-    def transform(output)
-      case (output_type = output['output_type'])
-      when 'error'
-        transform_error(output['traceback'])
-      when 'execute_result', 'display_data'
-        transform_non_error(ORDERED_KEYS[output_type], output['data'])
-      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 transform_error(traceback)
-      traceback.map do |t|
-        t.split("\n").map do |line|
-          line.gsub(/\[[0-9][0-9;]*m/, '').sub("\u001B", '    ').gsub(/\u001B/, '').rstrip << "\n"
+    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)
-      accepted_keys.map do |key|
-        transform_element(key, elements[key]) if elements.key?(key)
-      end.flatten
+    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)
+    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, output_element)
+        transform_image(output_type, output_element, new_symbol)
       when 'image/svg+xml'
-        transform_svg(output_element)
-      when 'text/markdown', 'text/latex', 'text/plain'
-        transform_text(output_element)
+        transform_svg(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)
-      ["    ![](data:#{image_type};base64,#{image_content.gsub("\n", '')})", "\n"]
+    def transform_image(image_type, image_content, symbol)
+      _(symbol, "    ![](data:#{image_type};base64,#{image_content.gsub("\n", '')})")
     end
 
-    def transform_svg(image_content)
+    def transform_svg(image_content, symbol)
       lines = image_content.is_a?(Array) ? image_content : [image_content]
 
-      single_line = lines.map(&:strip).join('').gsub(/\s+/, ' ')
+      single_line = lines.map(&:strip).join.gsub(/\s+/, ' ')
 
-      ["    ![](data:image/svg+xml;utf8,#{single_line})", "\n"]
+      _(symbol, "    ![](data:image/svg+xml;utf8,#{single_line})")
     end
 
-    def transform_text(text_content)
-      lines = text_content.is_a?(Array) ? text_content : [text_content]
-
-      lines.map { |line| "    #{line}" }.append("\n")
+    def transform_text(text_content, symbol)
+      symbolize_array(symbol, text_content) { |l| "    #{l.rstrip}" }
     end
   end
 end

data/lib/symbolized_markdown_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module IpynbDiff
+  # Helper functions
+  module SymbolizedMarkdownHelper
+
+    def _(symbol = nil, content = '')
+      { symbol: symbol, content: content }
+    end
+
+    def array_if_not_array(thing)
+      thing.is_a?(Array) ? thing : [thing]
+    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

data/lib/transformed_notebook.rb

@@ -0,0 +1,20 @@
+# 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

data/lib/transformer.rb

@@ -9,14 +9,15 @@ module IpynbDiff
     require 'json'
     require 'yaml'
     require 'output_transformer'
+    require 'symbolized_markdown_helper'
+    require 'ipynb_symbol_map'
+    require 'transformed_notebook'
+    include SymbolizedMarkdownHelper
 
-    @cell_decorator = :html
-    @include_metadata = true
+    @include_frontmatter = true
 
-
-    def initialize(include_metadata: true, cell_decorator: :html)
-      @include_metadata = include_metadata
-      @cell_decorator = cell_decorator
+    def initialize(include_frontmatter: true)
+      @include_frontmatter = include_frontmatter
       @output_transformer = OutputTransformer.new
     end
 
@@ -31,71 +32,68 @@ module IpynbDiff
     end
 
     def transform(notebook)
+      return TransformedNotebook.new unless notebook
+
       notebook_json = validate_notebook(notebook)
-      transformed_blocks = notebook_json['cells'].map do |cell|
-        decorate_cell(transform_cell(cell, notebook_json), cell)
-      end
+      transformed = transform_document(notebook_json)
+      symbol_map = IpynbSymbolMap.parse(notebook)
 
-      transformed_blocks.prepend(transform_metadata(notebook_json)) if @include_metadata
-      transformed_blocks.join("\n")
+      TransformedNotebook.new(transformed, symbol_map)
     end
 
-    def decorate_cell(rows, cell)
-      tags = cell['metadata']&.fetch('tags', [])
-      type = cell['cell_type'] || 'raw'
+    def transform_document(notebook)
+      symbol = JsonSymbol.new('.cells')
 
-      case @cell_decorator
-      when :html
-        rows.prepend(%(<div class="cell #{type}" data-id="#{cell['id']}" data-tags="#{tags&.join(' ')}">\n\n))
-            .append("\n</div>\n")
-      when :percent
-        rows.prepend(%(%% Cell type:#{type} id:#{cell['id']} tags:#{tags&.join(',')}\n\n))
-      else
-        rows
-      end.join('')
-    end
+      transformed_blocks = notebook['cells'].map.with_index do |cell, idx|
+        decorate_cell(transform_cell(cell, notebook, symbol / idx), cell, symbol / idx)
+      end
 
-    def transform_cell(cell, notebook)
-      cell['cell_type'] == 'code' ? transform_code_cell(cell, notebook) : transform_text_cell(cell)
+      transformed_blocks.prepend(transform_metadata(notebook)) if @include_frontmatter
+      transformed_blocks.flatten
     end
 
-    def decorate_output(output_rows, output)
-      if @cell_decorator == :html
-        output_rows.prepend(%(\n<div class="output #{output['output_type']}">\n\n)).append("\n</div>\n")
-      else
-        output_rows.prepend(%(\n%%%% Output: #{output['output_type']}\n\n))
-      end
-    end
+    def decorate_cell(rows, cell, symbol)
+      tags = cell['metadata']&.fetch('tags', [])
+      type = cell['cell_type'] || 'raw'
 
-    def transform_code_cell(cell, notebook)
       [
-        %(``` #{notebook.dig('metadata', 'kernelspec', 'language') || ''}\n),
-        *cell['source'],
-        "\n```\n",
-        *cell['outputs'].map { |output| transform_output(output) }
+        _(symbol, %(%% Cell type:#{type} id:#{cell['id']} tags:#{tags&.join(',')})),
+        _,
+        rows,
+        _
       ]
     end
 
-    def transform_output(output)
-      transformed = @output_transformer.transform(output)
+    def transform_cell(cell, notebook, symbol)
+      cell['cell_type'] == 'code' ? transform_code_cell(cell, notebook, symbol) : transform_text_cell(cell, symbol)
+    end
 
-      decorate_output(transformed, output).join('') if transformed
+    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)
-      source = cell['source']
-      (source.is_a?(Array) ? source : [source]).append("\n")
+    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 + "---\n"
+      }.to_yaml
+
+      as_yaml.split("\n").map { |l| _(nil, l) }.append(_(nil, '---'), _)
     end
   end
 end

data/lib/version.rb

@@ -0,0 +1,5 @@
+# lib/emoticon/version.rb
+
+module IpynbDiff
+  VERSION = "0.4.2"
+end

metadata

@@ -1,41 +1,47 @@
 --- !ruby/object:Gem::Specification
 name: ipynbdiff
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.4.2
 platform: ruby
 authors:
 - Eduardo Bonet
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-18 00:00:00.000000000 Z
+date: 2022-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diffy
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.3.0
+        version: '3.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.3.0
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.5.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.5.1
 - !ruby/object:Gem::Dependency
@@ -108,6 +114,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-parametized
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Better diff for Jupyter Notebooks by first preprocessing them and removing
   clutter
 email: ebonet@gitlab.com
@@ -115,19 +135,28 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".VERSION.TMPL"
 - ".gitignore"
 - ".gitlab-ci.yml"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
 - Gemfile
 - Gemfile.lock
 - README.md
 - ipynbdiff.gemspec
+- lib/diff.rb
+- lib/ipynb_symbol_map.rb
 - lib/ipynbdiff.rb
 - lib/output_transformer.rb
+- lib/symbolized_markdown_helper.rb
+- lib/transformed_notebook.rb
 - lib/transformer.rb
+- lib/version.rb
 homepage: https://gitlab.com/gitlab-org/incubation-engineering/mlops/rb-ipynbdiff
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths: