asgard 0.3.1 → 0.3.2

data/lib/asgard/kernel_methods.rb

@@ -29,11 +29,15 @@ module Kernel
   end
   module_function :loki_up
 
-  def import(path)
+  # +from+ is the call-site location used to resolve a relative +path+. It
+  # defaults to the immediate caller, but is exposed as a keyword so a
+  # wrapper (e.g. Asgard::Doctor's import tracer, prepended via `super`)
+  # can thread through the *real* caller instead of its own frame.
+  def import(path, from: caller_locations(1, 1).first)
     path = path.to_s
     raise ArgumentError, "import: path must end with .loki (got #{path.inspect})" unless path.end_with?(".loki")
     unless File.absolute_path?(path)
-      caller_dir = File.dirname(caller_locations(1, 1).first.absolute_path)
+      caller_dir = File.dirname(from.absolute_path)
       path = File.expand_path(path, caller_dir)
     end
     paths = path =~ /[*?\[{]/ ? Dir.glob(path) : [path]

data/lib/asgard/tasks.rb

@@ -26,4 +26,10 @@ class Tasks < Asgard::Base
                default: false,
                desc:    "Show asgard version and exit"
   no_negate :version
+
+  class_option :doctor,
+               type:    :boolean,
+               default: false,
+               desc:    "Diagnose .loki resolution, imports, and task definitions for the CWD, then exit"
+  no_negate :doctor
 end

data/lib/asgard/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Asgard
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

data/lib/asgard.rb

@@ -5,6 +5,7 @@ require_relative "asgard/kernel_methods"
 require_relative "asgard/shell"
 require_relative "asgard/base"
 require_relative "asgard/tasks"
+require_relative "asgard/doctor"
 
 module Asgard
   class Error < StandardError; end
@@ -18,11 +19,16 @@ module Asgard
 
   # Main entry point invoked by the asgard executable.
   def self.run!(argv)
-    abort "asgard: unknown command '#{argv.first}'" if argv.first&.start_with?("_")
+    first = argv.first
+    abort "asgard: unknown command '#{first}'" if first&.start_with?("_")
     if argv.include?("--version")
       puts Asgard::VERSION
       exit
     end
+    if argv.include?("--doctor")
+      Asgard::Doctor.new.run
+      exit
+    end
     task_file = find_task_file or abort "asgard: no .loki file found in #{Dir.pwd}"
     before = Asgard::Base.subclasses.dup
     load task_file

data/quality.loki

@@ -3,44 +3,41 @@
 
 class Tasks
   desc "Run the test suite"
-  def test
+  def test_check
     output = `bundle exec ruby -Ilib:test test/test_asgard.rb 2>&1`
-    @test_result = $?.success? ? :pass : :fail
-    if @test_result == :fail
-      lines  = output.lines
-      start  = lines.index { |l| l =~ /^\s+1\) / } || 0
-      finish = lines.rindex { |l| l =~ /\d+ runs,/ } || -1
-      print lines[start..finish].join
-    end
+    result = $?.success? ? :pass : :fail
+    File.write("test_output.txt", output)
+    summary = output.lines.reverse.find { |l| l =~ /\d+ runs,/ }&.strip || result.to_s
+    puts "Tests: #{summary} (see test_output.txt)"
+    result
   end
 
-  desc "Run all quality gates (tests, RuboCop, Flog) in parallel"
-  depends_on [:test, :rubocop, :flog_check]
-  def quality
-    results = { tests: @test_result, rubocop: @rubocop_result, flog: @flog_result }
+  desc "Run the test suite with verbose output"
+  def test_verbose
+    sh "bundle exec ruby -Ilib:test test/test_asgard.rb -v"
+  end
 
-    if @flog_failures&.any?
-      puts "\nFlog failures (must be refactored):"
-      @flog_failures.each { |v| puts "  #{v}" }
-    end
+  desc "Run every *_check quality gate task in parallel"
+  # A Proc defers resolution to validate_deps!, after every .loki file has
+  # loaded — so a *_check task from another file (e.g. quality_rails.loki's
+  # brakeman_check) is picked up too, with no need to redeclare anything here.
+  depends_on -> { [all_commands.keys.grep(/_check\z/).sort.map(&:to_sym)] }
+  def quality
+    check_tasks = self.class._deps.fetch(:quality, []).flatten.map(&:to_s)
 
-    puts "\n#{"=" * 60}"
-    puts "Quality Summary"
-    puts "=" * 60
-    results.each { |gate, status| puts "  [#{status == :pass ? "PASS" : "FAIL"}] #{gate}" }
-    puts "=" * 60
+    results = check_tasks.to_h { |name| [quality_gate_label(name), dep_result(name)] }
 
-    abort "\nQuality gate failed" if results.values.any?(:fail)
-    puts "\nAll quality gates passed."
+    print_quality_summary(results)
   end
 
   desc "Check code style with RuboCop"
-  def rubocop
+  def rubocop_check
     output = `RUBOCOP_CACHE_ROOT=tmp/rubocop_cache bundle exec rubocop 2>&1`
-    @rubocop_result = $?.success? ? :pass : :fail
-    if @rubocop_result == :fail
-      output.each_line { |l| print l if l =~ /:\d+:\d+: [CWEF]: / }
-    end
+    result = $?.success? ? :pass : :fail
+    File.write("rubocop_output.txt", output)
+    summary = output.lines.find { |l| l =~ /files inspected/ }&.strip || result.to_s
+    puts "RuboCop: #{summary} (see rubocop_output.txt)"
+    result
   end
 
   desc "Auto-correct RuboCop offenses"
@@ -58,18 +55,207 @@ class Tasks
     flogger = Flog.new(all: true)
     flogger.flog(*Dir.glob("lib/**/*.rb"))
 
-    warnings  = []
-    @flog_failures = []
+    warnings = []
+    failures = []
 
     flogger.each_by_score do |method_name, score|
       next if method_name.end_with?("#none")
       if score > method_fail
-        @flog_failures << "#{"%.1f" % score}: #{method_name}"
+        failures << "#{"%.1f" % score}: #{method_name}"
       elsif score > method_warn
         warnings << "#{"%.1f" % score}: #{method_name}"
       end
     end
 
-    @flog_result = @flog_failures.empty? ? :pass : :fail
+    result = failures.empty? ? :pass : :fail
+
+    lines = ["Flog warnings (#{method_warn}–#{method_fail}):"]
+    lines.concat(warnings.empty? ? ["  (none)"] : warnings.map { |w| "  #{w}" })
+    lines << ""
+    lines << "Flog failures (>= #{method_fail}):"
+    lines.concat(failures.empty? ? ["  (none)"] : failures.map { |f| "  #{f}" })
+    File.write("flog_output.txt", "#{lines.join("\n")}\n")
+
+    puts "Flog: #{failures.size} failure(s), #{warnings.size} warning(s) (see flog_output.txt)"
+    result
+  end
+
+  desc "Check for structural code duplication with Flay (mass >= 150)"
+  def flay_check
+    require "flay"
+
+    mass_threshold = 150
+
+    flay = Flay.new(mass: mass_threshold, diff: false, verbose: false, summary: false, timeout: 60)
+    flay.process(*Dir.glob("lib/**/*.rb"))
+    flay.analyze
+
+    result = flay.hashes.empty? ? :pass : :fail
+
+    File.open("flay_output.txt", "w") do |f|
+      if result == :pass
+        f.puts "Flay: no structural duplication detected (mass >= #{mass_threshold})"
+      else
+        flay.report(f)
+      end
+    end
+    puts "Flay: #{flay.hashes.size} duplication pattern(s) found (mass >= #{mass_threshold}) (see flay_output.txt)"
+    result
+  end
+
+  desc "Check code smells with Reek"
+  def reek_check
+    output = `bundle exec reek lib 2>&1`
+    result = $?.success? ? :pass : :fail
+    File.write("reek_output.txt", output)
+    summary = output.lines.reverse.find { |l| l =~ /total warnings?/ }&.strip || result.to_s
+    puts "Reek: #{summary} (see reek_output.txt)"
+    result
+  end
+
+  desc "Check spelling with typos"
+  def typos_check
+    return skip_typos unless command_available?("typos")
+
+    output = `typos 2>&1`
+    result = $?.success? ? :pass : :fail
+    File.write("typos_output.txt", output)
+    count   = output.lines.count { |l| l.start_with?("error:") }
+    summary = result == :pass ? "no typos found" : "#{count} typo(s) found"
+    puts "Typos: #{summary} (see typos_output.txt)"
+    result
+  end
+
+  desc "Auto-correct typos"
+  def typos_fix
+    return skip_typos unless command_available?("typos")
+
+    sh "typos -w"
+  end
+
+  desc "Check ERB templates for style and safety issues with ERBLint"
+  def erb_lint_check
+    return skip_erb_lint if Dir.glob("**/*.erb").empty?
+
+    output = `bundle exec erb_lint --lint-all --enable-all-linters 2>&1`
+    result = $?.success? ? :pass : :fail
+    File.write("erb_lint_output.txt", output)
+    summary = output.lines.reverse.find { |l| l =~ /error\(s\)|no errors were found/i }&.strip || result.to_s
+    puts "ERBLint: #{summary} (see erb_lint_output.txt)"
+    result
+  end
+
+  desc "Check for performance suggestions with Fasterer"
+  def fasterer_check
+    output = `bundle exec fasterer lib 2>&1`.gsub(/\e\[\d+m/, "")
+    result = $?.success? ? :pass : :warn
+    File.write("fasterer_output.txt", output)
+    summary = output.lines.find { |l| l =~ /files? inspected/ }&.strip || result.to_s
+    puts "Fasterer: #{summary} (see fasterer_output.txt)"
+    result
+  end
+
+  desc "Check Gemfile.lock for known vulnerabilities with bundler-audit"
+  def bundler_audit_check
+    output = `bundle exec bundle-audit check --update 2>&1`
+    result = $?.success? ? :pass : :fail
+    File.write("bundler_audit_output.txt", output)
+    summary = output.lines.reverse.find { |l| l =~ /vulnerabilit/i }&.strip || result.to_s
+    puts "Bundler Audit: #{summary} (see bundler_audit_output.txt)"
+    result
+  end
+
+  desc "Check architecture boundaries with ArchSpec"
+  def archspec_check
+    return skip_archspec unless command_available?("archspec") && File.exist?("Archspec.rb")
+
+    output = `archspec check 2>&1`
+    result = $?.success? ? :pass : :fail
+    File.write("archspec_output.txt", output)
+    summary = output.lines.reverse.find { |l| l =~ /architecture violations? found|ArchSpec passed/i }&.strip ||
+      result.to_s
+    puts "ArchSpec: #{summary} (see archspec_output.txt)"
+    result
+  end
+
+  # Curated display labels for the *_check tasks defined in this file. A
+  # *_check task from elsewhere (e.g. quality_rails.loki's brakeman_check,
+  # loaded automatically once Rails is defined) isn't listed here — it just
+  # falls back to a titleized version of its own name in quality_gate_label.
+  QUALITY_GATE_LABELS = {
+    "test_check"     => "Tests + Coverage",
+    "rubocop_check"  => "RuboCop",
+    "flog_check"     => "Flog Complexity",
+    "flay_check"     => "Flay Duplication",
+    "reek_check"     => "Reek Smells",
+    "erb_lint_check" => "ERBLint",
+    "archspec_check" => "ArchSpec",
+  }.freeze
+
+  no_commands do
+    # true if +name+ resolves to an executable file somewhere on PATH.
+    def command_available?(name)
+      ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? do |dir|
+        File.executable?(File.join(dir, name))
+      end
+    end
+
+    def quality_gate_label(check_name)
+      QUALITY_GATE_LABELS.fetch(check_name) do
+        check_name.delete_suffix("_check").split("_").map(&:capitalize).join(" ")
+      end
+    end
+
+    def skip_typos
+      puts "Typos: SKIPPED — `typos` command not found. Install it with `brew install typos-cli`."
+      :skip
+    end
+
+    def skip_erb_lint
+      puts "ERBLint: SKIPPED — no .erb files found."
+      :skip
+    end
+
+    def skip_archspec
+      reason = command_available?("archspec") ? "no Archspec.rb found" : "`archspec` command not found"
+      puts "ArchSpec: SKIPPED — #{reason}. Install it with `gem install archspec` " \
+        "and run `archspec init` to generate one."
+      :skip
+    end
+
+    # Status badges. Only :fail is blocking (aborts the quality task);
+    # :skip (a required tool isn't installed) and :warn (the check ran but
+    # has non-blocking suggestions, e.g. a performance-hint gate) are not.
+    STATUS_BADGES = {
+      pass: ["PASS", 32], # green
+      fail: ["FAIL", 31], # red
+      warn: ["WARN", 33], # yellow
+      skip: ["SKIP", 36], # cyan
+    }.freeze
+
+    # Colorized status badges plus a pass/fail/warn/skip tally; aborts only
+    # if any gate failed — skip and warn are informational, not blocking.
+    def print_quality_summary(results)
+      colorize_badge = ->(code, text) { "\e[#{code}m#{text}\e[0m" }
+      width = results.keys.map(&:length).max
+
+      puts "\n#{"=" * 60}"
+      puts "Quality Gate Summary"
+      puts "=" * 60
+      results.each do |label, status|
+        text, code = STATUS_BADGES.fetch(status)
+        puts "  [#{colorize_badge.call(code, text)}] #{label.ljust(width)}"
+      end
+      puts "-" * 60
+
+      counts = results.values.tally
+      failed = counts[:fail] || 0
+      tally  = STATUS_BADGES.keys.filter_map { |s| "#{counts[s]} #{s}" if counts[s]&.positive? }.join(", ")
+      puts "  #{colorize_badge.call(failed.zero? ? 32 : 31, tally)}"
+      puts "=" * 60
+
+      abort "\n#{colorize_badge.call(31, "Quality gate failed.")}" unless failed.zero?
+      puts "\n#{colorize_badge.call(32, "All quality gates passed.")}"
+    end
   end
 end

data/quality_rails.loki

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+# Rails-specific quality gate tasks — imported by .loki only when the Rails
+# constant is defined.
+#
+# `quality` (in quality.loki) discovers every *_check task at run time by
+# introspecting Tasks.all_commands, rather than a fixed depends_on list — so
+# any *_check task defined here is automatically picked up by `asgard
+# quality` too, with no need to redeclare or extend anything.
+#
+# Note on rubocop-rails: it's a RuboCop plugin, not a standalone CLI, so it
+# has no *_check task of its own here. Add the gem to the app's Gemfile and
+# `require: rubocop-rails` in its .rubocop.yml — the existing rubocop_check
+# (quality.loki) picks up the added Rails cops automatically.
+
+class Tasks
+  desc "Check for Rails security vulnerabilities with Brakeman"
+  def brakeman_check
+    output = `bundle exec brakeman -q 2>&1`
+    result = $?.success? ? :pass : :fail
+    File.write("brakeman_output.txt", output)
+    summary = output.lines.reverse.find { |l| l =~ /warnings? found/i }&.strip || result.to_s
+    puts "Brakeman: #{summary} (see brakeman_output.txt)"
+    result
+  end
+
+  desc "Check for Rails anti-patterns with RailsBestPractices"
+  def rails_best_practices_check
+    output = `bundle exec rails_best_practices --silent --without-color . 2>&1`
+    result = $?.success? ? :pass : :fail
+    File.write("rails_best_practices_output.txt", output)
+    summary = output.lines.reverse.find { |l| l =~ /warning/i }&.strip || result.to_s
+    puts "RailsBestPractices: #{summary} (see rails_best_practices_output.txt)"
+    result
+  end
+
+  desc "Check for database schema issues with ActiveRecordDoctor"
+  def active_record_doctor_check
+    output = `bundle exec rake active_record_doctor 2>&1`
+    result = $?.success? ? :pass : :fail
+    File.write("active_record_doctor_output.txt", output)
+    issue_count = output.lines.count { |l| l.strip != "" }
+    summary = result == :pass ? "no issues found" : "#{issue_count} issue line(s) found"
+    puts "ActiveRecordDoctor: #{summary} (see active_record_doctor_output.txt)"
+    result
+  end
+end

data/xyzzy.loki

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+# example of an overwritten task detected by (--doctor) — imported by .loki
+
+class Tasks
+  desc "Push the current branch to its remote"
+  def xyzzy = puts <<~MAGIC
+    You are at a fork in the yellow brick road to AI.
+    To the left is python, the favorite programming language of snake charmers.
+    To the right is Ruby, the best computer programming language of all time.
+    Which way do you go?
+  MAGIC
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asgard
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -23,20 +23,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: dagwood
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement
@@ -65,7 +51,9 @@ files:
 - ".envrc"
 - ".github/workflows/deploy-github-pages.yml"
 - ".loki"
+- ".reek.yml"
 - ".rubocop.yml"
+- Archspec.rb
 - CHANGELOG.md
 - CLAUDE.md
 - COMMITS.md
@@ -92,6 +80,7 @@ files:
 - docs/variables.md
 - examples/.env
 - examples/.loki
+- examples/bad.loki
 - examples/concurrent.loki
 - examples/db_subcommands.loki
 - examples/env_usage.loki
@@ -101,15 +90,25 @@ files:
 - examples/subdir/import_demo.loki
 - examples/subdir/import_up_demo.loki
 - gem_tasks.loki
+- git.loki
 - lib/asgard.rb
 - lib/asgard/base.rb
+- lib/asgard/base/dependency_graph.rb
+- lib/asgard/base/dispatch.rb
+- lib/asgard/base/registry.rb
+- lib/asgard/base/task_dsl.rb
+- lib/asgard/doctor.rb
+- lib/asgard/doctor/report.rb
+- lib/asgard/doctor/task_sections.rb
 - lib/asgard/kernel_methods.rb
 - lib/asgard/shell.rb
 - lib/asgard/tasks.rb
 - lib/asgard/version.rb
 - mkdocs.yml
 - quality.loki
+- quality_rails.loki
 - sig/asgard.rbs
+- xyzzy.loki
 homepage: https://github.com/madbomber/asgard
 licenses:
 - MIT
@@ -132,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.12
+rubygems_version: 4.0.19
 specification_version: 4
 summary: A powerful Ruby-based task runner
 test_files: []