noid 0.7.1 → 0.7.2

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MDE0ZDYxMWVjODZhOGEwODM0NDRiZThjZmZhMWU3YTVjZjZjYTEwNw==
-  data.tar.gz: !binary |-
-    ZWY4NGM2YjcwMGViNmQxMTk1MmU1OTYzNGFiMDQ1ODk1YTI1ZjE3Mw==
+SHA1:
+  metadata.gz: 50e4fa485ed73bb6f4d313b5fda35a6ecfeb08e7
+  data.tar.gz: 763d9e2e9f279a0afa7461b9f2ddee88d00e1318
 SHA512:
-  metadata.gz: !binary |-
-    MmIxY2RiNWUzNjFmZmE1MmY4YjE1YjgxZTFkZTIwMDZhNWYwZTI1ZWM5NWE5
-    MDcyZDFhMmE5ZWQxZDVhOWIwYzRmNjdjOGViZjA4NDQ4ZjcwOTViOWU3ZDcz
-    NDE5ZjhhNWIwMDk3Y2IzZGUzZDI1Zjk5ZDE3NzBlYTE1MDVjNGE=
-  data.tar.gz: !binary |-
-    MDdlODMyZDMxYWExNzM5MTY4ZGY5ZjkzNzJhMDc0MDUwODg0OTA2OGEwNDJh
-    MzRmNDdjNTk0NWE4NzkzZTYwMDJlNTBmZGY0MjgwZmMwZWNlNjgwMWMzZTYw
-    NjYyNWM3OGMxYzMxNTVmOGZkNTU1Y2RkMDQ5MTc2Y2I4YzczY2M=
+  metadata.gz: b5d19a31918d22133f8c282e3deb6baab51e27cbe7fb65797a503bffff474b34964bef5d9e81d657f591653d807e0be33b5ab2bab644ac633a9904561fecf66c
+  data.tar.gz: 48e622908ddedc36c1296ecdbb9818694f7f3a680f5d610fc9115254d630bcb6489519bf00903ad1f6d751254fa5816ab4c989a93014b73439b1d99c8dae73d9

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -1,6 +1,7 @@
 language: ruby
+sudo: false
+cache: bundler
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - jruby-19mode
+  - 2.1
+  - 2.2
 script: bundle exec rake

data/Gemfile

@@ -1,7 +1,10 @@
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
 # Specify your gem's dependencies in test.gemspec
 gemspec
 
-gem 'simplecov'
-gem 'simplecov-rcov'
+group :development, :test do
+  gem 'simplecov'
+  gem 'simplecov-rcov'
+  gem 'byebug', require: false
+end

data/Rakefile

@@ -15,10 +15,10 @@ require 'rspec'
 require 'rspec/core/rake_task'
 
 desc 'Default: run specs.'
-task :default => :spec
+task default: :spec
 
 RSpec::Core::RakeTask.new do |t|
-  if ENV['COVERAGE'] and RUBY_VERSION =~ /^1.8/
+  if ENV['COVERAGE'] && RUBY_VERSION =~ /^1.8/
     t.rcov = true
     t.rcov_opts = ['--exclude', 'spec', '--exclude', 'gems']
   end
@@ -32,14 +32,13 @@ begin
   doc_destination = File.join(project_root, 'doc')
 
   YARD::Rake::YardocTask.new(:doc) do |yt|
-    yt.files   = Dir.glob(File.join(project_root, 'lib', '**', '*.rb')) + 
-                 [ File.join(project_root, 'README.md') ]
+    yt.files   = Dir.glob(File.join(project_root, 'lib', '**', '*.rb')) +
+      [File.join(project_root, 'README.md')]
     yt.options = ['--output-dir', doc_destination, '--readme', 'README.md']
   end
 rescue LoadError
-  desc "Generate YARD Documentation"
+  desc 'Generate YARD Documentation'
   task :doc do
-    abort "Please install the YARD gem to generate rdoc."
+    abort 'Please install the YARD gem to generate rdoc.'
   end
 end
-

data/VERSION

@@ -1 +1 @@
-0.7.1
+0.7.2

data/lib/noid.rb

@@ -1,8 +1,11 @@
-require "noid/version"
-require "noid/minter"
-require "noid/template"
+require 'noid/version'
+require 'noid/minter'
+require 'noid/template'
 
 module Noid
