hash_sample 0.8.7 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbaa5ac645a6128e616c5d2b33494ee8784c78836d341f15189016627f58d2e0
-  data.tar.gz: 5273af277526e13aea1999606c5208a444fb9916baa9169e2247c1f2fbbb8848
+  metadata.gz: 39d81a45676bb796c3e4b12f107783954bdd4209a597a3f019affd2054999a8b
+  data.tar.gz: dba23546f29b23d004de850f163dd8bc873bf21bbc0307665b539e2ea8f97f04
 SHA512:
-  metadata.gz: a111c5c5eb58d2f20df8506ff7c6d3ed6e8ccfb3aa6642fbf6800bf6e090017d5cc1f140d0613460e578156b9f253df58882cefaaca0c729aa76fc20de8666c0
-  data.tar.gz: 047c8aa18ea0f5c1abc746eafecf3077519562b66ece4de47d38fedf5e3754231ebc570c3c39cf3c1ce55489c9935edb4c1712148739e10b50231897880df007
+  metadata.gz: eb909e73f6e90502e3d4e759d6aab56cd837b4e19079b8508c8fe0b9b4380c328f5b5abb8ed472dcaa3f34adab9b9c54d49624fd038ddde538c9b1ac55595b54
+  data.tar.gz: 32c844882181b440c452831ac9756b83bdd1768c41ab7a31e889f6feee7f4f34af567ac1f38071ad7e1470de815894a81c0e624b0e78627defeb116cf69aa935

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in the .gemspec file

data/README.md

@@ -1,6 +1,7 @@
 # hash_sample
 
