classnamer 3.0.9 → 3.0.12

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2022 Aaron Beckerman
+Copyright (c) 2011-2025 Aaron Beckerman
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

data/{README.rdoc → README.txt}

@@ -1,24 +1,21 @@
-= \Classnamer
+Classnamer
 
-Classnamer randomly generates tongue-in-cheek class names suitable for
-enterprise-friendly object-oriented programming languages like C++ and Java. It
-includes a library and a command-line program.
+Classnamer randomly generates facetious class names suitable for
+object-oriented programming languages like C++ and Java. It includes a Ruby
+library and command-line program.
 
-This code is packaged as a RubyGem and tested on the following branches of
-MRI (Matz's Ruby Interpreter): 1.8.7, 1.9.3, 2.0.0, 2.1.x, and 2.2.x.
 
-
-== Using the command-line program
+Using the command-line program
 
   $ classnamer
   PrioritizedUploadWrapper
 
 
-== Using in Ruby code
+Using in Ruby code
 
 You can generate a random class name like this:
 
-  require 'classnamer'
+  require "classnamer"
   puts Classnamer.generate # => PrioritizedUploadWrapper
 
 You can customize how class names are generated. Classnamer will generate
@@ -41,17 +38,6 @@ a Classnamer::Generator object for that.
   generator.generate # => BarQux
 
 
-== Author
-
-This was written by Aaron Beckerman.
-
-
-== Acknowledgements
+Acknowledgements
 
 Thanks to Luiz Signorelli and Marta Paciorkowska for their suggestions.
-
-
-== Copyright
-
-This code is distributed under the MIT License (also known as the Expat
-License). See the LICENSE.txt file for details.

data/bin/classnamer

@@ -1,17 +1,17 @@
 #!/usr/bin/env ruby
 
-require 'optparse'
-require 'classnamer'
+require "optparse"
+require "classnamer"
 
 OptionParser.new do |opts|
-  opts.banner = 'Usage: classnamer [options]'
+  opts.banner = "Usage: classnamer [options]"
 
-  opts.on_tail '-v', '--version', 'Show version number' do
+  opts.on_tail "-v", "--version", "Show version number" do
     puts Classnamer::VERSION
     exit
   end
 
-  opts.on_tail '-h', '--help', 'Show this message' do
+  opts.on_tail "-h", "--help", "Show this message" do
     puts opts
     exit
   end

data/lib/classnamer.rb

@@ -1,15 +1,21 @@
+##
 # This module randomly generates class names, such as
 # "PrioritizedUploadWrapper". It does this by concatenating several parts
 # ("Prioritized", "Upload", and "Wrapper", in this case), which are strings
-# randomly selected from arrays of candidates. ("Prioritized", "Upload", and
-# "Wrapper" were each selected from a different array.) An array of such arrays
+# randomly selected from arrays of candidates ("Prioritized", "Upload", and
+# "Wrapper" were each selected from a different array). An array of such arrays
 # is called a part candidate matrix.
+
 module Classnamer
 
+  ##
   # The library's version string.
-  VERSION = '3.0.9'
 
+  VERSION = "3.0.12"
+
+  ##
   # The default part candidate matrix, used by generate.
+
   PART_CANDIDATE_MATRIX = [
     %w{Threadsafe Optimized Stable Automatic Abstract Serializable Writable
        Readable Blocking Nonblocking Scriptable Smart Basic Remote Simple
@@ -36,36 +42,48 @@ module Classnamer
        Constraint Module Migrator Descriptor Process}
   ]
 
+  ##
   # The default index generator, used by generate.
-  PRNG = ::Kernel.method(:rand)
-
-  # This method does the actual work of randomly generating a class name. It
-  # takes two arguments, both optional: a part candidate matrix (+matrix+) and
-  # an index generator (+prng+). If +matrix+ is not specified, the module's
-  # default part candidate matrix (PART_CANDIDATE_MATRIX) is used. If +prng+ is
-  # not specified, Kernel::rand is used. +matrix+ must act like an array of
-  # arrays of strings. +prng+ will be sent "call" messages with one integer
-  # argument (an array length) and must act like Kernel::rand with an integer
-  # argument.
-  def self.generate(matrix = self::PART_CANDIDATE_MATRIX, prng = self::PRNG)
-    matrix.map { |a| a[prng.call a.length] }.join ''
+
+  PRNG = ::Kernel.method :rand
+
+  ##
+  # Randomly generates a class name and returns it. This method takes two
+  # arguments, both optional: a part candidate matrix (+matrix+) and an index
+  # generator (+prng+). If +matrix+ is not specified, the module's default part
+  # candidate matrix (PART_CANDIDATE_MATRIX) is used. If +prng+ is not
+  # specified, Kernel::rand is used. +matrix+ must act like an array of arrays
+  # of strings. +prng+ will be sent call messages with one integer argument
+  # (an array length) and must act like Kernel::rand with an integer argument.
+
+  def self.generate matrix = PART_CANDIDATE_MATRIX, prng = PRNG
+    matrix.map { |a| a[prng.call a.length] }.join ""
   end
 
+  ##
   # A class name generator that always uses the specified part candidate matrix
   # and index generator.
+
   class Generator
+
+    ##
     # Creates a class name generator with the specified part candidate matrix
     # and index generator.
-    def initialize(matrix = Classnamer::PART_CANDIDATE_MATRIX,
-      prng = Classnamer::PRNG)
+
+    def initialize matrix = PART_CANDIDATE_MATRIX, prng = PRNG
       @matrix = matrix
       @prng = prng
+      nil
     end
 
-    # Generates a class name using the part candidate matrix and index
-    # generator passed in when the object was created.
+    ##
+    # Generates and returns a class name using the part candidate matrix and
+    # index generator specified when the generator was created.
+
     def generate
       Classnamer.generate @matrix, @prng
     end
+
   end
+
 end

data/test/classnamer_test.rb

@@ -1,20 +1,48 @@
-require 'classnamer'
+# Sections that create local variables are in class definitions so that later
+# sections cannot accidentally reference those local variables.
 
-String == Classnamer::VERSION.class or fail
+require "classnamer"
 
-3 == Classnamer::PART_CANDIDATE_MATRIX.length or fail
+# Classnamer should be a module.
+fail "" unless Module.equal? Classnamer.class
 
-Classnamer::PART_CANDIDATE_MATRIX.flatten(1).
-  all? { |part_candidate| /\A[A-Z]/ =~ part_candidate } or fail
+# The version constant should be a string.
+fail "" unless String.equal? Classnamer::VERSION.class
 
-Classnamer.respond_to?(:generate) or fail
+# The default part candidate matrix should be an array.
+fail "" unless Array.equal? Classnamer::PART_CANDIDATE_MATRIX.class
 
-String == Classnamer.generate.class or fail
+# The default part candidate matrix should have three sections.
+fail "" unless 3 == Classnamer::PART_CANDIDATE_MATRIX.length
 
-'42ObjecttrueSymbolFoo' == Classnamer.generate(
-  [[42], [Object], [nil], [true], [:Symbol], ['Foo']]) or fail
+# The default part candidate matrix should contain only arrays.
+fail "" unless Classnamer::PART_CANDIDATE_MATRIX.
+  all? { |elem| ::Array.equal? elem.class }
 
-lambda do
+# Each default part candidate should start with an uppercase English letter.
+fail "" unless Classnamer::PART_CANDIDATE_MATRIX.flatten(1).
+  all? { |part_candidate| /\A[A-Z]/ =~ part_candidate }
+
+# The default index generator should be a wrapper around Kernel.rand.
+fail "" unless Kernel.method(:rand) == Classnamer::PRNG
+
+# The default index generator should return a valid index when a call message
+# is sent to it with a length argument.
+fail "" unless 0 == Classnamer::PRNG.call(1)
+
+# Classnamer should say it responds to generate messages.
+fail "" unless Classnamer.respond_to? :generate
+
+# Classnamer.generate should return a string.
+fail "" unless String.equal? Classnamer.generate.class
+
+# Classnamer.generate should convert all the parts to strings.
+fail "" unless "42ObjecttrueSymbolFoo" ==
+  Classnamer.generate([[42], [Object], [nil], [true], [:Symbol], ["Foo"]])
+
+# Classnamer.generate should send the expected messages to the index generator
+# given as an argument.
+class ::Object
   matrix = [%w{A B C}, [], %w{A B}, %w{A}]
   prng_args = []
   prng = lambda { |n|
@@ -22,52 +50,73 @@ lambda do
     0
   }
   Classnamer.generate matrix, prng
-  [3, 0, 2, 1] == prng_args or fail
-end.call
+  fail "" unless [3, 0, 2, 1] == prng_args
+end
 
-lambda do
+# Classnamer should return the expected string when sent a generate message
+# with a deterministic index generator as an argument.
+class ::Object
   matrix = [%w{Foo0 Foo1 Foo2}, %w{Bar0 Bar1 Bar2}, %w{Baz0 Baz1 Baz2}]
   indices = [0, 2, 1]
-  'Foo0Bar2Baz1' == Classnamer.generate(matrix, lambda { |_| indices.shift }) \
-    or fail
-end.call
-
-'Foo' == Classnamer.generate([['Foo']]) or fail
-
-'' == Classnamer.generate([]) or fail
+  fail "" unless "Foo0Bar2Baz1" ==
+    Classnamer.generate(matrix, lambda { |_| indices.shift })
+end
 
-'' == Classnamer.generate([[], [], []]) or fail
+# Classnamer.generate should return the expected strings when given part
+# candidate matrices consisting of empty and single-element arrays.
+fail "" unless "Foo" == Classnamer.generate([["Foo"]])
+fail "" unless "" == Classnamer.generate([])
+fail "" unless "" == Classnamer.generate([[], [], []])
+
+# Classnamer.generate should create a new string and not modify any parts.
+class ::Object
+  a = "a"
+  b = "b"
+  name = Classnamer.generate [[a], [b]]
+  fail "" if a.equal? name
+  fail "" if b.equal? name
+  fail "" unless "a" == a
+  fail "" unless "b" == b
+end
 
+# Classnamer.generate should raise an exception when given a part candidate
+# matrix that does not conform to the expected interface as an argument.
 begin
   Classnamer.generate nil
 rescue NoMethodError
 else
-  fail
+  fail ""
 end
-
 begin
-  Classnamer.generate Classnamer::PART_CANDIDATE_MATRIX, nil
+  Classnamer.generate [["Foo"], nil]
 rescue NoMethodError
 else
-  fail
+  fail ""
 end
 
+# Classnamer.generate should raise an exception when given an index generator
+# that does not conform to the expected interface as an argument.
 begin
-  Classnamer.generate [['Foo'], nil]
+  Classnamer.generate Classnamer::PART_CANDIDATE_MATRIX, nil
 rescue NoMethodError
 else
-  fail
+  fail ""
 end
 
-Classnamer::Generator == Classnamer::Generator.new.class or fail
+# Classnamer::Generator.new should return a generator of the expected class.
+fail "" unless Classnamer::Generator.equal? Classnamer::Generator.new.class
 
-Classnamer::Generator.new.respond_to?(:generate) or fail
+# A generator should say it responds to generate messages.
+fail "" unless Classnamer::Generator.new.respond_to? :generate
 
-lambda do
+# A generator with a deterministic index generator should return the expected
+# name when sent a generate message.
+class ::Object
   matrix = [%w{Foo0 Foo1 Foo2}, %w{Bar0 Bar1 Bar2}, %w{Baz0 Baz1 Baz2}]
   indices = [0, 2, 1]
-  generator = Classnamer::Generator.new(matrix, lambda { |_| indices.shift })
-  'Foo0Bar2Baz1' == generator.generate or fail
-end.call
+  generator = Classnamer::Generator.new matrix, lambda { |_| indices.shift }
+  fail "" unless "Foo0Bar2Baz1" == generator.generate
+end
 
-puts 'Test finished.'
+# If this message doesn't get written, there was a problem.
+puts "Test finished: #{__FILE__}"

metadata

@@ -1,52 +1,73 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: classnamer
-version: !ruby/object:Gem::Version
-  version: 3.0.9
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: 
+  segments: 
+  - 3
+  - 0
+  - 12
+  version: 3.0.12
 platform: ruby
-authors:
+authors: 
 - Aaron Beckerman
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-11-13 00:00:00.000000000 Z
+
+date: 2025-05-16 00:00:00 -07:00
+default_executable: 
 dependencies: []
-description: Classnamer randomly generates tongue-in-cheek class names suitable for
-  enterprise-friendly object-oriented programming languages like C++ and Java. It
-  includes a library and a command-line program.
-email:
-executables:
+
+description: Classnamer randomly generates facetious class names suitable for object-oriented programming languages like C++ and Java. It includes a library and command-line program.
+email: 
+executables: 
 - classnamer
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - LICENSE.txt
-- README.rdoc
+- README.txt
 - bin/classnamer
-- classnamer.gemspec
 - lib/classnamer.rb
 - test/classnamer_test.rb
-homepage:
-licenses:
+has_rdoc: true
+homepage: 
+licenses: 
 - MIT
-metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
-  requirements:
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
   - - ">="
-    - !ruby/object:Gem::Version
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
       version: 1.8.7
-required_rubygems_version: !ruby/object:Gem::Requirement
-  requirements:
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
   - - ">="
-    - !ruby/object:Gem::Version
-      version: '0'
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
-specification_version: 4
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
 summary: A random class name generator.
-test_files:
-- test/classnamer_test.rb
+test_files: []
+

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA256:
-  metadata.gz: d27a21e3575373a7dd8339fc51f8f06fa691ec94575523da070ccd4afe8608cc
-  data.tar.gz: 1de71f5634a0f8ab76f4cdafd584489e8cbe10ea14de32f8cfb264291c512037
-SHA512:
-  metadata.gz: e3b75eee842eb2de0866e81c81e9457db9622e4fbe7ab8c914fc954c23393c54371eb69a722cc23d00cd490148aca40762d743f1a15c04c157ae5cce9f046469
-  data.tar.gz: 3e14a92ade9675a6e15210a7f14e7d17a3d09ac764d6e61fe101c0f61cf9dea733c2707f56458a1d65c3af04522d8e4b14eb7cf1e8393c7c6ae156ea68a6826e

data/classnamer.gemspec

@@ -1,20 +0,0 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "classnamer"
-
-Gem::Specification.new do |s|
-  s.name = "classnamer"
-  s.version = Classnamer::VERSION
-  s.author = "Aaron Beckerman"
-  s.summary = %q{A random class name generator.}
-  s.description = %q{Classnamer randomly generates tongue-in-cheek class names suitable for enterprise-friendly object-oriented programming languages like C++ and Java. It includes a library and a command-line program.}
-  s.license = "MIT"
-  s.platform = Gem::Platform::RUBY
-  s.required_ruby_version = ">= 1.8.7"
-  s.bindir = "bin"
-  s.files = ["LICENSE.txt", "README.rdoc", "bin/classnamer", "classnamer.gemspec", "lib/classnamer.rb", "test/classnamer_test.rb"]
-  s.test_files = ["test/classnamer_test.rb"]
-  s.executables = ["classnamer"]
-  s.require_paths = ["lib"]
-end