bundle_update 0.0.1 → 0.1.0

data/lib/bundle_update/report_writer.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "time"
+
+module BundleUpdate
+  # Writes the rendered report to disk, choosing which markdown body to use
+  # based on the API response tier (rich/200, basic+link/202, local/nothing),
+  # and persists report_id + url to a small state file so `bundle_update
+  # report` can poll a still-generating report later.
+  class ReportWriter
+    Result = Struct.new(:path, :terminal_summary, :hosted_url, keyword_init: true)
+
+    def initialize(config)
+      @config = config
+    end
+
+    # api_response is an ApiClient::Response, or nil on the free tier / when
+    # the API call itself failed open.
+    def write(diff:, project_name:, ran_at:, api_response: nil)
+      local_report = LocalReport.new(diff: diff, project_name: project_name, ran_at: ran_at)
+      markdown = markdown_for(local_report, api_response)
+
+      path = write_markdown(markdown, ran_at)
+      persist_state(api_response) if api_response&.report_id
+
+      Result.new(path: path, terminal_summary: local_report.terminal_summary, hosted_url: api_response&.url)
+    end
+
+    # Writes an already-rendered markdown string directly, bypassing Diff
+    # rendering. Used by `bundle_update report` to persist a report fetched
+    # straight from the API.
+    def write_raw(markdown, ran_at: Time.now)
+      write_markdown(markdown, ran_at)
+    end
+
+    def self.read_state(config)
+      path = config.state_file_path
+      return nil unless File.exist?(path)
+
+      JSON.parse(File.read(path))
+    rescue JSON::ParserError, Errno::ENOENT
+      nil
+    end
+
+    private
+
+    def markdown_for(local_report, api_response)
+      case api_response&.status
+      when :ready
+        api_response.markdown || local_report.markdown
+      when :pending
+        pending_markdown(local_report.markdown, api_response.url)
+      else
+        local_report.markdown
+      end
+    end
+
+    def pending_markdown(basic_markdown, hosted_url)
+      <<~MARKDOWN
+        #{basic_markdown}
+        ---
+
+        **Full changelog report generating:** #{hosted_url}
+
+        Run `bundle_update report` to fetch the complete version once it's ready.
+      MARKDOWN
+    end
+
+    def write_markdown(content, ran_at)
+      dir = File.join(@config.project_root, @config.reports_dir)
+      FileUtils.mkdir_p(dir)
+      path = unique_path(dir, ran_at.strftime("%Y%m%d%H%M%S"))
+      File.write(path, content)
+      path
+    end
+
+    # A zero-padded sequence (not "plain, then -2, -3...") so two runs within
+    # the same second — back-to-back in a script, or in tests — sort in the
+    # same order they were written, instead of a bare filename sorting ahead
+    # of its own "-2" suffix.
+    def unique_path(dir, timestamp)
+      seq = 1
+      loop do
+        path = File.join(dir, format("%<timestamp>s_%<seq>02d_report.md", timestamp: timestamp, seq: seq))
+        return path unless File.exist?(path)
+
+        seq += 1
+      end
+    end
+
+    def persist_state(api_response)
+      path = @config.state_file_path
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, JSON.pretty_generate(
+                         report_id: api_response.report_id,
+                         url: api_response.url,
+                         recorded_at: Time.now.utc.iso8601
+                       ))
+      FileUtils.chmod(0o600, path)
+    end
+  end
+end

