namo 0.32.2 → 0.32.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 175cb09542235c37007cf26ce5146a1c4a92b3ed19f8d30c261e225994f2881b
-  data.tar.gz: 95eda631ef9ce13aa633c9c6fc17ea1ee6141dc234604a6add9a2912d0a9de78
+  metadata.gz: 1cd9dd8978eec2325228fe1c867977bb3a7d3392d97884da2cd92b497f7defd3
+  data.tar.gz: 71c01853d939dfecfb060e796b16ee8f29e050e2509657a68078f136f752299b
 SHA512:
-  metadata.gz: 4b80fbc059a6824450688df197ca403fd89a74deb2a53f3105985fa4356bec340afdb812eb935906bb1583c52378e5ee784efed155c3c7043c7d353ff4b53a79
-  data.tar.gz: 9fbe3169c001aac490cd012c1005c92da2a714faed70db57030d36332de589e9c9c424b37ddd304f4055904c633544d3f598294c28327fcf106f44aae645cb1d
+  metadata.gz: 9c8f2926ab8e9f94c06a72873c0b20d65754fc1bc5a08f76aeac791bcbb24b12c8909a89d62d7a89df313115f575821eea707ee7836df2d4fe0e682ea9794efc
+  data.tar.gz: 9cea051b58185b3ba6d64d737d1d2da6f72378d628cfd7fe196e80f82619cc5ccfcfc06af02ba3400500d45b62dc85e6c51ae92e4f48e2a2570491fb6328a40b

data/CHANGELOG

@@ -1,5 +1,18 @@
 # CHANGELOG
 
+## 20260828
+
+0.32.3: ~ install.sh: + ruby-install, for a machine with no package manager at all; the handover is to a clone's own bin/namo where the script was run from one.
+
+1. ~ install.sh: + install_ruby_install, + ruby_from_ruby_install. Where no package manager is found and Homebrew is declined, ruby-install is offered — fetched from its latest release rather than a pinned version, built with make as root, and used to build Ruby. It is the last thing tried and the only route here which builds Ruby rather than fetching it.
+2. ~ install.sh: ruby-install leaves its Ruby under ~/.rubies, which nothing puts on the PATH — chruby's job, and chruby is not there either — so that directory is added to the PATH of the run and offered to the shell's configuration, as the gem's own directory is.
+3. ~ install.sh: + wants_on_path, and add_to_path takes none. A machine taking the ruby-install route has a Ruby under ~/.rubies and its gems elsewhere, so two directories want adding; they are gathered as they are found and the shell configuration is written to once, naming both, rather than the same question being asked twice seconds apart. Each is put on the running PATH as it is found, so that `namo setup` happens whether or not the file is written to.
+4. ~ install.sh: install_namo runs gem install rather than skipping where the command is present. gem install is idempotent for a version already installed and fetches a newer one where there is one, so this is what makes a second run an upgrade.
+5. ~ bin/namo: + gem_version, + report. Each check states the gem, its version and its status on one line, where the announcement had been a sentence carrying no version — the version being the part neither script had said. install.sh reports in the same shape, and its namo step speaks only where something changed — installed, or upgraded from a version — since gem install says "Successfully installed" whether or not it did anything, and `namo setup` reports the gem and its version a moment later regardless.
+6. ~ install.sh: + repository, and hand_over takes the clone it was given. install_namo is the bootstrap for the handover and nothing else — a way to have a namo command to run — so a script run from a checkout hands over to that checkout's bin/namo and leaves the gem to `namo setup`, which installs it as its own first act. A checkout with the gem not yet installed now works as it stands, and the gem is named once rather than by both scripts in turn. 0.32.1 had taken the path lookup out for being unconditional, which failed piped from curl where the working directory is not a checkout; it is guarded now on $0 being a readable file beside both bin/namo and the gemspec, none of which holds for the shell's own name, so the curl route finds nothing and installs the gem as it did.
+7. ~ Namo::VERSION: /0.32.2/0.32.3/
+
+
 ## 20260828
 
 0.32.2: ~ install.sh: the one command ends with namo runnable from anywhere.

data/README.md

@@ -18,7 +18,7 @@ Or in your Gemfile:
 gem 'namo'
 ```
 
-Or from nothing at all — Ruby, the gem, and the gems its scripts want, each step skipped where it is already there. Where Ruby is missing, whichever package manager is already installed supplies it — Homebrew, MacPorts, apt, dnf, pacman or zypper; where none is, you are asked before Homebrew is installed; `-y` answers yes in advance, and a machine with nobody at the keyboard is taken to have said no. Where the gem's own directory is not on the PATH, it offers to add it to your shell's configuration, so that a new shell has `namo` in it:
+Or from nothing at all — Ruby, the gem, and the gems its scripts want, each step skipped where it is already there. Where Ruby is missing, whichever package manager is already installed supplies it — Homebrew, MacPorts, apt, dnf, pacman or zypper; where none is, you are asked before Homebrew is installed, and then before ruby-install is built from source; `-y` answers yes in advance, and a machine with nobody at the keyboard is taken to have said no. Where the gem's own directory is not on the PATH, it offers to add it to your shell's configuration, so that a new shell has `namo` in it:
 
 ```
 sh -c "$(curl -fsSL https://raw.githubusercontent.com/thoran/namo/master/install.sh)"

