classnamer 3.0.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 739adbbcad3a5bcf1cca2cdd2382c2353f2ab8c42a0f1e8d26aff6dccb9cbe8b
+  data.tar.gz: fca286e359dd7d1e24a8475bd24f4e93c77528ddddcc01c905376e4b819c6d97
+SHA512:
+  metadata.gz: 5dc4755ce5009c9e96b2c3e3f46d71c52a32cf9c2ff1d1686d786507cb3424f3085a7d68d43a9dcb62c9ef33313a5756acaeba80a2a22480715ad09bf9078fa1
+  data.tar.gz: 6bd9610baaec2587275b4514185452d203266834e1bdcbb2b49ee343e87e466e01511bd98a68792249d34f0e9050c7d71b90db3848e1c90d9f11bd8a48db82e3

data/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2018 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
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.rdoc

@@ -0,0 +1,57 @@
+= \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.
+
+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
+
+  $ classnamer
+  PrioritizedUploadWrapper
+
+
+== Using in Ruby code
+
+You can generate a random class name like this:
+
+  require 'classnamer'
+  puts Classnamer.generate # => PrioritizedUploadWrapper
+
+You can customize how class names are generated. Classnamer will generate
+random class names by concatenating randomly-selected elements of arrays that
+you provide.
+
+  puts Classnamer.generate([%w{Foo Bar}, %w{Baz Qux}]) # => FooQux
+
+You can also specify a custom random number generator. Maybe you don't even
+want it to be random.
+
+  puts Classnamer.generate([%w{Foo Bar}, %w{Baz Qux}], lambda { |_| 0 })
+    # => FooBaz
+
+If you plan to use the same customizations multiple times, you can create
+a Classnamer::Generator object for that.
+
+  generator = Classnamer::Generator.new([%w{Foo Bar}, %w{Baz Qux}])
+  generator.generate # => FooQux
+  generator.generate # => BarQux
+
+
+== Author
+
+This was written by Aaron Beckerman.
+
+
+== 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

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

data/classnamer.gemspec

@@ -0,0 +1,20 @@
+# -*- 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

data/lib/classnamer.rb

@@ -0,0 +1,70 @@
+# 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
+# is called a part candidate matrix.
+module Classnamer
+
+  # The library's version string.
+  VERSION = '3.0.8'
+
+  # 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
+       Secure Cryptographic Flexible Configurable Internal Cloneable Legacy
+       Recursive Multiple Threaded Virtual Singleton Stateless Stateful
+       Localized Prioritized Generic Dynamic Shared Modal Fast Temporary},
+    %w{Byte Task Object Resource Mutex Memory List Node File Lock Pixel
+       Character Command Client Server Socket Thread Notification Keystroke
+       Timestamp Raster String Hash Integer Cache Scrollbar Grid Package
+       Connection Database Graph Row Column Record Metadata Transaction Message
+       Request Response Query Statement Result Upload Download User Directory
+       Button Device Search Lolcat Robot},
+    %w{Sorter Allocator Tokenizer Writer Reader Randomizer Initializer Factory
+       Panel Frame Container Compressor Expander Counter Collector Collection
+       Wrapper Accumulator Table Marshaller Demarshaller Extractor Parser
+       Scanner Interpreter Validator Window Dialog Stream Listener Event
+       Exception Vector Lexer Analyzer Iterator Set Tree Concatenator Monitor
+       Tester Buffer Selector Visitor Adapter Helper Annotation Permission
+       Info Action Channel Filter Manager Mediator Operation Context Queue
+       Stack View Engine Publisher Subscriber Delegator State Processor Handler
+       Generator Dispatcher Bundle Builder Logger Iterator Observer Encoder
+       Decoder Importer Exporter Util Policy Preference Formatter Sequence
+       Comparator Definition Timer Classifier Controller Loader Converter
+       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+ must have a "call" method that takes one integer
+  # argument (an array length) and acts like Kernel::rand.
+  def self.generate(matrix = self::PART_CANDIDATE_MATRIX, prng = self::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)
+      @matrix = matrix
+      @prng = prng
+    end
+
+    # Generates a class name using the part candidate matrix and index
+    # generator passed in when the object was created.
+    def generate
+      Classnamer.generate @matrix, @prng
+    end
+  end
+end

data/test/classnamer_test.rb

@@ -0,0 +1,73 @@
+require 'classnamer'
+
+String == Classnamer::VERSION.class or fail
+
+3 == Classnamer::PART_CANDIDATE_MATRIX.length or fail
+
+Classnamer::PART_CANDIDATE_MATRIX.flatten(1).
+  all? { |part_candidate| /\A[A-Z]/ =~ part_candidate } or fail
+
+Classnamer.respond_to?(:generate) or fail
+
+String == Classnamer.generate.class or fail
+
+'42ObjecttrueSymbolFoo' == Classnamer.generate(
+  [[42], [Object], [nil], [true], [:Symbol], ['Foo']]) or fail
+
+lambda do
+  matrix = [%w{A B C}, [], %w{A B}, %w{A}]
+  prng_args = []
+  prng = lambda { |n|
+    prng_args << n
+    0
+  }
+  Classnamer.generate matrix, prng
+  [3, 0, 2, 1] == prng_args or fail
+end.call
+
+lambda do
+  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
+
+'' == Classnamer.generate([[], [], []]) or fail
+
+begin
+  Classnamer.generate nil
+rescue NoMethodError
+else
+  fail
+end
+
+begin
+  Classnamer.generate Classnamer::PART_CANDIDATE_MATRIX, nil
+rescue NoMethodError
+else
+  fail
+end
+
+begin
+  Classnamer.generate [['Foo'], nil]
+rescue NoMethodError
+else
+  fail
+end
+
+Classnamer::Generator == Classnamer::Generator.new.class or fail
+
+Classnamer::Generator.new.respond_to?(:generate) or fail
+
+lambda do
+  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
+
+puts 'Test finished.'

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: classnamer
+version: !ruby/object:Gem::Version
+  version: 3.0.8
+platform: ruby
+authors:
+- Aaron Beckerman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-28 00:00:00.000000000 Z
+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:
+- classnamer
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.rdoc
+- bin/classnamer
+- classnamer.gemspec
+- lib/classnamer.rb
+- test/classnamer_test.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A random class name generator.
+test_files:
+- test/classnamer_test.rb