-[![Build Status](https://travis-ci.com/serg123e/hash_sample.svg?branch=master)](https://travis-ci.com/serg123e/hash_sample)
+[![Build Status](https://travis-ci.com/serg123e/hash_sample.svg)](https://travis-ci.com/serg123e/hash_sample)
+[![Test Coverage](https://img.shields.io/codecov/c/github/serg123e/hash_sample.svg)](https://codecov.io/github/serg123e/hash_sample?branch=master)
 
 Implements methods for Hash class for getting weighted random samples with and without replacement, as well as regular random samples
 
@@ -13,14 +14,17 @@ Implements methods for Hash class for getting weighted random samples with and w
 ```ruby
     require 'hash_sample'
     loaded_die = {'1' => 0.1, '2' => 0.1, '3' => 0.1, '4' => 0.1, '5' => 0.1, '6' => 0.5}
-    p loaded_die.wchoice      # "6"
-    p loaded_die.wchoice(1)   # ["6"]
-    p loaded_die.wchoice(10)  # ["4", "6", "3", "3", "2", "2", "1", "6", "4", "6"]
-    p loaded_die.wsample      # 6
-    p loaded_die.wsample(6)   # ["6", "3", "2", "4", "1", "5"]
-    p loaded_die.wsample(10)  # ["2", "6", "1", "3", "4", "5"]
+    # weighted random choice of keys, with replacement (elements can repeat)  
+    p loaded_die.weighted_choice      # "6"
+    p loaded_die.weighted_choices(1)   # ["6"]
+    p loaded_die.wchoices(10)  # ["4", "6", "3", "3", "2", "2", "1", "6", "4", "6"]
+    # weighted random choice of keys, without replacement (elements can NOT repeat)
+    p loaded_die.weighted_sample      # 6
+    p loaded_die.weighted_samples(6)   # ["6", "3", "2", "4", "1", "5"]
+    p loaded_die.wsamples(10)  # ["2", "6", "1", "3", "4", "5"]
+    # regular random choice of key-value pairs (pairs can NOT repeat)
     p loaded_die.sample       # { '1' => 0.1 }
-    p loaded_die.sample(6)    # {'1' => 0.1, '2' => 0.1, '3' => 0.1, '4' => 0.1, '5' => 0.1, '6' => 0.5}
+    p loaded_die.samples(6)    # {'1' => 0.1, '2' => 0.1, '3' => 0.1, '4' => 0.1, '5' => 0.1, '6' => 0.5}
 ```
 
 ## Hash instance methods
@@ -35,8 +39,12 @@ If the hash contains less than n unique keys, the copy of whole hash will be ret
 
 Returns new Hash containing sample key=>value pairs
 
+### hash.weighted_choice ⇒ Object
 ### hash.wchoice ⇒ Object
-### hash.wchoice(n) ⇒ Array of n samples.
+
+### hash.weighted_choices(n) ⇒ Array of n samples
+
+### hash.wchoices(n) ⇒ ⇒ Array of n samples
 Weighted random sampling *with* replacement.
 
 Choose a random key or n random keys from the hash, according to weights defined in hash values.
@@ -49,22 +57,28 @@ All weights should be Numeric.
 
 Zero or negative weighs will be ignored.
 
-    {'_' => 9, 'a' => 1}.wchoice(10)  # ["_", "a", "_", "_", "_", "_", "_", "_", "_", "_"]
+    {'_' => 9, 'a' => 1}.wchoices(10)  # ["_", "a", "_", "_", "_", "_", "_", "_", "_", "_"]
 
+### hash.weighted_sample ⇒ Object
 ### hash.wsample ⇒ Object
-### hash.wsample(n) ⇒ Array of n samples.
+
+### hash.wsamples(n) ⇒ Array of n samples.
+
+### hash.weighted_samples(n) ⇒ Array of n samples.
 Weighted random sampling *without* replacement.
 
 Choose 1 or n *distinct* random keys from the hash, according to weights defined in hash values.
-Drawn items are not replaced.
+Drawn items are not put back into the set, so they **can not be repeated in result**.
 
-If the hash is empty the first form returns nil and the second form returns an empty array.
+If the hash is empty, singular form returns nil and plural returns an empty array.
 
 All weights should be Numeric.
 
 Zero or negative weighs will be ignored.
 
-    {'_' => 9, 'a' => 1}.wchoice(10)  # ["_", "a"]
+    Hash.new.weighted_sample                   # nil
+    Hash.new.weighted_samples                  # []
+    {'_' => 9, 'a' => 1}.weighted_samples(10)  # ["_", "a"]
 
 ### hash.wchoices(n = 1) ⇒ Object
 alias for wchoice

data/Rakefile

@@ -1,4 +1,6 @@
-require 'yard'
+# frozen_string_literal: true
+
+require 'yard'
 require 'rake'
 require 'date'
 
@@ -9,7 +11,7 @@ require 'date'
 #############################################################################
 
 def name
-  "hash_sample"
+  'hash_sample'
 end
 
 def version
@@ -38,7 +40,7 @@ def bump_version
 end
 
 def replace_header(head, header_name)
-  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{Regexp.last_match(1)}#{send(header_name)}'" }
 end
 
 def gemspec_file
@@ -46,11 +48,11 @@ def gemspec_file
 end
 
 def gem_files
- ["#{name}-#{version}.gem"]
+  ["#{name}-#{version}.gem"]
 end
 
 def gemspecs
-   ["#{name}.gemspec"]
+  ["#{name}.gemspec"]
 end
 
 def date
@@ -65,20 +67,20 @@ end
 YARD::Rake::YardocTask.new do |t|
 end
 
-desc "Generate RCov test coverage and open in your browser"
+desc 'Generate RCov test coverage and open in your browser'
 task :coverage do
   require 'rcov'
-  sh "rm -fr coverage"
-  sh "rcov test/test_*.rb"
-  sh "open coverage/index.html"
+  sh 'rm -fr coverage'
+  sh 'rcov test/test_*.rb'
+  sh 'open coverage/index.html'
 end
 
-desc "Open an irb session preloaded with this library"
+desc 'Open an irb session preloaded with this library'
 task :console do
   sh "irb -r rubygems -r ./lib/#{name}.rb"
 end
 
-desc "Update version number and gemspec"
+desc 'Update version number and gemspec'
 task :bump do
   puts "Updated version to #{bump_version}"
   # Execute does not invoke dependencies.
@@ -88,8 +90,8 @@ task :bump do
 end
 
 desc 'Build gem'
-task :build => :gemspec do
-  sh "mkdir pkg"
+task build: :gemspec do
+  sh 'mkdir pkg'
   gemspecs.each do |gemspec|
     sh "gem build #{gemspec}"
   end
@@ -98,14 +100,13 @@ task :build => :gemspec do
   end
 end
 
-
-desc "Build and install"
-task :install => :build do
+desc 'Build and install'
+task install: :build do
   sh "gem install --local --no-document pkg/#{name}-#{version}.gem"
 end
 
 desc 'Update gemspec'
-task :gemspec => :validate do
+task gemspec: :validate do
   # read spec file and split out manifest section
   spec = File.read(gemspec_file)
   head, _manifest, tail = spec.split(/\s*# = MANIFEST =\n/)
@@ -114,22 +115,22 @@ task :gemspec => :validate do
   replace_header(head, :name)
   replace_header(head, :version)
   replace_header(head, :date)
-  #comment this out if your rubyforge_project has a different name
-#  replace_header(head, :rubyforge_project)
+  # comment this out if your rubyforge_project has a different name
+  #  replace_header(head, :rubyforge_project)
 
   # determine file list from git ls-files
-  files = `git ls-files`.
-    split("\n").
-    sort.
-    reject { |file| file =~ /^\./ }.
-    reject { |file| file =~ /^(rdoc|pkg|test|Home\.md|\.gitattributes|Guardfile)/ }.
-    map { |file| "      #{file}" }.
-    join("\n")
+  files = `git ls-files`
+          .split("\n")
+          .sort
+            .grep_v(/^\./)
+            .grep_v(/^(rdoc|pkg|test|Home\.md|\.gitattributes|Guardfile)/)
+          .map { |file| "    #{file}" }
+          .join("\n")
 
   # piece file back together and write
-  manifest = "    s.files = %w(\n#{files}\n    )"
-  spec = [head, manifest, tail].join("\n    # = MANIFEST =\n")
-  File.open(gemspec_file, 'w') { |io| io.write(spec) }
+  manifest = "  s.files = %w[\n#{files}\n  ]"
+  spec = [head, manifest, tail].join("\n  # = MANIFEST =\n")
+  File.write(gemspec_file, spec)
   puts "Updated #{gemspec_file}"
 end
 
@@ -141,7 +142,7 @@ task :validate do
     exit!
   end
   unless Dir['VERSION*'].empty?
-    puts "A `VERSION` file at root level violates Gem best practices."
+    puts 'A `VERSION` file at root level violates Gem best practices.'
     exit!
   end
 end
@@ -149,13 +150,13 @@ end
 desc 'Tag commit and push it'
 task :tag do
   sh "git tag v#{version}"
-  sh "git push --tags"
+  sh 'git push --tags'
 end
 
 begin
   require 'rspec/core/rake_task'
-  desc "run rspec tests"
+  desc 'run rspec tests'
   RSpec::Core::RakeTask.new(:spec)
-  task :default => :spec
-rescue LoadError
-end
+  task default: :spec
+rescue LoadError # rubocop:disable Lint/SuppressedException
+end

data/hash_sample.gemspec

@@ -1,42 +1,49 @@
-Gem::Specification.new do |s|
-    s.name        = 'hash_sample'
-    s.platform    = Gem::Platform::RUBY
-    s.authors     = ["Sergey Evstegneiev"]
-    s.email       = ["serg123e@gmail.com"]
-    s.homepage    = 'https://github.com/serg123e/hash_sample'
-    s.summary     = %q{Implements multiple sampling methods for Hash class}
-    s.description = %q{Implements methods for Hash class for getting weighted random samples with and without replacement, as well as regular random samples}
+# frozen_string_literal: true
 
-    s.add_development_dependency "rspec", "~> 3.5"
-    s.add_development_dependency "simplecov", "~> 0.12"
-    s.add_development_dependency "rspec-simplecov", "~> 0.2"
+Gem::Specification.new do |s|
+  s.name = 'hash_sample'
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Sergey Evstegneiev"]
+  s.email       = ["serg123e@gmail.com"]
+  s.homepage    = 'https://github.com/serg123e/hash_sample'
+  s.summary     = 'Implements multiple sampling methods for Hash class'
+  s.description = 'Implements methods for Hash class for getting weighted random samples with and without ' \
+                  'replacement, as well as regular random samples'
 
-    s.add_development_dependency "rake", "~> 13"
-    s.add_development_dependency "yard", "~> 0.9"
+  s.add_development_dependency "codecov", "~> 0.2"
+  s.add_development_dependency "rspec", "~> 3.5"
+  s.add_development_dependency "rspec-simplecov", "~> 0.2"
+  s.add_development_dependency "simplecov", "~> 0.12"
 
+  s.add_development_dependency "rake", "~> 13"
+  s.add_development_dependency "reek", "~> 6"
+  s.add_development_dependency "rubocop", "~> 1.59"
+  s.add_development_dependency "rubocop-rake", "~> 0.6"
+  s.add_development_dependency "rubocop-rspec", "~> 3"
+  s.add_development_dependency "yard", "~> 0.9"
 
-    s.require_paths = ["lib"]
+  s.require_paths = ["lib"]
 
-    s.required_ruby_version = '>= 2.4'
+  s.required_ruby_version = '>= 2.4'
 
-    s.date              = '2020-05-01'
-    s.version           = '0.8.7'
-    s.license           = 'MIT'
+  s.date = '2024-11-19'
+  s.version = '1.0.2'
+  s.license           = 'MIT'
 
-    s.rdoc_options = ['--charset=UTF-8']
-    s.extra_rdoc_files = %w(README.md LICENSE)
-    # = MANIFEST =
-    s.files = %w(
-      Gemfile
-      LICENSE
-      README.md
-      Rakefile
-      hash_sample.gemspec
-      lib/hash_sample.rb
-      lib/hash_sample/version.rb
-      spec/hash_sample_spec.rb
-      spec/spec_helper.rb
-    )
-    # = MANIFEST =
-    s.test_files = s.files.select { |path| path =~ /^test\/test_.*\.rb/ }
-end
+  s.rdoc_options = ['--charset=UTF-8']
+  s.extra_rdoc_files = %w[README.md LICENSE]
+  # = MANIFEST =
+  s.files = %w[
+    Gemfile
+    LICENSE
+    README.md
+    Rakefile
+    hash_sample.gemspec
+    lib/hash_sample.rb
+    lib/hash_sample/version.rb
+    spec/hash_sample_spec.rb
+    spec/spec_helper.rb
+  ]
+  # = MANIFEST =
+  s.test_files = s.files.select { |path| path =~ %r{^spec/*\.rb} }
+end

data/lib/hash_sample/version.rb

@@ -1,4 +1,6 @@
-module HashSample
-    # gem version
-    VERSION = '0.8.7'
-end
+# frozen_string_literal: true
+
+module HashSample
+  # gem version
+  VERSION = '1.0.2'
+end

data/lib/hash_sample.rb

@@ -1,30 +1,33 @@
-# monkey-patched Hash module
+# frozen_string_literal: true
+
+# Implements methods for getting weighted random samples with and without replacement,
+# as well as regular random samples
 class Hash
   ##
   # Choose a random key=>value pair or *n* random pairs from the hash.
   #
   # @return [Hash] new Hash containing sample key=>value pairs
   #
-  # The elements are chosen by using random and unique indices in order to ensure that each element doesn't includes more than once.
+  # Each element doesn't includes more than once.
+  #
   # If the hash is empty it returns an empty hash.
-  # If the hash contains less than *n* unique keys, the copy of whole hash will be returned, none of keys will be lost.
-  def sample(n = 1)
-    to_a.sample(n).to_h
+  #
+  # If the hash contains less than *n* unique keys, the copy of whole hash
+  # will be returned, none of keys will be lost.
+  #
+  def sample(number = 1)
+    to_a.sample(number).to_h
   end
 
-  ###
-  # alias for wchoice
-  def wchoices(*args)
-    wchoice(*args)
-  end
+  alias samples sample
 
-  ## 
+  ##
   # Choose 1 or n random keys from the hash, according to weights defined in hash values
   # (weighted random sampling *with* *replacement*)
-  # 
-  # @overload wchoice
+  #
+  # @overload weighted_choice
   #   @return [Object] one sample object
-  # @overload wchoice(n)
+  # @overload weighted_choices(n)
   #   @param n [Integer] number of samples to be returned
   #   @return [Array] Array of n samples
   #
@@ -35,60 +38,73 @@ class Hash
   #
   # ===== Example
   #
-  #     p {'_' => 9, 'a' => 1}.wchoice(10)  # ["_", "a", "_", "_", "_", "_", "_", "_", "_", "_"]
+  #     p {'_' => 9, 'a' => 1}.weighted_choices(10)  # ["_", "a", "_", "_", "_", "_", "_", "_", "_", "_"]
   #
-  def wchoice(*args)
-    _check_weighted_params
-    n = args.first || 1
-    res = []
-    n.times do
-      tmp = max_by { |_, weight| weight.positive? ? rand**(1.0 / weight) : 0 }
-      res << tmp.first unless tmp.nil?
-    end
-    return args.empty? ? res.first : res
+  def weighted_choice
+    weighted_choices(1).first
   end
 
-  # internal method to validate parameters
-  def _check_weighted_params(*_args)
-    sum_weights = 0
-    each_value do |v|
-      raise ArgumentError, "All weights should be numeric unlike #{v}" unless v.is_a? Numeric
+  def weighted_choices(number = 1)
+    return [] if empty?
 
-      sum_weights += v if v.positive?
-    end
-
-    raise ArgumentError, "At least one weight should be > 0" unless sum_weights.positive? || empty?
+    validate_weights
+    Array.new(number) { _wrs.first }
   end
 
+  alias wchoices weighted_choices
+  alias wchoice weighted_choice
+
   ##
-  # Choose 1 or n *distinct* random keys from the hash, according to weights defined in hash values 
-  # (weighted random sampling *without* *replacement*)
+  # Choose 1 or _number_ of *distinct* random keys from the hash, according to
+  # weights defined in hash values (weighted random sampling *without* *replacement*)
   #
-  # @overload wsample
+  # @overload weighted_sample
   #   @return [Object] one sample object
-  # @overload wsample(n)
-  #   @param n [Integer] number of samples to be returned
-  #   @return [Array] Array of n or sometimes less than n samples
+  # @overload weighted_samples(number)
+  #   @param number [Integer] number of samples to be returned
+  #   @return [Array] Array of specified or sometimes less than specified samples
+  #
+  # When there are no sufficient distinct samples to return, the result will
+  # contain less than specified number of samples
   #
-  # When there are no sufficient distinct samples to return, the result will contain less than n samples
   # If the hash is empty the first form returns nil and the second form returns an empty array.
   # All weights should be Numeric.
-  # Zero or negative weighs will be ignored.
+  # Objects with zero or negative weighs will be skipped.
   #
   # ===== Example
+  #     {'a' => 98, 'b' => 1, 'c' => 1}.weighted_sample      # 'a'
+  #     {'a' => 98, 'b' => 1, 'c' => 1}.weighted_samples(3)  # ['a', 'a', 'a']
+  #     {'_' => 9, 'a' => 1}.weighted_samples(10)            # ['_', 'a']
   #
-  #     p {'_' => 9, 'a' => 1}.wsample(10)  # ["_", "a"]
-  #
-  def wsample(*args)
-    _check_weighted_params
-    n = args.first || 1
-    res = max_by(n) { |_, weight| weight.positive? ? rand**(1.0 / weight) : 0 }.map(&:first)
-    return args.empty? ? res.first : res
+  def weighted_sample
+    weighted_samples(1).first
+  end
+
+  def weighted_samples(number = 1)
+    return [] if empty?
+
+    validate_weights
+    _wrs(number).map(&:first)
+  end
+
+  alias wsamples weighted_samples
+  alias wsample weighted_sample
+
+  private
+
+  # internal method to validate parameters
+  def validate_weights
+    sum_weights = 0
+    each_value do |weight|
+      raise ArgumentError, "Invalid weight: #{weight}. All weights must be numeric." unless weight.is_a? Numeric
+
+      sum_weights += weight if weight.positive?
+    end
+    raise ArgumentError, 'At least one weight should be > 0' unless sum_weights.positive?
   end
 
-  ###
-  # alias for wsample
-  def wsamples(*args)
-    wsample(*args)
+  # Returns the *number* of key-value pairs, implementing weighted random sampling.
+  def _wrs(*number)
+    max_by(*number) { |_, weight| weight.positive? ? rand**(1.0 / weight) : 0 }
   end
 end

data/spec/hash_sample_spec.rb

@@ -1,168 +1,162 @@
-# require 'lib/core_ext.rb'
-
-#
-# Specs
-#
-describe 'Hash#sample' do
-  describe 'when specified parameter n>1' do
-    it 'returns new Hash with specified number of unique key=>value samples' do
-      h = { 'a' => 'b', 'b' => 'b', 'c' => 'b' }
-      expect(h.sample(3)).to eq h
-    end
-  end
-  describe 'when specified parameter n> number of unique keys' do
-    it 'returns new Hash only with unique key=>value samples' do
-      h = { 'a' => 'b', 'b' => 'b', 'c' => 'b' }
-      expect(h.sample(10)).to eq h
-    end
-  end
+# frozen_string_literal: true
+
+shared_examples 'weighted sampler' do |weighted_method|
+  context weighted_method.to_s do
+    let(:weighted_methods) { "#{weighted_method}s" }
 
-  describe 'when specified parameter n> number of unique keys' do
-    it 'keys can not be lost because of bad luck' do
-      h = { 'a' => 'b', 'b' => 'b', 'c' => 'b' }
-      min = h.keys.length
-      100.times do
-        min = [h.sample(4).keys.length, min].min
+    describe 'plural form of method' do
+      it 'can be used' do
+        expect(described_class.new).to respond_to(weighted_methods)
       end
-      expect(min).to be 3
-    end
-  end
 
-  describe 'when specified parameter n==1' do
-    it 'returns new Hash with 1 random key=>value sample' do
-      h = { 'a' => 'b', 'b' => 'b', 'c' => 'b' }
-      expect(h.sample(1).keys.length).to eq 1
-    end
-  end
-end
+      it 'works as expected without args' do
+        expect({ 'a' => 1 }.send(weighted_methods)).to eq ['a']
+      end
 
-%w[wchoice wsample].each do |weighted_method|
-  describe 'plural form of method' do
-    weighted_methods = weighted_method + "s"
-    it 'can be used' do
-      expect({}).to respond_to(weighted_methods)
-    end
-    it 'works as expected without args' do
-      expect({ 'a' => 1 }.send(weighted_methods)).to eq 'a'
-    end
-    it 'works as expected with args' do
-      expect({ 'a' => 1 }.send(weighted_methods, 1)).to eq ['a']
+      it 'works as expected with args' do
+        expect({ 'a' => 1 }.send(weighted_methods, 1)).to eq ['a']
+      end
     end
-  end
 
-  describe "Hash\##{weighted_method}" do
-    it 'returns weighted sample key from all keys with respect of its weights' do
-      s = { 1 => 90, 2 => 10 }
-      freq = Hash.new(0)
-      1000.times { freq[s.send(weighted_method)] += 1 }
-      expect(freq[1]).to be_between(800, 999)
-      expect(freq[2]).to be_between(1, 200)
-    end
+    describe "Hash##{weighted_method}" do
+      let(:test_hash) { { 1 => 90, 2 => 10 } }
 
-    describe 'when weights are equal' do
-      it 'it should returns equal parts of samples' do
-        res = 1.upto(100_000).to_a.map { { +1 => 50, -1 => 50 }.send(weighted_method) }
-        expect(res.sum).to be_between(-1000, 1000) # +-1%  bias
+      it 'returns weighted sample key from all keys with respect of its weights' do
+        freq = described_class.new(0)
+        1000.times { freq[test_hash.send(weighted_method)] += 1 }
+        expect(freq[1]).to be_between(850, 950) # +-5% bias
       end
-    end
 
-    describe 'when Hash is empty' do
-      it 'returns nil' do
-        expect({}.send(weighted_method)).to be_nil
+      it 'returns equal parts of samples when weights are equal' do
+        res = 1.upto(100_000).to_a.map { { +1 => 50, -1 => 50 }.send(weighted_method) }
+        expect(res.sum).to be_between(-1000, 1000) # +-1%  bias
       end
-    end
 
-    describe 'when weights are Float' do
-      it 'returns a value as expected' do
+      it 'works with fractional weights' do
         expect([1, 2].include?({ 1 => 0.1, 2 => 0.9 }.send(weighted_method))).to be true
       end
-    end
 
-    describe 'when some weights are negative' do
-      it 'does not sample that key' do
-        100.times { expect({ 'a' => -1, 'b' => 2 }.send(weighted_method)).to eq 'b' }
+      it 'ignores negative weights' do
+        10.times { expect({ 'a' => -1, 'b' => 2 }.send(weighted_method)).to eq 'b' }
       end
-    end
 
-    describe 'when weight contains zero' do
-      it 'returns non-zero weighted element' do
+      it 'ignores zero weight' do
         10.times do
           expect({ 1 => 0, 2 => 1, 3 => 0 }.send(weighted_method)).to eq 2
         end
       end
-    end
 
-    describe 'when weight is non-numeric' do
-      it 'raises ArgumentError' do
+      it 'raises ArgumentError when weight is non-numeric' do
         expect { { 1 => 'asd', 2 => 2 }.send(weighted_method) }.to raise_error(ArgumentError)
       end
-    end
 
-    describe 'when all weights are zero' do
-      it 'raises ArgumentError' do
+      it 'raises ArgumentError when all weights are zero' do
         expect { { 1 => 0, 2 => 0 }.send(weighted_method) }.to raise_error(ArgumentError)
       end
-      # @todo do not raise error when all weights are zero
-      # xit 'returns empty array' do
-      #   h = { 'a'=>0, 'b'=>0, 'c'=>0 }
-      #   expect( h.wchoice(10) ).to eq []
-      # end
-    end
 
-    describe 'when hash is empty' do
-      it 'returns empty array or nil' do
-        expect({}.send(weighted_method, 10)).to eq []
-        expect({}.send(weighted_method)).to eq nil
+      it 'returns [] from {} if param specified' do
+        expect({}.send(weighted_methods, 10)).to eq []
       end
-    end
 
-    describe 'when specified parameter n>1' do
-      it 'returns array of sample keys 2' do
-        100.times { expect({ 1 => 1, 2 => 0.01, 3 => 0.0000001 }.wchoice(3).length).to be 3 }
+      it 'returns [] from {} if no param specified' do
+        expect({}.send(weighted_methods)).to eq []
       end
+
+      it 'returns array for parameter > 1' do
+        100.times { expect({ 1 => 1, 2 => 0.01, 3 => 0.0000001 }.weighted_choices(3).length).to be 3 }
+      end
+
+      context 'when specified parameter n==1' do
+        subject(:result) { { '1' => 1, '2' => 1, '3' => 1 }.weighted_samples(1) }
+
+        it { expect(result).to be_a(Array) }
+        it { expect(result.length).to be 1 }
+      end
+
+      describe 'should work with complex Objects as keys' do
+        subject(:result) do
+          { test_class.new('asd') => 1, test_class.new('bsd') => 1, test_class.new('dsf') => 1 }.weighted_choice
+        end
+
+        let(:test_class) { Struct.new(:foo) }
+
+        it 'returns array of one key' do
+          expect(result).to be_a(test_class)
+        end
+      end
+    end
+  end
+end
+
+RSpec.describe Hash do
+  let(:simple_hash) { { 'a' => 'x', 'b' => 'y', 'c' => 'z' } }
+  let(:weighted_hash) { { 'a' => 90, 'b' => 10 } }
+  let(:empty_hash) { {} }
+
+  describe '#sample' do
+    context 'when n is less than or equal to the number of unique keys' do
+      subject(:result) { simple_hash.sample(2) }
+
+      it { expect(result.keys.size).to eq(2) }
+      it { expect(result).to be_a(described_class) }
     end
-    describe 'when specified parameter n==1' do
-      subject { { '1' => 1, '2' => 1, '3' => 1 }.wchoice(1) }
-      it 'returns array of one key' do
-        expect(subject).to be_kind_of(Array)
-        expect(subject.length).to be 1
+
+    context 'when n is greater than the number of unique keys' do
+      subject(:result) { simple_hash.sample(10) }
+
+      it 'returns the entire hash' do
+        expect(result).to eq(simple_hash)
       end
     end
 
-    describe 'should work with complex Objetcts as keys' do
-      subject { { %w[asd zxf] => 1, %w[asd bsd] => 1, %w[asd dsf] => 1 }.wchoice }
-      it 'returns array of one key' do
-        expect(subject).to be_kind_of(Array)
-        expect(subject.length).to be 2
-        expect(subject).to include 'asd'
+    context 'when n equals 1' do
+      subject(:result) { simple_hash.sample(1) }
+
+      it { expect(result.keys.size).to eq(1) }
+      it { expect(result).to be_a(described_class) }
+    end
+
+    context 'when the hash is empty' do
+      it { expect(empty_hash.sample).to eq({}) }
+    end
+  end
+
+  describe '#weighted_choices' do
+    it_behaves_like 'weighted sampler', :weighted_choice
+
+    context 'when specified parameter n>1' do
+      it 'returns array of n sample keys' do
+        expect({ 'a' => 1 }.weighted_choices(2)).to eq %w[a a]
       end
     end
 
-    describe 'when specified parameter n is greater than number of unique keys' do
+    context 'when specified parameter is greater than number of keys' do
       it 'returns array with exactly n key samples, repeating some of them' do
         h = { 'a' => 1, 'b' => 1, 'c' => 1 }
-        expect(h.wchoice(10).length).to eq 10
+        expect(h.weighted_choices(10).length).to eq 10
       end
     end
   end
-end
 
-describe 'Hash#wchoice' do
-  describe 'when specified parameter n>1' do
-    it 'returns array of n sample keys' do
-      expect({ 'a' => 1 }.wchoice(2)).to eq %w[a a]
+  describe '#weighted_samples' do
+    it_behaves_like 'weighted sampler', :weighted_sample
+
+    describe 'when specified parameter n>1' do
+      it 'returns array of unique keys' do
+        expect({ 'a' => 1 }.weighted_samples(2)).to eq ['a']
+      end
     end
-  end
-end
 
-describe 'Hash#wsample' do
-  describe 'when specified parameter n>1' do
-    it 'returns array of unique keys' do
-      expect({ 'a' => 1 }.wsample(2)).to eq ['a']
+    context 'when specified parameter is greater than number of keys' do
+      let(:sample_hash) { { 'a' => 1, 'b' => 1, 'c' => 1 } }
+
+      it 'returns array with all presented keys' do
+        expect(sample_hash.weighted_samples(100).length).to eq 3
+      end
     end
-  end
 
-  it 'returned objects are not repeated' do
-    expect({ '_' => 9, 'a' => 1 }.wsample(10).sort).to eq %w[_ a]
+    it 'returned objects are not repeated' do
+      expect({ '_' => 9, 'a' => 1 }.weighted_samples(10).sort).to eq %w[_ a]
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,7 +1,14 @@
+# frozen_string_literal: true
+
 require 'simplecov'
 require 'rspec/simplecov'
 
 SimpleCov.minimum_coverage 100
 SimpleCov.start
 
+if ENV['CI'] == 'true'
+  require 'codecov'
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+end
+
 require 'hash_sample'

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: hash_sample
 version: !ruby/object:Gem::Version
-  version: 0.8.7
+  version: 1.0.2
 platform: ruby
 authors:
 - Sergey Evstegneiev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-01 00:00:00.000000000 Z
+date: 2024-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: codecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '0.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '0.2'
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.12'
+        version: '3.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.12'
+        version: '3.5'
 - !ruby/object:Gem::Dependency
   name: rspec-simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +80,62 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13'
+- !ruby/object:Gem::Dependency
+  name: reek
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.59'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.59'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -119,8 +189,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Implements multiple sampling methods for Hash class