-    XDIGIT = ['0','1','2','3','4','5','6','7','8','9','b','c','d','f','g','h','j','k','m','n','p','q','r','s','t','v','w','x','z']
-    MAX_COUNTERS = 293
+  XDIGIT = %w(0 1 2 3 4 5 6 7 8 9 b c d f g h j k m n p q r s t v w x z)
+  MAX_COUNTERS = 293
+
+  class TemplateError < StandardError
+  end
 end

data/lib/noid/minter.rb

@@ -1,74 +1,43 @@
 module Noid
   class Minter
-    attr_reader :seed, :seq
+    attr_reader :seed, :seq, :template
     attr_writer :counters
 
-    def initialize options = {}
-
+    def initialize(options = {})
       if options[:state]
-        seed(options[:seed])
+        # Only set the sequence ivar if this is a stateful minter
         @seq = options[:seq]
-        @template_string = options[:template]
-        @counters = options[:counters]
       else
-        seed(options[:seed], options[:seq])
-        @template_string = options[:template]
         @max_counters = options[:max_counters]
-        @counters = options[:counters]
-
         @after_mint = options[:after_mint]
       end
-      @template ||= Noid::Template.new(@template_string)
-    end  
+      @counters = options[:counters]
+      @template = Template.new(options[:template])
+      seed(options[:seed], options[:seq])
+    end
 
     ##
     # Mint a new identifier
     def mint
       n = next_in_sequence
       id = template.mint(n)
-      if @after_mint
-        @after_mint.call(self, id)
-      end
+      @after_mint.call(self, id) if @after_mint
       id
     end
 
-    ##
-    # Noid identifier template
-    #
-    # @return Noid::Template
-    def template
-      @template 
-    end
-
     ##
     # Is the identifier valid under the template string and checksum?
     # @param [String] id
     # @return bool
-    def valid? id
-      prefix = @template.prefix.empty? ? '' : id[0..@template.prefix.length-1]
-      ch = @template.prefix.empty? ? id.split('') : id[@template.prefix.length..-1].split('')
-      check = ch.pop if @template.checkdigit?
-      return false unless prefix == @template.prefix
-
-      return false unless @template.characters.length == ch.length
-      @template.characters.split('').each_with_index do |c, i|
-        return false unless Noid::XDIGIT.include? ch[i] 
-        return false if c == 'd' and ch[i] =~ /[^\d]/
-      end
-
-      return false unless check.nil? or check == @template.checkdigit(id[0..-2])
-
-      true
+    def valid?(id)
+      template.valid?(id)
     end
 
     ##
     # Seed the random number generator with a seed and sequence offset
-    # @param [Integer] seed
-    # @param [Integer] seq
     # @return [Random]
-    def seed seed = nil, seq = 0
-      @rand = ::Random.new(seed) if seed
-      @rand ||= ::Random.new 
+    def seed(seed_number = nil, seq = 0)
+      @rand = seed_number ? Random.new(seed_number) : Random.new
       @seed = @rand.seed
       @seq = seq || 0
 
@@ -80,27 +49,31 @@ module Noid
     def next_in_sequence
       n = @seq
       @seq += 1
-      case template.generator
-        when 'r'
-          n = next_random
+      if template.generator == 'r'
+        next_random
+      else
+        n
       end
-      n
     end
 
     def next_random
-      raise Exception("Exhausted noid sequence pool") if counters.size == 0
-      i = @rand.rand(counters.size)
+      raise 'Exhausted noid sequence pool' if counters.size == 0
+      i = random_bucket
       n = counters[i][:value]
       counters[i][:value] += 1
       counters.delete_at(i) if counters[i][:value] == counters[i][:max]
       n
     end
 
+    def random_bucket
+      @rand.rand(counters.size)
+    end
+
     ##
     # Counters to use for quasi-random NOID sequences
     def counters
       return @counters if @counters
-      return [] unless template.generator == "r"
+      return [] unless template.generator == 'r'
 
       percounter = template.max / (@max_counters || Noid::MAX_COUNTERS) + 1
       t = 0
@@ -120,7 +93,7 @@ module Noid
     end
 
     def dump
-      { :state => true, :seq => @seq, :seed => @seed, :template => template.template, :counters => Marshal.load(Marshal.dump(counters)) }
+      { state: true, seq: @seq, seed: @seed, template: template.template, counters: Marshal.load(Marshal.dump(counters)) }
     end
   end
 end

data/lib/noid/template.rb

@@ -1,13 +1,16 @@
 module Noid
   class Template