data/lib/bundle_update/runner.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "time"
+
+module BundleUpdate
+  # The single orchestration entry point both the CLI wrapper and the
+  # Bundler plugin hooks call. Owns the fail-open contract: nothing raised
+  # from here ever propagates into the caller's `bundle update` run.
+  class Runner
+    def initialize(config: Config.new)
+      @config = config
+    end
+
+    # lockfile_before/lockfile_after are raw Gemfile.lock content, captured
+    # by the caller (CLI wrapper or plugin hook) around the bundler command.
+    def report(lockfile_before:, lockfile_after:, ran_at: Time.now)
+      return nil if @config.disabled?
+
+      diff = Diff.new(Snapshot.new(lockfile_before), Snapshot.new(lockfile_after))
+      return nil if diff.empty?
+
+      api_response = fetch_api_response(lockfile_before, lockfile_after, ran_at)
+      result = ReportWriter.new(@config).write(
+        diff: diff, project_name: @config.project_name, ran_at: ran_at, api_response: api_response
+      )
+      print_result(result, api_response)
+      result
+    rescue StandardError => e
+      # Failure in the local pipeline itself (parsing, rendering, disk I/O):
+      # print nothing, exit cleanly. The client's bundle run must never see this.
+      debug_log(e)
+      nil
+    end
+
+    # `bundle_update report` — re-fetch the report for the most recently
+    # recorded run (e.g. one that returned 202 and is now ready).
+    def refetch_latest
+      unless @config.api_key?
+        warn "bundle_update: no API key configured. Run `bundle_update auth KEY` first."
+        return nil
+      end
+
+      state = ReportWriter.read_state(@config)
+      unless state && state["report_id"]
+        warn "bundle_update: no previous run found. Run `bundle update` first."
+        return nil
+      end
+
+      response = ApiClient.new(@config).fetch_report(state["report_id"])
+      handle_refetch_response(response)
+    rescue StandardError => e
+      debug_log(e)
+      warn "bundle_update: could not fetch the report."
+      nil
+    end
+
+    private
+
+    def fetch_api_response(lockfile_before, lockfile_after, ran_at)
+      return nil unless @config.api_key?
+
+      response = ApiClient.new(@config).create_report(
+        lockfile_before: lockfile_before, lockfile_after: lockfile_after, ran_at: ran_at
+      )
+      warn_on_api_failure(response) if response.error?
+      response
+    rescue StandardError => e
+      debug_log(e)
+      warn_on_api_failure(nil)
+      nil
+    end
+
+    def warn_on_api_failure(_response)
+      warn "bundle_update: couldn't reach bundleupdate.com — showing the local summary instead."
+    end
+
+    def handle_refetch_response(response)
+      case response.status
+      when :ready
+        path = ReportWriter.new(@config).write_raw(response.markdown, ran_at: Time.now)
+        puts "Report written to #{path}"
+        puts response.url
+        response
+      when :pending
+        puts "Report is still generating: #{response.url}"
+        response
+      else
+        warn "bundle_update: could not fetch the report (#{response.error})."
+        nil
+      end
+    end
+
+    def print_result(result, api_response)
+      puts result.terminal_summary
+      case api_response&.status
+      when :ready
+        puts "Full report: #{api_response.url}" if api_response.url
+      when :pending
+        puts "Full report generating: #{api_response.url}"
+        puts "Run `bundle_update report` shortly to fetch it."
+      end
+      puts "Report written to #{result.path}"
+    end
+
+    def debug_log(error)
+      return unless @config.debug?
+
+      path = @config.debug_log_path
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, "a") do |f|
+        f.puts "[#{Time.now.utc.iso8601}] #{error.class}: #{error.message}"
+        f.puts(error.backtrace || [])
+        f.puts "---"
+      end
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/bundle_update/snapshot.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "bundler"
+
+module BundleUpdate
+  # A parsed Gemfile.lock at a point in time: raw content plus name => GemSpec.
+  class Snapshot
+    GemSpec = Struct.new(:name, :version, :source_type, keyword_init: true)
+
+    attr_reader :raw, :specs
+
+    def self.from_file(path)
+      new(File.exist?(path) ? File.read(path) : "")
+    end
+
+    def initialize(raw)
+      @raw = raw.to_s
+      @specs = parse(@raw)
+    end
+
+    def [](name)
+      specs[name]
+    end
+
+    def gem_names
+      specs.keys
+    end
+
+    private
+
+    def parse(raw)
+      return {} if raw.strip.empty?
+
+      Bundler::LockfileParser.new(raw).specs.to_h do |spec|
+        [spec.name, GemSpec.new(
+          name: spec.name,
+          version: spec.version&.to_s,
+          source_type: source_type_for(spec.source)
+        )]
+      end
+    end
+
+    def source_type_for(source)
+      case source
+      when Bundler::Source::Git
+        :git
+      when Bundler::Source::Path, Bundler::Source::Gemspec
+        :path
+      else
+        :gem
+      end
+    end
+  end
+end

