gemstar 1.0.2 → 1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b290f73ca813d6ef39789e23d883f3bd382fbdcc17f0803cd5fdc296d7f60582
-  data.tar.gz: '058a2d17b98461a62d463ba673d170b621471e8f9693ea294da403382da5a759'
+  metadata.gz: bd80f7bf53281fd8f5b80138f9f564ff8e393ffaec44276168dc020765c6ae7a
+  data.tar.gz: 3d6b9c2f9a2e0955d6ace8c34100c05390cd9579aa8c8993361799450e36c625
 SHA512:
-  metadata.gz: fe408b9d9259ab0771e41522238b35c259e624759ac27ffe013d689c76ebe0164905c5ee67bb7868e8cc43ff361568f854f8dccf2e513468176685a395bb9786
-  data.tar.gz: 149884982e1e2d124f7ade0bf565604106a455db2bab04f6b3811b316fb0386f72ed3fdaa0969369c310e3811e7735d97d29c147f9263f32f62c6c2fcb0d7487
+  metadata.gz: 79d87285b961fdd88c6e898b2016d2bc4cc65b508a5f2c7480f865f0144b12ca5a53be3ff7833d48ed1a66cf4851134a6dbe41fdfc44d807f720e0c63fe52a05
+  data.tar.gz: 4803b9f217fef1aae5b671fdc5a356229697aba7d5cec4b2f1a05588d63a9ca88c38f876ed4aa1d2579451d6196097818a3d9aa866f8071004c45a9966c66a95

data/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Change Log
 
+## 1.1
+
+- Server: Add **JavaScript package support** to browse change logs for your project's packages. This currently
+  supports packages in `importmap.rb` and `package-lock.json`.
+- Server: Change launch behavior to more reliably start cache warmer at launch.
+- Server: Add `--open` option to open the server root in a local browser at launch.
+- Server: Defer initial detail rendering so the page becomes interactive sooner on startup.
+- Server: Persist the Details disclosure state between gem views.
+- Server: Continue background warming with cached parsed release sections, not just raw fetched pages.
+- Server: Improve GitHub release discovery with direct tag-page fallback and paginated GitHub tags support.
+- Server: Prefer real changelog file entries over GitHub-derived placeholders when both exist.
+- Server: Short gem description now rendered as markdown (for minitest gem).
+- Server: Improve section parsing for simplecov and similar gems.
+- Server: Increase limit for number of recent commits to show in menu to 100.
+- Server: Add page icon.
+- Server: Unless a port has been specified, server will now attempt binding from ports 2112 up.
+- Diff: Add **JavaScript package support.** Like with Server, this supports `importmap.rb` and `package-lock.json`.
+- Diff: Add `--ecosystem` parameter to choose js/gems/all.
+- Diff: Add `--project` directive to point at the project root to diff.
+- Diff: Add `--since` parameter to limit diff to commits since a specific date, e.g. `--since "3 weeks ago"`.
+- Diff: Add "file://" to generated report output to fix click-to-open in certain terminal apps.
+- Diff: Add list of considered git commits to diff report.
+- Special cases for specific packages now moved into json configuration files.
+- `gemstar` is now a shortcut for `gemstar server --open`.
+
+## 1.0.4
+
+- Server: Improve layout, detail panel state management, and initial gem selection
+- Server: Gem details now in collapsible panel
+- Server: Arrow left/right navigation improved
+- Enhance changelog parsing with GitHub tag and release support
+- Extend `LockFile` with dependency requirements, spec sources, and platform parsing
+- Refactor dependency processing to include platform and source details
+- Refactor changelog parsing to merge GitHub release and changelog sections
+
+## 1.0.3
+
+- Load our own WEBrick to avoid conflicts with hosting puma.rb etc.
+
 ## 1.0.2
 
 - General server performance improvements.
@@ -21,7 +60,6 @@
 - Removed Railtie from this gem.
 - Improve how git root dir is determined.
 
-
 ## 0.0.2
 
 - Diff: Fix regex warnings shown in terminal.

data/README.md