-    attr_reader :template
+    attr_reader :template, :prefix, :generator, :characters
 
-    # @param [String] template A Template is a coded string of the form Prefix.Mask that governs how identifiers will be minted. 
-    def initialize template
-      @template = template  
+    VALID_PATTERN = /\A(.*)\.([rsz])([ed]+)(k?)\Z/
+
+    # @param [String] template A Template is a coded string of the form Prefix.Mask that governs how identifiers will be minted.
+    def initialize(template)
+      @template = template
+      parse!
     end
 
-    def mint n
+    def mint(n)
       str = prefix
       str += n2xdig(n)
       str += checkdigit(str) if checkdigit?
@@ -15,103 +18,116 @@ module Noid
       str
     end
 
-    def valid? str
-      return false unless str[0..prefix.length] == prefix
-
-      if generator == 'z'
-        str[prefix.length..-1].length > 2
-      else
-        str[prefix.length..-1].length == characters.length
-      end
-
-      characters.split('').each_with_index do |c, i|
-        case c
-          when 'e'
-            return false unless Noid::XDIGIT.include? str[prefix.length + i]
-          when 'd'
-            return false unless str[prefix.length + i] =~ /\d/
-        end
-      end 
-
-      return false unless checkdigit(str[0..-2]) == str.split('').last if checkdigit?
-
+    ##
+    # Is the string valid against this template string and checksum?
+    # @param [String] str
+    # @return bool
+    def valid?(str)
+      match = validation_regex.match(str)
+      return false if match.nil?
+      return checkdigit(match[1]) == match[3] if checkdigit?
       true
     end
 
     ##
-    # identifier prefix string
-    def prefix
-      @prefix ||= @template.split('.').first
+    # calculate a checkdigit for the str
+    # @param [String] str
+    # @return [String] checkdigit
+    def checkdigit(str)
+      Noid::XDIGIT[str.split('').map { |x| Noid::XDIGIT.index(x).to_i }.each_with_index.map { |n, idx| n * (idx + 1) }.inject { |sum, n| sum + n } % Noid::XDIGIT.length]
     end
 
     ##
-    # identifier mask string
-    def mask
-      @mask ||= @template.split('.').last
+    # minimum sequence value
+    def min
+      @min ||= 0
     end
 
     ##
-    # generator type to use: r, s, z
-    def generator
-      @generator ||= mask[0..0]  
+    # maximum sequence value for the template
+    def max
+      @max ||= if generator == 'z'
+                 nil
+               else
+                 size_list.inject(1) { |total, x| total * x }
+               end
     end
 
+    protected
+
     ##