data/bin/namo

@@ -31,20 +31,31 @@ def gem_installed?(name)
   system("gem list -i #{name} > /dev/null 2>&1")
 end
 
+def gem_version(name)
+  Gem::Specification.find_all_by_name(name).map(&:version).max
+rescue StandardError
+  nil
+end
+
+def report(name, status)
+  puts format('  %-11s %-8s %s', name, gem_version(name) || '-', status)
+end
+
+# The status and the version, one line per check.  "already installed" on its own
+# was the second script announcing what install.sh had just done; the version is
+# what neither script has said, and is the reason to look.
 def install_gem(name)
   if gem_installed?(name)
-    puts "#{name} is already installed!"
+    report(name, 'already installed')
   else
     run("gem install #{name}")
+    report(name, 'installed')
   end
 end
 
-# Namo itself first: arriving by `git clone` leaves the source on disk and nothing
-# on the load path, so the gem is what makes `require 'namo'` work from anywhere
-# else.  Arriving by `gem install namo` has it already, and the step says so.
-#
-# measurand is the one the demo asks for and does without: its uncertainty section
-# skips itself when it is missing, and every other section runs regardless.
+# namo itself first: arriving by `git clone`, or by install.sh before the gem is
+# there, leaves nothing on the load path.  measurand the demo asks for and does
+# without, its uncertainty section skipping itself where it is missing.
 def setup
   install_gem('namo')
   install_gem('measurand')

data/lib/Namo/VERSION.rb

@@ -2,5 +2,5 @@
 # Namo::VERSION
 
 class Namo
-  VERSION = '0.32.2'
+  VERSION = '0.32.3'
 end

data/test/namo_command_test.rb

@@ -22,11 +22,15 @@ describe 'bin/namo' do
     _(output).must_match(/console/)
   end
 
-  it "reports rather than acts where a gem is already there" do
+  # A line per check carrying the status and the version.  "already installed" on
+  # its own repeated what install.sh had just done; the version is the part
+  # neither script has said, and the reason to read the line at all.
+  it "reports the status and version of each gem it checks" do
     output = namo('setup')
     _($?.success?).must_equal true
-    _(output).must_match(/namo is already installed!/)
-    _(output).must_match(/measurand is already installed!/)
+    _(output.lines.length).must_equal 2
+    _(output).must_match(/^\s+namo\s+\d+\.\d+\.\d+\s+already installed$/)
+    _(output).must_match(/^\s+measurand\s+\d+\.\d+\.\d+\s+already installed$/)
   end
 
   # install.sh is the part a Ruby script cannot do — the Ruby the script would be
@@ -34,8 +38,11 @@ describe 'bin/namo' do
   # syntax is asserted and its body is not run: a test which executed it on a
   # machine without Ruby would install Ruby.
   #
-  # It hands over by name rather than by path, which is what lets it run piped
-  # from curl — an assertion that it finds nothing by SCRIPT_DIR.
+  # It hands over to a clone's own bin/namo where it was run from one, and fetches
+  # the gem only where it was not: the gem is the bootstrap for the handover rather
+  # than a second opinion about what wants installing.  Piped from curl there is no
+  # clone to find, the guard being that $0 is a readable file at all, which the
+  # shell's own name is not.
   #
   # It installs Homebrew only through `agreed`, which answers no unless -y was
   # given or somebody is there to say yes.  What is asserted is that the curl of
@@ -52,8 +59,18 @@ describe 'bin/namo' do
       _(body).must_match(/command -v #{manager}/)
     end
     _(body).must_match(/ruby_routes/)
+    _(body).must_match(/install_ruby_install/)
+    # One prompt and one line however many directories want adding: the shell
+    # configuration is written to once, not once per directory.
+    _(body).must_match(/wants_on_path/)
+    _(body.scan(/>> "\$file"/).length).must_equal 1
+    # The tag is resolved from the latest release rather than pinned, so that the
+    # branch does not rot against a version.
+    _(body).wont_match(/ruby-install-0\.\d+\.\d+\.tar\.gz/)
     _(body).must_match(/namo setup/)
-    _(body).wont_match(/SCRIPT_DIR/)
+    _(body).must_match(/repository\(\) \{\n\s+\[ -f "\$0" \]/)
+    _(body).must_match(%r{"\$clone/bin/namo" setup})
+    _(body).must_match(/\[ -n "\$clone" \] \|\| install_namo/)
     _(body).must_match(/elif agreed .*Install Homebrew\?.*; then\n\s+\/bin\/bash -c/)
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: namo
 version: !ruby/object:Gem::Version
-  version: 0.32.2
+  version: 0.32.3
 platform: ruby
 authors:
 - thoran