lumitrace 0.4.2 → 0.6.0

data/runv/sync_inline.rb

@@ -3,6 +3,7 @@
 index_path = File.expand_path("index.html", __dir__)
 record_path = File.expand_path("../lib/lumitrace/record_instrument.rb", __dir__)
 html_path = File.expand_path("../lib/lumitrace/generate_resulted_html.rb", __dir__)
+renderer_js_path = File.expand_path("../lib/lumitrace/generate_resulted_html_renderer.js", __dir__)
 version_path = File.expand_path("../lib/lumitrace/version.rb", __dir__)
 
 index = File.read(index_path)
@@ -15,6 +16,17 @@ record_code = File.read(record_path).rstrip
 html_code = File.read(html_path).lines.reject { |line|
   line.match?(/^\s*require_relative\s+["']record_instrument["']\s*$/)
 }.join.rstrip
+renderer_js = File.read(renderer_js_path).rstrip
+renderer_js_literal = renderer_js.gsub(/\\/, "\\\\\\\\").gsub(/'/, "\\\\'")
+
+renderer_method_src = <<~RUBY.rstrip
+  def self.html_renderer_js
+    @html_renderer_js ||= '#{renderer_js_literal}'
+  end
+RUBY
+html_code_after = html_code.sub(/def self\.html_renderer_js\s*\n.*?\n\s*end/m) { renderer_method_src }
+abort "failed to inline renderer JS into GenerateResultedHtml" if html_code_after == html_code
+html_code = html_code_after
 html_code = html_code.gsub("</script>", "\#{'</scr' + 'ipt>'}")
 
 generated = +"    # LUMITRACE_INLINE_BEGIN\n"
@@ -30,7 +42,7 @@ unless index.match?(pattern)
   abort "inline block markers not found in #{index_path}"
 end
 
-index.sub!(pattern, generated)
+index.sub!(pattern) { generated }
 index.gsub!(/lumitrace \d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?\./, "lumitrace #{version}.")
 File.write(index_path, index)
 puts "updated #{index_path}"

data/test/test_lumitrace.rb

@@ -64,6 +64,43 @@ class LumiTraceTest < Minitest::Test
     assert_operator out.scan(/Lumitrace::R\(\d+, \(/).length, :>=, 2
   end
 
+  def test_instrument_command_style_call_with_hash_and_block_compiles
+    skip "RubyVM::InstructionSequence unavailable" unless defined?(RubyVM::InstructionSequence)
+
+    src = <<~RUBY
+      def path(*args)
+        yield if block_given?
+      end
+
+      path = "x"
+      glob = "*.rb"
+
+      path path, "glob" => glob do
+        path
+      end
+    RUBY
+
+    out = Lumitrace::RecordInstrument.instrument_source(src, [], file_label: "sample.rb")
+    RubyVM::InstructionSequence.compile(out, "sample.rb")
+    assert_includes out, "path path"
+  end
+
+  def test_instrument_does_not_wrap_inside_defined
+    skip "RubyVM::InstructionSequence unavailable" unless defined?(RubyVM::InstructionSequence)
+
+    src = <<~RUBY
+      foo = 1
+      bar = 2
+      defined?(foo + bar)
+    RUBY
+
+    out = Lumitrace::RecordInstrument.instrument_source(src, [], file_label: "sample.rb")
+    RubyVM::InstructionSequence.compile(out, "sample.rb")
+
+    assert_includes out, "defined?(foo + bar)"
+    refute_match(/defined\?\([^)]*Lumitrace::R\(/, out)
+  end
+
   def test_render_all_generates_html
     Dir.mktmpdir do |dir|
       path = File.join(dir, "lumitrace_events.json")
@@ -243,6 +280,37 @@ class LumiTraceTest < Minitest::Test
     end
   end
 
+  def test_events_from_ids_includes_unhit_locations
+    with_record_instrument_state do
+      mod = Lumitrace::RecordInstrument
+      mod.instance_variable_set(:@events_by_id, [])
+      mod.instance_variable_set(:@loc_by_id, [])
+      mod.instance_variable_set(:@next_id, 0)
+      Lumitrace.install_collect_mode("history")
+      mod.max_samples_per_expr = 3
+
+      hit_id = mod.register_location(
+        "a.rb",
+        { start_line: 1, start_col: 0, end_line: 1, end_col: 1 },
+        kind: :expr
+      )
+      mod.register_location(
+        "a.rb",
+        { start_line: 2, start_col: 0, end_line: 2, end_col: 1 },
+        kind: :expr
+      )
+
+      Lumitrace::R(hit_id, 1)
+
+      events = mod.events_from_ids.sort_by { |e| e[:start_line] }
+      assert_equal 2, events.length
+      assert_equal 1, events[0][:total]
+      assert_equal 0, events[1][:total]
+      assert_equal [], events[1][:sampled_values]
+      assert_equal({}, events[1][:types])
+    end
+  end
+
   def test_text_comment_value_includes_type
     events = [
       {
@@ -346,6 +414,46 @@ class LumiTraceTest < Minitest::Test
     assert_equal "types: Integer(3) (3rd run)", comment
   end
 
+  def test_comment_value_ignores_unhit_event
+    comment = Lumitrace::GenerateResultedHtml.comment_value_with_total_for_line(
+      [
+        {
+          marker: true,
+          kind: "expr",
+          start_col: 0,
+          end_col: 1,
+          sampled_values: [],
+          types: {},
+          total: 0
+        }
+      ]
+    )
+    assert_nil comment
+  end
+
+  def test_render_text_marks_unhit_line_with_bang
+    text = Lumitrace::GenerateResultedHtml.render_text_from_normalized_events(
+      "foo = bar\n",
+      [
+        {
+          file: "a.rb",
+          start_line: 1,
+          start_col: 6,
+          end_line: 1,
+          end_col: 9,
+          kind: "expr",
+          sampled_values: [],
+          types: {},
+          total: 0
+        }
+      ],
+      filename: "a.rb",
+      with_header: false
+    )
+
+    assert_includes text, "!1| foo = bar"
+  end
+
   def test_normalize_events_keeps_sampled_value_objects
     events = [
       {
@@ -362,6 +470,193 @@ class LumiTraceTest < Minitest::Test
     assert_equal "<obj>", normalized.first[:sampled_values].first["preview"]
   end
 
+  def test_event_to_html_trace_payload_uses_last_value_when_sampled_values_missing
+    payload = Lumitrace::GenerateResultedHtml.event_to_html_trace_payload(
+      {
+        start_line: 1,
+        start_col: 0,
+        end_line: 1,
+        end_col: 3,
+        kind: "expr",
+        last_value: { type: "String", preview: "\"x\"" },
+        types: { "String" => 2 },
+        total: 2
+      }
+    )
+
+    assert_equal [{ type: "String", preview: "\"x\"" }], payload[:sampled_values]
+    assert_equal({ "String" => 2 }, payload[:types])
+    assert_equal 2, payload[:total]
+  end
+
+  def test_build_html_payload_includes_command_text
+    payload = Lumitrace::GenerateResultedHtml.build_html_payload(
+      mode_info: { mode: "last", text: "Mode: last (last value)", max_samples: nil },
+      files: [],
+      command_text: "ruby script.rb arg1"
+    )
+
+    assert_equal "ruby script.rb arg1", payload[:meta][:command]
+  end
+
+  def test_value_type_name_with_basic_object
+    klass = Class.new(BasicObject)
+    obj = klass.new
+    type = Lumitrace::RecordInstrument.value_type_name(obj)
+    refute_nil type
+    refute_empty type
+  end
+
+  def test_summarize_value_with_basic_object
+    klass = Class.new(BasicObject)
+    obj = klass.new
+    summary = Lumitrace::RecordInstrument.summarize_value(obj)
+    assert summary.is_a?(Hash)
+    assert summary.key?(:type)
+    assert summary.key?(:preview)
+    refute_nil summary[:type]
+    refute_empty summary[:type]
+  end
+
+  def test_R_with_basic_object_last_mode
+    with_record_instrument_state do
+      mod = Lumitrace::RecordInstrument
+      mod.instance_variable_set(:@events_by_id, [])
+      mod.instance_variable_set(:@loc_by_id, [])
+      mod.instance_variable_set(:@next_id, 0)
+      Lumitrace.install_collect_mode("last")
+
+      id = mod.register_location(
+        "a.rb",
+        { start_line: 1, start_col: 0, end_line: 1, end_col: 1 },
+        kind: :expr
+      )
+
+      klass = Class.new(BasicObject)
+      obj = klass.new
+      result = Lumitrace::R(id, obj)
+      assert_same obj, result
+
+      events = mod.events_from_ids
+      assert_equal 1, events.first[:total]
+      refute_empty events.first[:types]
+    end
+  end
+
+  def test_R_with_basic_object_history_mode
+    with_record_instrument_state do
+      mod = Lumitrace::RecordInstrument
+      mod.instance_variable_set(:@events_by_id, [])
+      mod.instance_variable_set(:@loc_by_id, [])
+      mod.instance_variable_set(:@next_id, 0)
+      Lumitrace.install_collect_mode("history")
+      mod.max_samples_per_expr = 3
+
+      id = mod.register_location(
+        "a.rb",
+        { start_line: 1, start_col: 0, end_line: 1, end_col: 1 },
+        kind: :expr
+      )
+
+      klass = Class.new(BasicObject)
+      Lumitrace::R(id, klass.new)
+      Lumitrace::R(id, 42)
+
+      events = mod.events_from_ids
+      assert_equal 2, events.first[:total]
+      assert_equal 2, events.first[:sampled_values].length
+    end
+  end
+
+  def test_R_with_basic_object_types_mode
+    with_record_instrument_state do
+      mod = Lumitrace::RecordInstrument
+      mod.instance_variable_set(:@events_by_id, [])
+      mod.instance_variable_set(:@loc_by_id, [])
+      mod.instance_variable_set(:@next_id, 0)
+      Lumitrace.install_collect_mode("types")
+
+      id = mod.register_location(
+        "a.rb",
+        { start_line: 1, start_col: 0, end_line: 1, end_col: 1 },
+        kind: :expr
+      )
+
+      klass = Class.new(BasicObject)
+      Lumitrace::R(id, klass.new)
+
+      events = mod.events_from_ids
+      assert_equal 1, events.first[:total]
+      refute_empty events.first[:types]
+    end
+  end
+
+  def test_compute_coverage
+    events = [
+      { file: "a.rb", start_line: 1, start_col: 0, end_line: 1, end_col: 5, total: 3 },
+      { file: "a.rb", start_line: 2, start_col: 0, end_line: 2, end_col: 5, total: 0 },
+      { file: "a.rb", start_line: 3, start_col: 0, end_line: 3, end_col: 5, total: 1 },
+      { file: "b.rb", start_line: 1, start_col: 0, end_line: 1, end_col: 5, total: 0 }
+    ]
+    coverage = Lumitrace::RecordInstrument.compute_coverage(events)
+    assert_equal 2, coverage.length
+
+    a = coverage.find { |c| c[:file] == "a.rb" }
+    assert_equal 3, a[:total_lines]
+    assert_equal 2, a[:covered_lines]
+    assert_equal 66.7, a[:coverage_percent]
+
+    b = coverage.find { |c| c[:file] == "b.rb" }
+    assert_equal 1, b[:total_lines]
+    assert_equal 0, b[:covered_lines]
+    assert_equal 0.0, b[:coverage_percent]
+  end
+
+  def test_dump_events_json_wrapped_format
+    Dir.mktmpdir do |dir|
+      events = [
+        { file: "a.rb", start_line: 1, start_col: 0, end_line: 1, end_col: 5, total: 1 }
+      ]
+      path = File.join(dir, "out.json")
+      Lumitrace::RecordInstrument.dump_events_json(events, path)
+      data = JSON.parse(File.read(path))
+
+      assert_equal 1, data["version"]
+      assert data.key?("events")
+      assert data.key?("coverage")
+      assert_equal 1, data["events"].length
+      assert_equal 1, data["coverage"].length
+      assert_equal 100.0, data["coverage"][0]["coverage_percent"]
+    end
+  end
+
+  def test_render_all_reads_wrapped_json
+    Dir.mktmpdir do |dir|
+      sample = File.join(dir, "sample.rb")
+      File.write(sample, "puts hi\n")
+      events_path = File.join(dir, "events.json")
+      payload = {
+        "version" => 1,
+        "events" => [
+          {
+            "file" => sample,
+            "start_line" => 1,
+            "start_col" => 0,
+            "end_line" => 1,
+            "end_col" => 5,
+            "sampled_values" => ["ok"],
+            "total" => 1
+          }
+        ],
+        "coverage" => []
+      }
+      File.write(events_path, JSON.dump(payload))
+
+      html = Lumitrace::GenerateResultedHtml.render_all(events_path, root: dir)
+      assert_includes html, "sample.rb"
+    end
+  end
+
   def test_env_range_parsing
     with_env("LUMITRACE_RANGE" => "a.rb:1-3,5-6;b.rb", "LUMITRACE_COLLECT_MODE" => "types") do
       env = Lumitrace.resolve_env_options

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lumitrace
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.6.0
 platform: ruby
 authors:
 - Koichi Sasada
@@ -34,6 +34,7 @@ files:
 - lib/lumitrace/enable_git_diff.rb
 - lib/lumitrace/env.rb
 - lib/lumitrace/generate_resulted_html.rb
+- lib/lumitrace/generate_resulted_html_renderer.js
 - lib/lumitrace/git_diff.rb
 - lib/lumitrace/help_manifest.rb
 - lib/lumitrace/record_instrument.rb