data/lib/bundle_update/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module BundleUpdate
+  VERSION = "0.1.0"
+end

data/lib/bundle_update.rb

@@ -1,4 +1,14 @@
-# Placeholder gem. Name reserved; no functionality.
+# frozen_string_literal: true
+
+require_relative "bundle_update/version"
+require_relative "bundle_update/snapshot"
+require_relative "bundle_update/diff"
+require_relative "bundle_update/config"
+require_relative "bundle_update/local_report"
+require_relative "bundle_update/api_client"
+require_relative "bundle_update/report_writer"
+require_relative "bundle_update/runner"
+
 module BundleUpdate
-  VERSION = "0.0.1"
+  class Error < StandardError; end
 end

data/plugins.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Loaded by Bundler when this gem is installed as a plugin
+# (`bundle plugin install bundle_update`). Wires the zero-effort mode: the
+# reporting pipeline runs automatically after `bundle install`/`bundle
+# update`, no CLI wrapper required.
+#
+# This must never be able to break the host's bundle install/update, so
+# every failure mode here — a missing dependency, an incompatible Bundler
+# plugin API, anything — is swallowed rather than raised.
+begin
+  require "bundle_update"
+  require "bundle_update/plugin"
+  BundleUpdate::Plugin.install!
+rescue StandardError
+  nil
+end

metadata

@@ -1,29 +1,54 @@
 --- !ruby/object:Gem::Specification
 name: bundle_update
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Emanuel Comsa
-bindir: bin
+bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: This gem is a placeholder to reserve the bundle_update name. It has no
-  functionality.
+description: |
+  bundle_update wraps `bundle update` / `bundle install`, diffs your Gemfile.lock
+  before and after, and prints a concise summary of what changed (major/minor/patch).
+  With a bundleupdate.com API key it also fetches a rich changelog report for every
+  updated gem. Works fully offline with no API key. Zero runtime dependencies.
 email:
 - office@rubydev.ro
-executables: []
+executables:
+- bundle_update
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- DECISIONS.md
+- Gemfile
+- LICENSE.txt
 - README.md
+- bundle_update.gemspec
+- exe/bundle_update
 - lib/bundle_update.rb
-homepage: https://www.deadbro.com
+- lib/bundle_update/api_client.rb
+- lib/bundle_update/cli.rb
+- lib/bundle_update/config.rb
+- lib/bundle_update/diff.rb
+- lib/bundle_update/local_report.rb
+- lib/bundle_update/plugin.rb
+- lib/bundle_update/report_writer.rb
+- lib/bundle_update/runner.rb
+- lib/bundle_update/snapshot.rb
+- lib/bundle_update/version.rb
+- plugins.rb
+homepage: https://www.bundleupdate.com
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://www.deadbro.com
+  homepage_uri: https://www.bundleupdate.com
+  source_code_uri: https://github.com/deadbro-com/bundle_update
+  changelog_uri: https://github.com/deadbro-com/bundle_update/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/deadbro-com/bundle_update/issues
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -31,7 +56,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -40,5 +65,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.10
 specification_version: 4
-summary: Placeholder gem. Name reserved.
+summary: Reports what changed after `bundle update` — free local summaries, optional
+  hosted changelog reports.
 test_files: []