-    # sequence pattern: e (extended), d (digit)
-    def characters
-      @characters ||= begin
-        if checkdigit?
-          mask[1..-2]
-        else
-          mask[1..-1]
-        end
-                      end
+    # A noid has the structure (prefix)(code)(checkdigit)
+    # the regexp has the following captures
+    #  1 - the prefix and the code
+    #  2 - the changing id characters (not the prefix and not the checkdigit)
+    #  3 - the checkdigit, if there is one. This field is missing if there is no checkdigit
+    def validation_regex
+      @validation_regex ||= begin
+                              character_pattern = ''
+                              # the first character in the mask after the type character is the most significant
+                              # acc. to the Noid spec (p.9):
+                              # https://wiki.ucop.edu/display/Curation/NOID?preview=/16744482/16973835/noid.pdf
+                              character_pattern += character_to_pattern(character_list.first) + "*" if generator == 'z'
+                              character_pattern += character_list.map { |c| character_to_pattern(c) }.join
+
+                              %r{\A(#{Regexp.escape(prefix)}(#{character_pattern}))(#{character_to_pattern('k') if checkdigit?})\Z}
+                            end
     end
 
     ##
-    # should generated identifiers have a checkdigit?
-    def checkdigit?
-      mask.split('').last == 'k'
+    # parse template and put the results into instance variables
+    # raise an exception if there is a parse error
+    def parse!
+      match = VALID_PATTERN.match(template)
+      raise Noid::TemplateError, "Malformed noid template '#{template}'" unless match
+      @prefix = match[1]
+      @generator = match[2]
+      @characters = match[3]
+      @checkdigit = (match[4] == 'k')
     end
 
-    ##
-    # calculate a checkdigit for the str
-    # @param [String] str
-    # @return [String] checkdigit
-    def checkdigit str
-      Noid::XDIGIT[str.split('').map { |x| Noid::XDIGIT.index(x).to_i }.each_with_index.map { |n, idx| n*(idx+1) }.inject { |sum, n| sum += n }  % Noid::XDIGIT.length ]
+    def xdigit_pattern
+      @xdigit_pattern ||= '[' + Noid::XDIGIT.join('') + ']'
     end
 
-    ##
-    # minimum sequence value
-    def min
-      @min ||= 0
+    def character_to_pattern(c)
+      case c
+      when 'e', 'k'
+        xdigit_pattern
+      when 'd'
+        '\d'
+      else
+        ''
+      end
     end
 
     ##
-    # maximum sequence value for the template
-    def max
-      @max ||= begin
-        case generator
-          when 'z'
-            nil
-          else
-            characters.split('').map { |x| character_space(x) }.compact.inject(1) { |total, x| total *= x }
-        end
-      end
+    # Return a list giving the number of possible characters at each position
+    def size_list
+      @size_list ||= character_list.map { |c| character_space(c) }
     end
 
+    def character_list
+      characters.split('')
+    end
+
+    def mask
+      generator + characters
+    end
+
+    def checkdigit?
+      @checkdigit
+    end
 
-    protected
     ##
     # total size of a given template character value
     # @param [String] c
-    def character_space c
+    def character_space(c)
       case c
-        when 'e'
-          Noid::XDIGIT.length
-        when 'd'
-          10
+      when 'e'
+        Noid::XDIGIT.length
+      when 'd'
+        10
       end
     end
 
@@ -119,26 +135,25 @@ module Noid
     # convert a minter position to a noid string under this template
     # @param [Integer] n
     # @return [String]
-    def n2xdig n
-      xdig = characters.reverse.split('').map do |c|
-        value = n % character_space(c)
-        n = n / character_space(c)  
+    def n2xdig(n)
+      xdig = size_list.reverse.map { |size|
+        value = n % size
+        n /= size
         Noid::XDIGIT[value]
-      end.compact.join('')
+      }.compact.join('')
 
       if generator == 'z'
-        c = characters.split('').last
+        size = size_list.last
         while n > 0
-          value = n % character_space(c)
-          n = n / character_space(c)  
+          value = n % size
+          n /= size
           xdig += Noid::XDIGIT[value]
         end
       end
 
-      raise Exception if n > 0
+      raise 'Exhausted noid sequence pool' if n > 0
 
       xdig.reverse
     end
-
   end
 end

data/lib/noid/version.rb

@@ -4,6 +4,6 @@ module Noid
       @version ||= File.read(File.join(File.dirname(__FILE__), '..', '..', 'VERSION')).chomp
     end
 
-    VERSION = self.version
+    VERSION = version
   end
 end

data/noid.gemspec

@@ -1,27 +1,27 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "noid/version"
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'noid/version'
 
 Gem::Specification.new do |s|
-  s.name        = "noid"
+  s.name        = 'noid'
   s.version     = Noid::VERSION
-  s.authors     = ["Chris Beer"]
-  s.email       = ["chris@cbeer.info"]
-  s.homepage    = "http://github.com/microservices/noid"
-  s.summary     = %q{Nice Opaque Identifier}
-  s.description = %q{Nice Opaque Identifier}
-  s.licenses    = ["MIT"]
+  s.authors     = ['Chris Beer']
+  s.email       = ['chris@cbeer.info']
+  s.homepage    = 'http://github.com/microservices/noid'
+  s.summary     = 'Nice Opaque Identifier'
+  s.description = 'Nice Opaque Identifier'
+  s.licenses    = ['MIT']
 
-  s.rubyforge_project = "noid"
+  s.rubyforge_project = 'noid'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
 
   s.required_ruby_version = '>= 1.9.3'
 
-  s.add_development_dependency "bundler"
-  s.add_development_dependency "rake"
-  s.add_development_dependency "rspec", ">= 2.0"
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec', '>= 3.0'
 end

data/spec/lib/minter_spec.rb

@@ -1,152 +1,158 @@
 require 'spec_helper'
 
 describe Noid::Minter do
-  it "should mint a few random 3-digit numbers" do
-    minter = Noid::Minter.new(:template => '.rddd')
-    minter.mint.should =~ /\d\d\d/
+  it 'mints a few random 3-digit numbers' do
+    minter = described_class.new(template: '.rddd')
+    expect(minter.mint).to match(/\d\d\d/)
   end
 
-  it "should mint random 3-digit numbers, stopping after the 1000th" do
-    minter = Noid::Minter.new(:template => '.rddd')
-    1000.times { minter.mint.should =~ /^\d\d\d$/ }
-    expect { minter.mint }.to raise_exception
+  it 'mints random 3-digit numbers, stopping after the 1000th' do
+    minter = described_class.new(template: '.rddd')
+    1000.times { expect(minter.mint).to match(/^\d\d\d$/) }
+    expect { minter.mint }.to raise_exception(RuntimeError, /Exhausted noid sequence pool/)
   end
 
-  it "should mint sequential numbers without limit, adding new digits as needed" do
-    minter = Noid::Minter.new(:template => '.zd')
-    minter.mint.should == "0"
-    999.times { minter.mint.should =~ /\d/ }
-    minter.mint.should == "1000"
+  it 'mints sequential numbers without limit, adding new digits as needed' do
+    minter = described_class.new(template: '.zd')
+    expect(minter.mint).to eq('0')
+    999.times { expect(minter.mint).to match(/\d/) }
+    expect(minter.mint).to eq('1000')
   end
 
-  it "should mint random 4-digit numbers with constant prefix bc" do
-    minter = Noid::Minter.new(:template => 'bc.rdddd')
-    1000.times { minter.mint.should =~ /^bc\d\d\d\d$/ }
+  it 'mints random 4-digit numbers with constant prefix bc' do
+    minter = described_class.new(template: 'bc.rdddd')
+    1000.times { expect(minter.mint).to match(/^bc\d\d\d\d$/) }
   end
 
-  it "should mint sequential 2-digit numbers with constant prefix 8rf" do
-    minter = Noid::Minter.new(:template => '8rf.sdd')
-    minter.mint.should == "8rf00"
-    10.times { minter.mint.should =~ /^8rf\d\d$/ }
-    minter.mint.should == "8rf11"
-    88.times { minter.mint.should =~ /^8rf\d\d$/ }
-    expect { minter.mint }.to raise_exception
+  it 'mints sequential 2-digit numbers with constant prefix 8rf' do
+    minter = described_class.new(template: '8rf.sdd')
+    expect(minter.mint).to eq('8rf00')
+    10.times { expect(minter.mint).to match(/^8rf\d\d$/) }
+    expect(minter.mint).to eq('8rf11')
+    88.times { expect(minter.mint).to match(/^8rf\d\d$/) }
+    expect { minter.mint }.to raise_exception(RuntimeError, /Exhausted noid sequence pool/)
   end
 
-  it "should mint sequential extended-digits" do
-    minter = Noid::Minter.new(:template => '.se')
-    29.times.map { minter.mint }.join('').should == "0123456789bcdfghjkmnpqrstvwxz"
+  it 'mints sequential extended-digits' do
+    minter = described_class.new(template: '.se')
+    expect(29.times.map { minter.mint }.join('')).to eq('0123456789bcdfghjkmnpqrstvwxz')
   end
-  
-  it "should mint random 3-extended-digit numbers with constant prefix h9" do
-    minter = Noid::Minter.new(:template => 'h9.reee')
 
-    (minter.template.max).times { minter.mint.should =~ /^h9\w\w\w$/ }
-    expect { minter.mint }.to raise_exception
+  it 'mints random 3-extended-digit numbers with constant prefix h9' do
+    minter = described_class.new(template: 'h9.reee')
+
+    (minter.template.max).times { expect(minter.mint).to match(/^h9\w\w\w$/) }
+    expect { minter.mint }.to raise_exception(RuntimeError, /Exhausted noid sequence pool/)
   end
 
-  it "should mint unlimited sequential numbers with at least 3 extended digits" do
-    minter = Noid::Minter.new(:template => '.zeee')
-    (29*29*29).times { minter.mint.should =~ /^\w\w\w/ }
-    minter.mint.should =~ /^\w\w\w\w/
+  it 'mints unlimited sequential numbers with at least 3 extended digits' do
+    minter = described_class.new(template: '.zeee')
+    (29 * 29 * 29).times { expect(minter.mint).to match(/^\w\w\w/) }
+    expect(minter.mint).to match(/^\w\w\w\w/)
   end
 
-  it "should mint random 7-char numbers, with extended digits at chars 2,4,and 5" do
-    minter = Noid::Minter.new(:template => '.rdedeedd')
-    1000.times { minter.mint.should =~ /^\d\w\d\w\w\d\d$/ }
+  it 'mints random 7-char numbers, with extended digits at chars 2,4,and 5' do
+    minter = described_class.new(template: '.rdedeedd')
+    1000.times { expect(minter.mint).to match(/^\d\w\d\w\w\d\d$/) }
   end
 
-  it "should mint unlimited mixed digits, adding new extended digits as needed" do
-    minter = Noid::Minter.new(:template => '.zedededed')
-    minter.mint.should == "00000000"
+  it 'mints unlimited mixed digits, adding new extended digits as needed' do
+    minter = described_class.new(template: '.zedededed')
+    expect(minter.mint).to eq('00000000')
   end
 
-  it "should mint sequential 4-mixed-digit with constant prefix sdd" do
-    minter = Noid::Minter.new(:template => 'sdd.sdede')
-    minter.mint.should == 'sdd0000'
-    1000.times { minter.mint.should =~ /^sdd\d\w\d\w$/}
-    minter.mint.should == "sdd034h"
+  it 'mints sequential 4-mixed-digit with constant prefix sdd' do
+    minter = described_class.new(template: 'sdd.sdede')
+    expect(minter.mint).to eq('sdd0000')
+    1000.times { expect(minter.mint).to match(/^sdd\d\w\d\w$/) }
+    expect(minter.mint).to eq('sdd034h')
   end
 
-  it "should mint random 3 mixed digits plus final (4th) computed check character" do
-    minter = Noid::Minter.new(:template => '.rdedk')
-    1000.times { minter.mint.should =~ /^\d\w\d\w$/ }
+  it 'mints random 3 mixed digits plus final (4th) computed check character' do
+    minter = described_class.new(template: '.rdedk')
+    1000.times { expect(minter.mint).to match(/^\d\w\d\w$/) }
   end
 
-  it "should mint 5 sequential mixed digits plus final extended digit check char" do
-    minter = Noid::Minter.new(:template => '.sdeeedk')
-    minter.mint.should == "000000"
-    minter.mint.should == "000015"
-    minter.mint.should == "00002b"
-    1000.times { minter.mint.should =~ /^\d\w\w\w\d\w$/ }
-    minter.mint.should == "003f3m"
+  it 'mints 5 sequential mixed digits plus final extended digit check char' do
+    minter = described_class.new(template: '.sdeeedk')
+    expect(minter.mint).to eq('000000')
+    expect(minter.mint).to eq('000015')
+    expect(minter.mint).to eq('00002b')
+    1000.times { expect(minter.mint).to match(/^\d\w\w\w\d\w$/) }
+    expect(minter.mint).to eq('003f3m')
   end
 
-  it "should mint sequential digits plus check char, with new digits added as needed" do
-    minter = Noid::Minter.new(:template => ".zdeek")
-    minter.mint.should == "0000"
-    minter.mint.should == "0013"
-    (10*29*29-2).times { minter.mint.should =~ /^\d\w\w\w$/ }
-    minter.mint.should == "10001"
+  it 'mints sequential digits plus check char, with new digits added as needed' do
+    minter = described_class.new(template: '.zdeek')
+    expect(minter.mint).to eq('0000')
+    expect(minter.mint).to eq('0013')
+    (10 * 29 * 29 - 2).times { expect(minter.mint).to match(/^\d\w\w\w$/) }
+    expect(minter.mint).to eq('10001')
   end
 
-  it "should mint prefix plus random 3 mixed digits plus a check char" do
-    minter = Noid::Minter.new(:template => "63q.redek")
-    minter.mint.should =~ /63q\w\d\w\w/
+  it 'mints prefix plus random 3 mixed digits plus a check char' do
+    minter = described_class.new(template: '63q.redek')
+    expect(minter.mint).to match(/63q\w\d\w\w/)
   end
 
-  describe "validate" do
-    it "should validate a prefixed identifier" do
-      minter = Noid::Minter.new(:template => "foobar.redek")
+  describe 'validate' do
+    it 'validates a prefixed identifier' do
+      minter = described_class.new(template: 'foobar.redek')
+      id = minter.mint
+      expect(minter.valid?(id)).to eq(true)
+    end
+    it 'validates a prefixless identifier' do
+      minter = described_class.new(template: '.redek')
       id = minter.mint
-      minter.valid?(id).should be_true
+      expect(minter.valid?(id)).to eq(true)
     end
-    it "should validate a prefixless identifier" do
-      minter = Noid::Minter.new(:template => ".redek")
+    it 'validates with a new minter' do
+      minter = described_class.new(template: '.redek')
       id = minter.mint
-      minter.valid?(id).should be_true
+      minter2 = described_class.new(template: '.redek')
+      expect(minter2.valid?(id)).to eq(true)
     end
-    it "should validate with a new minter" do
-      minter = Noid::Minter.new(:template => ".redek")
+    it 'validates an unlimited sequence with mixed digits' do
+      minter = described_class.new(template: '.zed')
+      1000.times { minter.mint }
       id = minter.mint
-      minter2 = Noid::Minter.new(:template => ".redek")
-      minter2.valid?(id).should be_true
+      expect(minter.valid?(id)).to eq(true)
     end
   end
 
-  describe "seed" do
-    it "given a specific seed, identifiers should be replicable" do
-      minter = Noid::Minter.new(:template => "63q.redek")
+  describe 'seed' do
+    it 'given a specific seed, identifiers should be replicable' do
+      minter = described_class.new(template: '63q.redek')
       minter.seed(1)
-      minter.mint.should == "63q3706"
-      
-      minter = Noid::Minter.new(:template => "63q.redek")
+      expect(minter.mint).to eq('63q3706')
+
+      minter = described_class.new(template: '63q.redek')
       minter.seed(1)
-      minter.mint.should == "63q3706"
+      expect(minter.mint).to eq('63q3706')
     end
 
-    it "given a specific seed and sequence, identifiers should be replicable" do
-      minter = Noid::Minter.new(:template => "63q.redek")
-      minter.seed(23456789, 567)
+    it 'given a specific seed and sequence, identifiers should be replicable' do
+      minter = described_class.new(template: '63q.redek')
+      minter.seed(23_456_789, 567)
       mint1 = minter.mint
       dump1 = minter.dump
 
-      minter = Noid::Minter.new(:template => "63q.redek")
-      minter.seed(23456789, 567)
+      minter = described_class.new(template: '63q.redek')
+      minter.seed(23_456_789, 567)
       mint2 = minter.mint
       dump2 = minter.dump
       expect(dump1).to eql(dump2)
       expect(mint1).to eql(mint2)
-      mint1.should == "63qb41v" # "63qh305" was the value from a slightly buggy impl
+      expect(mint1).to eq('63qb41v') # "63qh305" was the value from a slightly buggy impl
     end
   end
 
-  describe "dump and reload" do
-    it "should dump the minter state" do
-      minter = Noid::Minter.new(:template => ".sddd")
+  describe 'dump and reload' do
+    it 'dumps the minter state' do
+      minter = described_class.new(template: '.sddd')
       d = minter.dump
-      d[:template].should == ".sddd"
-      d[:seq].should == 0
+      expect(d[:template]).to eq('.sddd')
+      expect(d[:seq]).to eq(0)
 
       minter.mint
       minter.mint
@@ -154,51 +160,63 @@ describe Noid::Minter do
       d[:seq] == 2
     end
 
-    it "should dump the seed, sequence, and counters for the RNG" do
-      minter = Noid::Minter.new(:template => ".rddd")
+    it 'dumps the seed, sequence, and counters for the RNG' do
+      minter = described_class.new(template: '.rddd')
       d = minter.dump
-      d[:seq] == 0
-      d[:seed].should == minter.instance_variable_get('@seed')
+      expect(d[:seq]).to eq 0
+      expect(d[:seed]).to eq(minter.instance_variable_get('@seed'))
     end
 
-    it "should allow a random identifier minter to be 'replayed' accurately" do
-      minter = Noid::Minter.new(:template => '.rd')
+    it "allows a random identifier minter to be 'replayed' accurately" do
+      minter = described_class.new(template: '.rd')
       d = minter.dump
       arr = 10.times.map { minter.mint }
 
-      minter = Noid::Minter.new(d)
+      minter = described_class.new(d)
 
       arr2 = 10.times.map { minter.mint }
 
-      arr.should == arr2
-
+      expect(arr).to eq(arr2)
     end
-
   end
 
-  describe "with large seeds" do
-    it "should not reproduce noids with constructed sequences" do
-      minter = Noid::Minter.new(:template => 'ldpd:.reeeeeeee')
-      minter.seed(192548637498850379850405658298152906991)
-      first_values = (1..1000).collect {|c| minter.mint}
+  describe 'with large seeds' do
+    it 'does not reproduce noids with constructed sequences' do
+      minter = described_class.new(template: 'ldpd:.reeeeeeee')
+      minter.seed(192_548_637_498_850_379_850_405_658_298_152_906_991)
+      first_values = (1..1000).collect { |_c| minter.mint }
 
       values = []
       (0..999).each do |i|
-        minter = Noid::Minter.new(:template => 'ldpd:.reeeeeeee')
-        minter.seed(192548637498850379850405658298152906991, i)
+        minter = described_class.new(template: 'ldpd:.reeeeeeee')
+        minter.seed(192_548_637_498_850_379_850_405_658_298_152_906_991, i)
         values << minter.mint
-        expect(values[i]).to eql first_values[i] 
+        expect(values[i]).to eql first_values[i]
       end
       values.uniq!
       expect(values.length).to eql 1000
     end
   end
 
-  describe "multithreading-safe example" do
+  describe 'multithreading-safe example' do
+    def stateful_minter
+      File.open('minter-state', File::RDWR | File::CREAT, 0644) do |f|
+        f.flock(File::LOCK_EX)
+        yaml = YAML.load(f.read)
+        minter = described_class.new(yaml)
+        yield minter
+        f.rewind
+        yaml = YAML.dump(minter.dump)
+        f.write yaml
+        f.flush
+        f.truncate(f.pos)
+      end
+    end
+
     before do
       require 'yaml'
-      minter = Noid::Minter.new(:template => '.rd')
-      yaml = YAML::dump(minter.dump)
+      minter = described_class.new(template: '.reek')
+      yaml = YAML.dump(minter.dump)
       File.open('minter-state', 'w') { |f| f.write yaml }
     end
 
@@ -206,23 +224,34 @@ describe Noid::Minter do
       File.delete('minter-state')
     end
 
-    it "should persist state to the filesystem" do
+    it 'hops buckets between runs' do
+      bucket_list = []
+      10.times do
+        stateful_minter do |minter|
+          bucket = minter.random_bucket
+          bucket_list << bucket
+          allow(minter).to receive(:random_bucket) { bucket }
+          minter.mint
+        end
+      end
+      expect(bucket_list.uniq.count).to be > 1
+    end
 
-      File.open("minter-state", File::RDWR|File::CREAT, 0644) {|f|
+    it 'persists state to the filesystem' do
+      # TODO: This is not testing any expectations. Clarify intent and fix.
+      skip
+      File.open('minter-state', File::RDWR | File::CREAT, 0644) do|f|
         f.flock(File::LOCK_EX)
-        yaml = YAML::load(f.read)
-        
-        minter = Noid::Minter.new(yaml)
+        yaml = YAML.load(f.read)
+
+        minter = described_class.new(yaml)
 
         f.rewind
-        yaml = YAML::dump(minter.dump)
+        yaml = YAML.dump(minter.dump)
         f.write yaml
         f.flush
         f.truncate(f.pos)
-      }
-
+      end
     end
   end
-
-
 end

data/spec/lib/template_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Noid::Template do
+  context 'with a valid template' do
+    let(:template) { '.redek' }
+    it 'initializes without raising' do
+      expect { described_class.new(template) }.not_to raise_error
+    end
+  end
+  context 'with a bogus template' do
+    let(:template) { 'foobar' }
+    it 'raises Noid::TemplateError' do
+      expect { described_class.new(template) }.to raise_error(Noid::TemplateError)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,7 +1,7 @@
 require 'rubygems'
 require 'bundler/setup'
 
-if ENV['COVERAGE'] and RUBY_VERSION =~ /^1.9/
+if ENV['COVERAGE'] && RUBY_VERSION =~ /^1.9/
   require 'simplecov'
 
   SimpleCov.start
@@ -9,6 +9,5 @@ end
 
 require 'noid'
 
-RSpec.configure do |config|
-
+RSpec.configure do |_config|
 end

metadata

@@ -1,57 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: noid
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.2
 platform: ruby
 authors:
 - Chris Beer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-16 00:00:00.000000000 Z
+date: 2015-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
 description: Nice Opaque Identifier
 email:
 - chris@cbeer.info
@@ -59,8 +59,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -72,6 +73,7 @@ files:
 - lib/noid/version.rb
 - noid.gemspec
 - spec/lib/minter_spec.rb
+- spec/lib/template_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/microservices/noid
 licenses:
@@ -83,20 +85,18 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: noid
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Nice Opaque Identifier
-test_files:
-- spec/lib/minter_spec.rb
-- spec/spec_helper.rb
+test_files: []