@@ -3,7 +3,7 @@
 [![JRuby Build](https://github.com/FDj/gemstar/workflows/JRuby%20Build/badge.svg)](https://github.com/FDj/gemstar/actions)
 
 # Gemstar
-A very preliminary gem to help you keep track of your gems.
+Helps you keep track of your gems and JavaScript packages.
 
 ## Installation
 
@@ -34,17 +34,23 @@ gemstar server
 
 By default, the server listens to http://127.0.0.1:2112/
 
+To open the root page in your browser after startup:
+
+```shell
+gemstar server --open
+```
+
 
 ### gemstar diff
 
-Run this after you've updated your gems.
+Run this after you've updated your dependencies.
 
 ```shell
 # in your project directory, after bundle update:
 gemstar diff
 ```
 
-This will generate an html diff report with changelog entries for each gem that was updated:
+This will generate an html diff report with changelog entries for each updated package:
 
 ![Gemstar diff command output](docs/diff.png)
 
@@ -54,12 +60,31 @@ You can also specify from and to hashes or tags to generate a diff report for a
 gemstar diff --from 8e3aa96b7027834cdbabc0d8cbd5f9455165e930 --to HEAD
 ```
 
+To use a time range instead of choosing the starting commit yourself:
+
+```shell
+gemstar diff --project ~/Code/my-app --since "3 weeks"
+```
+
 To examine a specific Gemfile.lock, pass it like this:
 
 ```shell
 gemstar diff --lockfile=~/MyProject/Gemfile.lock
 ```
 
+To diff a project from anywhere, pass the project directory or a supported project file. In project mode, gemstar includes Ruby gems plus JS packages from `importmap.rb` and `package-lock.json` when present:
+
+```shell
+gemstar diff --project ~/Code/my-app
+```
+
+To filter a project diff down to one ecosystem:
+
+```shell
+gemstar diff --project ~/Code/my-app --ecosystem js
+gemstar diff --project ~/Code/my-app --ecosystem gems
+```
+
 To write markdown instead of html:
 
 ```shell

data/bin/gemstar

@@ -4,4 +4,8 @@
 $LOAD_PATH.unshift File.expand_path("../lib", __dir__)
 require_relative "../lib/gemstar"
 
-Gemstar::CLI.start(ARGV)
+if ARGV.empty?
+  Gemstar::Commands::Server.new(open: true).run
+else
+  Gemstar::CLI.start(ARGV)
+end

data/lib/gemstar/cache_warmer.rb

@@ -21,47 +21,60 @@ module Gemstar
       @completed_count = 0
     end
 
-    def enqueue_many(gem_names)
-      names = gem_names.uniq
+    def enqueue_many(package_states)
+      states = normalize_package_states(package_states)
 
       @mutex.synchronize do
-        names.each do |gem_name|
-          next if @completed.include?(gem_name) || @queued.include?(gem_name) || @in_progress.include?(gem_name)
+        states.each do |package_state|
+          key = package_key(package_state)
+          next if @completed.include?(key) || @queued.include?(key) || @in_progress.include?(key)
 
-          @queue << gem_name
-          @queued << gem_name
+          @queue << package_state
+          @queued << key
         end
-        @total += names.count
+        @total += states.count
         start_workers_unlocked unless @started
       end
 
-      log "Background cache refresh queued for #{names.count} gems."
+      log "Background cache refresh queued for #{states.count} packages."
       @condition.broadcast
       self
     end
 
-    def prioritize(gem_name)
+    def prioritize(package_name)
       @mutex.synchronize do
-        return if @completed.include?(gem_name) || @in_progress.include?(gem_name)
+        existing = @queue.find do |item|
+          item[:name] == package_name || item.dig(:source, :package_name) == package_name
+        end
 
-        if @queued.include?(gem_name)
-          @queue.delete(gem_name)
+        if existing
+          key = package_key(existing)
+          return if @completed.include?(key) || @in_progress.include?(key)
+          @queue.delete(existing)
+          @queue.unshift(existing)
         else
-          @queued << gem_name
+          synthetic = {
+            name: package_name,
+            package_scope: "gems",
+            source: {}
+          }
+          key = package_key(synthetic)
+          return if @completed.include?(key) || @in_progress.include?(key)
+          @queued << key
+          @queue.unshift(synthetic)
           @total += 1
         end
-
-        @queue.unshift(gem_name)
         start_workers_unlocked unless @started
       end
 
-      log "Prioritized #{gem_name}"
+      log "Prioritized #{package_name}"
       @condition.broadcast
     end
 
-    def pending?(gem_name)
+    def pending?(package_name)
       @mutex.synchronize do
-        @queued.include?(gem_name) || @in_progress.include?(gem_name)
+        @queue.any? { |item| item[:name] == package_name || item.dig(:source, :package_name) == package_name } ||
+          @in_progress.any? { |key| key.end_with?(":#{package_name}") }
       end
     end
 
@@ -80,47 +93,92 @@ module Gemstar
       Thread.current.name = "gemstar-cache-worker" if Thread.current.respond_to?(:name=)
 
       loop do
-        gem_name = @mutex.synchronize do
+        package_state = @mutex.synchronize do
           while @queue.empty?
             @condition.wait(@mutex)
           end
 
-          next_gem = @queue.shift
-          @queued.delete(next_gem)
-          @in_progress << next_gem
-          next_gem
+          next_package = @queue.shift
+          key = package_key(next_package)
+          @queued.delete(key)
+          @in_progress << key
+          next_package
         end
 
-        warm_cache_for_gem(gem_name)
+        warm_cache_for_package(package_state)
 
         current = @mutex.synchronize do
-          @in_progress.delete(gem_name)
-          @completed << gem_name
+          key = package_key(package_state)
+          @in_progress.delete(key)
+          @completed << key
           @completed_count += 1
         end
 
-        log_progress(gem_name, current)
+        log_progress(package_label(package_state), current)
       end
     end
 
-    def warm_cache_for_gem(gem_name)
-      metadata = Gemstar::RubyGemsMetadata.new(gem_name)
-      metadata.meta
-      metadata.repo_uri
-      Gemstar::ChangeLog.new(metadata).sections
+    def warm_cache_for_package(package_state)
+      metadata = metadata_adapter_for(package_state)
+      return unless metadata
+
+      metadata.warm_cache(versions: package_versions(package_state))
     rescue StandardError => e
-      log "Cache refresh failed for #{gem_name}: #{e.class}: #{e.message}"
+      log "Cache refresh failed for #{package_label(package_state)}: #{e.class}: #{e.message}"
     end
 
-    def log_progress(gem_name, current)
+    def log_progress(package_name, current)
       return unless @debug
       return unless current <= 5 || (current % 25).zero?
 
-      log "Background cache refresh #{current}/#{@total}: #{gem_name}"
+      log "Background cache refresh #{current}/#{@total}: #{package_name}"
     end
 
     def log(message)
       @io.puts(message)
     end
+
+    def normalize_package_states(package_states)
+      Array(package_states).filter_map do |package_state|
+        next unless package_state.is_a?(Hash)
+
+        package_state
+      end.uniq { |package_state| package_key(package_state) }
+    end
+
+    def package_key(package_state)
+      scope = package_state[:package_scope].to_s
+      source_type = package_state[:package_source_file].to_s
+      package_name = package_state.dig(:source, :package_name) || package_state[:name]
+      "#{scope}:#{source_type}:#{package_name}"
+    end
+
+    def package_label(package_state)
+      package_state.dig(:source, :package_name) || package_state[:name]
+    end
+
+    def package_versions(package_state)
+      [
+        package_state[:old_version],
+        package_state[:new_version],
+        package_state[:raw_old_version],
+        package_state[:raw_new_version],
+        package_state.dig(:source, :package_version)
+      ].compact
+    end
+
+    def metadata_adapter_for(package_state)
+      if package_state[:package_scope] == "js"
+        provider_gem = package_state.dig(:source, :provider_gem)
+        return Gemstar::RubyGemsMetadata.new(provider_gem) unless provider_gem.to_s.empty?
+
+        package_name = package_state.dig(:source, :package_name) || package_state[:name]
+        return nil if package_name.to_s.empty?
+
+        return Gemstar::NpmMetadata.new(package_name)
+      end
+
+      Gemstar::RubyGemsMetadata.new(package_state[:name])
+    end
   end
 end