namo.rb 0.32.2 → 0.32.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2cdcd36cc0d3b94a3d75d935ec816993f2b11946b53934f93225ec24f38b9567
-  data.tar.gz: 3f6359e0309eadfe76a206e4324918567b3b097704dba6a502d1e20eacd36e6f
+  metadata.gz: 53b03d4045a0b90e48ab18b834da6989c9ef3f2312201980bcf237e2eb59e524
+  data.tar.gz: f553c3f071bab22000a02cc7a177a23209eee2a85f29fe6cd98f718238311542
 SHA512:
-  metadata.gz: 8218b30ec72a118656fcadd27af5a9213b2785d62642712a7c5bcc5cddc4195c01983a0477326a582d4657fe7f1c3b3a4842534121407d53a2183de41b661f58
-  data.tar.gz: 2ed7ed7d9ca94c3cba1c878c56c4319cad59c04e2d1d7f50f82e78174bbc2cb3c8a826098d3e3fb509b7584b8efba2471b942b145390b1d6c0d868b5545ce866
+  metadata.gz: 19da5053f77a492572812811375007b4f3b91bcfd56335b6ae011c22e60c09ab6a30cbb393d5ef78ce42ed493be5afdff73a692db02769c026a4063fed4dfaf0
+  data.tar.gz: 379ebab7255ecc861e16b95fb076a949736ccdad3f22d3c97f42168ef7f9c77bb1d2f45014cb047fe7ecf24f0e233c139ba5da1e84a3a51f61813142552f7e3c

data/CHANGELOG

@@ -2,6 +2,26 @@
 
 ## 20260828
 
+0.32.4: ~ README.md: + Console, the command the gem has shipped since 0.32.0 going unmentioned until now.
+
+1. ~ README.md: + Console. `namo console` and `namo setup` had appeared nowhere: the gem gained an executable at 0.32.0 and the README named install.sh once, in the curl line, and the command not at all. Someone taking `gem install namo`, the first line of Installation, arrived at the library without learning that the console existed.
+2. ~ README.md: + the clone route, `git clone` and ./install.sh, which is the route the adjacent-bin/namo handover of 0.32.3 was written for and the one route no line described.
+3. ~ README.md: `gem install` and the Gemfile line say what they leave undone — the command is on the PATH only where gem's own directory is, which Homebrew's Ruby is the case against, and measurand arrives by `namo setup` rather than with the gem, a gemspec having no way to name a companion which is optional.
+4. ~ CHANGELOG: the 20260828 releases gather under one heading, as 20260824 and 20260826 gather theirs. Four releases in a day had taken a heading each.
+5. ~ Namo::VERSION: /0.32.3/0.32.4/
+
+
+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/
+
+
 0.32.2: ~ install.sh: the one command ends with namo runnable from anywhere.
 
 1. ~ install.sh: + add_to_path, + gem_bin_directory, + shell_configuration_file. gem puts the command in a directory which is on the PATH on some machines and not on others — Homebrew's ruby puts it somewhere which is not — so the run ended by naming the directory and stopping. It now offers to add it to the shell's configuration file, and adds it to the PATH of the run itself so that `namo setup` happens rather than being left as a further instruction.
@@ -11,8 +31,6 @@
 5. ~ Namo::VERSION: /0.32.1/0.32.2/
 
 
-## 20260828
-
 0.32.1: ~ install.sh: it runs the same piped from curl as from a clone, and forces no package manager; ~ README.md: + the one-line install.
 
 1. ~ install.sh: the handover is to `namo setup` on the PATH rather than to bin/namo beside the script. It had found bin/namo by its own path, so piped from curl it looked in the working directory and failed there. It now finds nothing by its path and so runs from anywhere. The check is for the namo command rather than for the gem, that being what the next step needs: an older namo installs no executable.
@@ -22,8 +40,6 @@
 5. ~ Namo::VERSION: /0.32.0/0.32.1/
 
 
-## 20260828
-
 0.32.0: + bin/namo, the gem's first executable, and the gems it installs.
 
 1. + bin/namo: a setup subcommand which installs the gems Namo's scripts want — Namo itself, so that a clone leaves require 'namo' working, and measurand, which the demo's uncertainty section does without when it is missing — and a console subcommand which is bin/console. Each step asks first and says so when there is nothing to do.

data/README.md

@@ -18,12 +18,42 @@ 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:
+Either brings the `namo` command with it, where the directory gem installs commands into is one your PATH reaches — it is on a Ruby from ruby-install or rbenv, and is not on Homebrew's. `namo setup` then adds measurand, which the uncertainty examples want and which nothing else does.
+
+Or from a clone, which wants none of it installed first:
+
+```
+git clone https://github.com/thoran/namo.git
+cd namo
+./install.sh
+```
+
+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)"
 ```
 
+The two which run `install.sh` end at a `namo` which runs from anywhere. The first ends at one which runs where your PATH already reaches it.
+
+## Console
+
+The gem ships one command.
+
+```
+namo console
+```
+
+An irb session with Namo loaded, for asking a question of the library without writing a file first.
+
+```
+namo setup
+```
+
+Installs the gems the scripts want — namo itself, and measurand — skipping whichever is already there and naming each and its version either way. `install.sh` runs it as the last of its own work, so it is here for a gem which arrived by `gem install`, and for adding measurand to an installation which went without it.
+
+`namo` alone prints the usage, as `namo --help` does.
+
 ## Usage
 
 Create a Namo instance from an array of hashes:

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.4'
 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.rb
 version: !ruby/object:Gem::Version
-  version: 0.32.2
+  version: 0.32.4
 platform: ruby
 authors:
 - thoran