shenanigans 1.0.10 → 1.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2e044d2e0504fe9effa8d5ab1ded585d95a0d0c1
-  data.tar.gz: a249b7f56f152919252ad63491f26d77ed00868e
+SHA256:
+  metadata.gz: 6b59ed384b8df1b8998e226ae092c61983fcbb926f52d825f77ca4cc6ffd455f
+  data.tar.gz: 36030c324aadae0a3f8ac00a5d2b0283dff3fa9e65ab682a7e3d6073da2472a6
 SHA512:
-  metadata.gz: 970384c5685779c928b2cf4347d4722148999ab9962bf0c9b9bafe7b64d5bbd437e0a8e2359b4387b2857571f8007fdbe5c964aa2c994111f5424f67bb535000
-  data.tar.gz: 4700cacb85b89461dc89ad01f954a8b2b5d0a632307c8c36713f3125b588fc91007b1d8a6450a1916a2aa88498b6cd06e577c0e4b616eab13427f9f086edb58b
+  metadata.gz: 5ace930024d466feb40bdb52dde54effb61182f3c2dcf13d4a8f34ed9cfcae8aec8509fdb04fee40317a1072640682af1e26b82a1759e1066b6cf2a91d58ebd3
+  data.tar.gz: d04dcb70b2565d320cf971864199e8f038c3fe0e609fb507adcab68000d271bad646e6f78f42b41095101930f5c9bf3ad402c2fac9a0c84411e5088c5eefa133

data/Gemfile

@@ -1,8 +1,9 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 gem "rake"
 
 group :developement do
   gem "minitest", ">= 2.6.0"
+  gem "standard"
   gem "yard"
 end

data/lib/shenanigans/array/caret.rb

@@ -1,7 +1,8 @@
 class Array
   # Returns an array containing elements exclusive between two arrays.
-  #   [1, 2, 3] ^ [1, 2, 4]
-  #   #=> [3, 4]
+  #
+  # @example
+  #   [1, 2, 3] ^ [1, 2, 4] #=> [3, 4]
   def ^(other)
     (self - other) | (other - self)
   end

data/lib/shenanigans/array/random_subarray.rb

@@ -2,15 +2,17 @@ class Array
   # Generates random subarrays. Uses random numbers and
   # bit-fiddling to assure performant uniform distributions
   # even for large arrays.
+  #
+  # @example
   #   a = *1..5
-  #   a.random_subarray(3)
-  #   #=> [[1, 3, 5], [2, 4], [1, 3, 4, 5]]
+  #   a.random_subarray(3) #=> [[1, 3, 5], [2, 4], [1, 3, 4, 5]]
 
-  def random_subarray(n=1)
+  def random_subarray(n = 1)
     raise ArgumentError, "negative argument" if n < 0
+
     (1..n).map do
-      r = rand(2**self.size)
-      self.select.with_index { |_, i| r[i] == 1 }
+      r = rand(2**size)
+      select.with_index { |_, i| r[i] == 1 }
     end
   end
 end

data/lib/shenanigans/array/reductions.rb

@@ -1,13 +1,16 @@
 class Array
-  # Similar to +reduce+/+inject+, but also returns intermediate values. Has the same interface as +reduce+/+inject+, so an initial value, an oprator or both can be supplied. This method may eventually be moved to the +Enumerable+ module.
+  # Similar to +reduce+/+inject+, but also returns intermediate values. Has the 
+  # same interface as +reduce+/+inject+, so an initial value, an operator or 
+  # both can be supplied. This method may eventually be moved to the 
+  # +Enumerable+ module.
   #
-  #   a = [*1..4]
-  #   a.reductions(:+)
-  #   #=> 10
-  #   a.reductions(50, :+)
-  #   #=> 60
-  #   %w(a b c).reductions { |s1, s2| s1+s2 }
-  #   #=> ["a", "ab", "abc"]
+  # @example Symbol argument
+  #   a = (1..4).to_a
+  #   a.reductions(:+) #=> 10
+  # @example Initial value and symbol argument
+  #   a.reductions(50, :+) #=> 60
+  # @example Block argument
+  #   %w(a b c).reductions { |s1, s2| s1+s2 } #=> ["a", "ab", "abc"]
   def reductions(*args, &block)
     arr = dup
 
@@ -21,9 +24,9 @@ class Array
 
     initial ||= arr.shift
 
-    arr.inject([initial, [initial]]) do |(acc, result), el|
+    arr.inject([initial, [initial]]) { |(acc, result), el|
       val = op ? acc.send(op, el) : yield(acc, el)
       [val, result << val]
-    end.last
+    }.last
   end
 end

data/lib/shenanigans/array/zip_with.rb

@@ -1,21 +1,18 @@
 class Array
-
   # Zip <tt>self</tt> with <tt>other</tt>, combining the elements
   # with the provided block or symbol.
   # The resulting array will be as long as the shorter of
   # the two arrays.
-  #   [1,2,3].zip_with([6,5,4], :+)
-  #   #=> [7, 7, 7]
-  #   %w(a b).zip_with(%w(c d), :+)
-  #   #=> ["ac", "bd"]
-  #
-  # For more complex combinations, a block can be provided:
-  #
-  #   [1,2,3].zip_with([6,5,4]) { |a,b| 3*a+2*b }
+  # @example With a symbol
+  #   [1,2,3].zip_with([6,5,4], :+) #=> [7, 7, 7]
+  #   %w(a b).zip_with(%w(c d), :+) #=> ["ac", "bd"]
+  # @example With a block
+  #   [1,2,3].zip_with([6,5,4]) { |a,b| 3 * a + 2 * b }
   #   #=> [15, 16, 17]
-  def zip_with(other, op=nil)
-    return [] if self.empty? || other.empty?
-    clipped = self[0..other.length-1]
+  def zip_with(other, op = nil)
+    return [] if empty? || other.empty?
+
+    clipped = self[0..other.length - 1]
     zipped = clipped.zip(other)
 
     if op

data/lib/shenanigans/array.rb

@@ -1,3 +1,3 @@
-require_relative 'array/caret'
-require_relative 'array/random_subarray'
-require_relative 'array/zip_with'
+require_relative "array/caret"
+require_relative "array/random_subarray"
+require_relative "array/zip_with"

data/lib/shenanigans/hash/extract.rb

@@ -1,10 +1,11 @@
 class Hash
   # Returns a new hash only with the specified keys (if present).
+  #
+  # @example Key order does not matter
   #   hash = { a: 1, b: 2, c: 3 }
-  #   hash.extract(:b, :a)
-  #   #=> { a: 1, b: 2 }
-  #   hash.extract(:a, :d)
-  #   #=> { a: 1}
+  #   hash.extract(:b, :a) #=> { a: 1, b: 2 }
+  # @example Missing keys are ignored
+  #   hash.extract(:a, :d) #=> { a: 1}
   def extract(*ks)
     existing = keys & ks
     Hash[existing.zip(values_at(*existing))]

data/lib/shenanigans/hash/has_shape_pred.rb

@@ -1,15 +1,14 @@
 class Hash
   # Checks if a hash has a certain structure.
+  #
+  # @example Simple hash
   #     h = { k1: 1, k2: "1" }
-  #     h.has_shape?(k1: Fixnum, k2: String)
-  #     #=> true
-  #     h.has_shape?(k1: Class, k2: String)
-  #     #=> false
-  # It also works with compound data structures.
+  #     h.has_shape?(k1: Integer, k2: String) #=> true
+  #     h.has_shape?(k1: Class, k2: String) #=> false
+  # @example Nested hashes
   #     h = { k1: [], k2: { k3: Struct.new("Foo") } }
   #     shape = { k1: Array, k2: { k3: Module } }
-  #     h.has_shape?(shape)
-  #     #=> true
+  #     h.has_shape?(shape) #=> true
   def has_shape?(shape)
     all? do |k, v|
       Hash === v ? v.has_shape?(shape[k]) : shape[k] === v

data/lib/shenanigans/hash/to_ostruct.rb

@@ -1,8 +1,10 @@
-require 'ostruct'
+require "ostruct"
 
 class Hash
   # Recursively converts a <tt>Hash</tt> and all nested <tt>Hash</tt>es to
   # <tt>OpenStruct</tt>s. Especially useful for parsing YAML.
+  #
+  # @example
   #     yaml=<<EOY
   #     subject: Programming Languages
   #     languages:
@@ -14,14 +16,11 @@ class Hash
   #         creator     : Larry Wall
   #     EOY
   #     struct = YAML.load(yaml).to_ostruct
-  #     struct.subject
-  #     #=> "Programming Languages"
-  #     struct.languages.first
-  #     #=> #<OpenStruct name="Ruby", creator="Matz">
-  #     struct.languages.first.creator
-  #     #=> "Matz"
+  #     struct.subject #=> "Programming Languages"
+  #     struct.languages.first #=> #<OpenStruct name="Ruby", creator="Matz">
+  #     struct.languages.first.creator #=> "Matz"
   def to_ostruct
-    arr = map do |k, v|
+    arr = map { |k, v|
       case v
       when Hash
         [k, v.to_ostruct]
@@ -30,7 +29,7 @@ class Hash
       else
         [k, v]
       end
-    end
+    }
     OpenStruct.new(Hash[arr])
   end
 end

data/lib/shenanigans/hash.rb

@@ -1,3 +1,3 @@
-require_relative 'hash/extract'
-require_relative 'hash/has_shape_pred'
-require_relative 'hash/to_ostruct'
+require_relative "hash/extract"
+require_relative "hash/has_shape_pred"
+require_relative "hash/to_ostruct"

data/lib/shenanigans/integer/divisible_by.rb

@@ -0,0 +1,13 @@
+class Integer
+  # Checks whether the receiver is cleanly divisble by the argument.
+  # @example
+  #     3.divisble_by(0) #=> false
+  #     3.divisble_by(2) #=> false
+  #     9.divisble_bu(3) #=> true
+  def divisible_by(n)
+    return false if n.zero?
+
+    self % n == 0
+  end
+end
+

data/lib/shenanigans/integer/string_length.rb

@@ -0,0 +1,13 @@
+class Integer
+  # Returns the length of the number's string representation.
+  # @example
+  #     0.string_length #=> 1
+  #     123.string_length #=> 3
+  #     -1.string_length #=> 2
+  def string_length
+    return 1 if zero?
+
+    len = Math.log10(abs).floor.next
+    positive? ? len : len.next
+  end
+end

data/lib/shenanigans/integer.rb

@@ -0,0 +1,2 @@
+require_relative "integer/divisible_by"
+require_relative "integer/string_length"

data/lib/shenanigans/kernel/fn.rb

@@ -1,14 +1,15 @@
 module Kernel
   # Composes a list of functions.
   # Functions can be specified as symbols or lambdas.
-  #   ["foo bar", "baz qux"].map &fn(:split, :last)
-  #   #=> ["bar", "qux"]
   #
-  #   (1..3).map &fn(:next, -> x { x * x }, -> x { x.to_f / 2 } )
+  # @example Composing symbols
+  #   ["foo bar", "baz qux"].map(&fn(:split, :last)) #=> ["bar", "qux"]
+  # @example Composing symbplds and lambdas
+  #   (1..3).map(&fn(:next, -> x { x * x }, -> x { x.to_f / 2 } ))
   #   #=> [2.0, 4.5, 8.0]
   def fn(*funs)
-    -> x do
-      funs.inject(x) do |v,f|
+    ->(x) do
+      funs.inject(x) do |v, f|
         Proc === f ? f.call(v) : v.send(f)
       end
     end

data/lib/shenanigans/kernel/prompt.rb

@@ -1,5 +1,4 @@
 module Kernel
-
   # Currently only used by <tt>prompt</tt>:
   # <tt>:to_i</tt>, <tt>:to_f</tt>, <tt>:to_r</tt>, <tt>:to_sym</tt>, <tt>:to_c</tt>
   CONVERSIONS = [:to_i, :to_f, :to_r, :to_sym, :to_c]
@@ -7,14 +6,14 @@ module Kernel
   # Displays a prompt and returns chomped input.
   # Modelled after the Python method <tt>raw_input</tt>, but also can
   # be supplied with an optional conversion method.
+  # 
+  # @example A simple prompt
   #   prompt("Prompt> ")
-  #   Prompt> 12
-  #   #=> "12"
-  #
+  #   Prompt> 12 #=> "12"
+  # @example A prompt with conversion
   #   prompt("Prompt> ", :to_f)
-  #   Prompt> 12
-  #   #=> 12.0
-  def prompt(text='', conversion=nil)
+  #   Prompt> 12 #=> 12.0
+  def prompt(text = "", conversion = nil)
     print text unless text.empty?
     input = gets.chomp
     CONVERSIONS.include?(conversion) ? input.send(conversion) : input

data/lib/shenanigans/kernel/require_optional.rb

@@ -2,17 +2,17 @@ module Kernel
   # Optionally require a gem. If it is not available, <tt>nil</tt>
   # will be returned. Alternatively, a block can be provided with code
   # to run.
-  #   require 'non_existent'
-  #   #=> nil
   #
-  #   require 'non_existent' do
-  #     puts 'Something went wrong'
-  #   end
-  #   #=> Outputs 'Something went wrong'
+  # @example Without a block
+  #   require "non_existent" #=> nil
+  # @example With a custom block
+  #   require "non_existent" do
+  #     puts "Something went wrong"
+  #   end #=> Outputs "Something went wrong"
   def require_optional(gem, &block)
     require gem
   rescue LoadError
-    block.call if block
+    block&.call
   end
 
   private :require_optional

data/lib/shenanigans/kernel/with.rb

@@ -1,11 +1,12 @@
 module Kernel
   # A Pascal/ActionScript like <tt>with</tt> method. Yields its
   # argument to the provided block and then returns it.
+  #
+  # @example
   #   with([]) do |a|
   #     a << "a"
   #     a << "b"
-  #   end
-  #   #=> ["a", "b"]
+  #   end #=> ["a", "b"]
   def with(o, &blk)
     o.tap(&blk)
   end

data/lib/shenanigans/kernel.rb

@@ -1,4 +1,4 @@
-require_relative 'kernel/fn'
-require_relative 'kernel/prompt'
-require_relative 'kernel/with'
-require_relative 'kernel/require_optional'
+require_relative "kernel/fn"
+require_relative "kernel/prompt"
+require_relative "kernel/with"
+require_relative "kernel/require_optional"

data/lib/shenanigans/module/private_accessor.rb

@@ -1,7 +1,7 @@
 class Module
-  # Works like <tt>attr_accessor</tt> but generates private
-  # getter/setter methods for class internal use only. Useful
-  # for enforcing Smalltalk-style internal encapsulation.
+  # Works like <tt>attr_accessor</tt> but generates private getter/setter
+  # methods for class internal use only. Useful for enforcing Smalltalk-style
+  # internal encapsulation.
   #
   # For a more complete implementation of a similar feature see {ivar_encapsulation}[https://github.com/citizen428/ivar_encapsulation].
   def private_accessor(*names)
@@ -16,8 +16,8 @@ class Module
         instance_variable_set(instance_var_name, value)
       end
 
-      self.send(:private, name)
-      self.send(:private, "#{name}=")
+      send(:private, name)
+      send(:private, "#{name}=")
     end
     nil # like attr_accessor
   end

data/lib/shenanigans/module.rb

@@ -1 +1 @@
-require_relative 'module/private_accessor'
+require_relative "module/private_accessor"

data/lib/shenanigans/object/display.rb

@@ -2,16 +2,17 @@ class Object
   # Outputs the object and also returns it.
   # Will use <tt>puts</tt> if <tt>new_line</tt> is <tt>true</tt> and
   # <tt>print</tt> otherwise.
+  #
+  # @example
   #   "foo".display
-  #   foo
-  #   #=> "foo"
+  #   foo #=> "foo"
   #
   #   "foo".display(false)
   #   foo#=> "foo"
   def display(new_line = true)
     m = new_line ? :puts : :print
-    self.tap { |o| send(m, o) }
+    tap { |o| send(m, o) }
   end
 
-  alias :d :display
+  alias d display
 end

data/lib/shenanigans/object.rb

@@ -1,2 +1 @@
-require_relative 'object/it'
-require_relative 'object/display'
+require_relative "object/display"

data/lib/shenanigans/string/cmpi.rb

@@ -0,0 +1,9 @@
+class String
+  # Compares strings ignoring case
+  #
+  # @example
+  #   "test".cmpi("tesT") #=> true
+  def cmpi(other)
+    casecmp(other).zero?
+  end
+end

data/lib/shenanigans/string/in_groups_of.rb

@@ -1,14 +1,12 @@
 class String
   # Returns an array of the string broken down into groups of
   # <tt>size</tt> characters.
-  #   "aabbcc".in_groups_of(2)
-  #   #=> ['aa', 'bb', 'cc']
-  #   "".in_groups_of(2)
-  #   #=> []
-  #   "".in_groups_of(0)
-  #   #=> ArgumentError
+  #   "aabbcc".in_groups_of(2) #=> ['aa', 'bb', 'cc']
+  #   "".in_groups_of(2) #=> []
+  #   "".in_groups_of(0) #=> ArgumentError
   def in_groups_of(size)
     raise ArgumentError, "Size of group must be >= 1" if size < 1
+
     scan(/.{1,#{size}}/)
   end
 end

data/lib/shenanigans/string.rb

@@ -1 +1,2 @@
-require_relative 'string/in_groups_of'
+require_relative "string/in_groups_of"
+require_relative "string/cmpi"

data/lib/shenanigans.rb

@@ -1,7 +1,7 @@
-require 'shenanigans/array'
-require 'shenanigans/fixnum'
-require 'shenanigans/hash'
-require 'shenanigans/kernel'
-require 'shenanigans/module'
-require 'shenanigans/object'
-require 'shenanigans/string'
+require "shenanigans/array"
+require "shenanigans/hash"
+require "shenanigans/integer"
+require "shenanigans/kernel"
+require "shenanigans/module"
+require "shenanigans/object"
+require "shenanigans/string"

data/test/array/caret_test.rb

@@ -0,0 +1,9 @@
+require "minitest/autorun"
+require "shenanigans/array/caret"
+
+class ArrayCaret < Minitest::Test
+  def test_caret
+    result = [1, 2, 3] ^ [1, 2, 4]
+    assert result == [3, 4]
+  end
+end

data/test/array/{test_random_subarray.rb → random_subarray_test.rb}

@@ -1,7 +1,7 @@
-require 'minitest/autorun'
-require 'shenanigans/array/random_subarray'
+require "minitest/autorun"
+require "shenanigans/array/random_subarray"
 
-class RandomSubarray < MiniTest::Unit::TestCase
+class RandomSubarray < Minitest::Test
   def test_random_subarray
     result = [*1..5].random_subarray(3)
     assert result.size == 3

data/test/array/reductions_test.rb

@@ -0,0 +1,27 @@
+require "minitest/autorun"
+require "shenanigans/array/reductions"
+
+class ArrayReductions < Minitest::Test
+  TEST_ARRAY = [*1..4]
+
+  def test_reductions_without_params_or_block
+    assert_raises(ArgumentError) { TEST_ARRAY.reductions }
+  end
+
+  def test_reductions_operator_only
+    assert TEST_ARRAY.reductions(:+) == [1, 3, 6, 10]
+  end
+
+  def test_reductions_initial_only
+    assert TEST_ARRAY.reductions(50) { |acc, b| acc + b } == [50, 51, 53, 56, 60]
+  end
+
+  def test_reductions_inital_and_operator
+    assert TEST_ARRAY.reductions(50, :+) == [50, 51, 53, 56, 60]
+  end
+
+  def test_reductions_without_params
+    assert TEST_ARRAY.reductions { |acc, b| acc + b } == [1, 3, 6, 10]
+    assert %w[a b c].reductions { |s1, s2| s1 + s2 } == %w[a ab abc]
+  end
+end

data/test/array/zip_with_test.rb

@@ -0,0 +1,14 @@
+require "minitest/autorun"
+require "shenanigans/array/zip_with"
+
+class ZipWith < Minitest::Test
+  def test_zip_with_with_symbol
+    result = [*1..3].zip_with([*1..3], :+)
+    assert result == [2, 4, 6]
+  end
+
+  def test_zip_with_with_block
+    result = [*"a".."c"].zip_with([*"a".."c"]) { |a, b| a * 2 + b.upcase }
+    assert result == %w[aaA bbB ccC]
+  end
+end

data/test/hash/extract_test.rb

@@ -0,0 +1,11 @@
+require "minitest/autorun"
+require "shenanigans/hash/extract"
+
+class Extract < Minitest::Test
+  def test_extract
+    hash = { a: 1, b: 2, c: 3 }
+    assert_equal hash.extract(:b, :a), { a: 1, b: 2 }
+    assert_equal hash.extract(:a, :d), { a: 1 }
+    assert_equal({}.extract(:a, :c), {})
+  end
+end

data/test/hash/{test_has_shape_pred.rb → has_shape_pred_test.rb}

@@ -1,7 +1,7 @@
-require 'minitest/autorun'
-require 'shenanigans/hash/has_shape_pred'
+require "minitest/autorun"
+require "shenanigans/hash/has_shape_pred"
 
-class HasShape < MiniTest::Unit::TestCase
+class HasShape < Minitest::Test
   def setup
     @hash = {
       k1: 1.0,

data/test/hash/{test_to_ostruct.rb → to_ostruct_test.rb}

@@ -1,7 +1,7 @@
-require 'minitest/autorun'
-require 'shenanigans/hash/to_ostruct'
+require "minitest/autorun"
+require "shenanigans/hash/to_ostruct"
 
-class ToOstruct < MiniTest::Unit::TestCase
+class ToOstruct < Minitest::Test
   def test_simple_hash
     struct = {a: 1, b: 2}.to_ostruct
     assert struct.a == 1

data/test/integer/divisible_by_test.rb

@@ -0,0 +1,16 @@
+require "minitest/autorun"
+require "shenanigans/integer/divisible_by"
+
+class StringLength < Minitest::Test
+  def test_divide_by_zero
+    refute 3.divisible_by(0)
+  end
+
+  def test_not_divisible
+    refute 3.divisible_by(2)
+  end
+
+  def test_divisible
+    assert 9.divisible_by(3)
+  end
+end

data/test/integer/string_length_test.rb

@@ -0,0 +1,16 @@
+require "minitest/autorun"
+require "shenanigans/integer/string_length"
+
+class StringLength < Minitest::Test
+  def test_zero
+    assert 0.string_length == 1
+  end
+
+  def test_positive
+    assert 123.string_length == 3
+  end
+
+  def test_negative
+    assert(-1.string_length) == 2
+  end
+end

data/test/kernel/fn_test.rb

@@ -0,0 +1,14 @@
+require "minitest/autorun"
+require "shenanigans/kernel/fn"
+
+class Fn < Minitest::Test
+  def test_with_symbols
+    result = ["foo bar", "baz qux"].map(&fn(:split, :last))
+    assert result == ["bar", "qux"]
+  end
+
+  def test_with_symbols_and_lambdas
+    result = (1..3).map(&fn(:next, ->(x) { x * x }, ->(x) { x.to_f / 2 }))
+    assert result == [2.0, 4.5, 8.0]
+  end
+end

data/test/kernel/{test_prompt.rb → prompt_test.rb}

@@ -1,8 +1,8 @@
-require 'minitest/autorun'
-require 'shenanigans/kernel/prompt'
-require 'stringio'
+require "minitest/autorun"
+require "shenanigans/kernel/prompt"
+require "stringio"
 
-class Prompt < MiniTest::Unit::TestCase
+class Prompt < Minitest::Test
   def setup
     @orig_stdin = $stderr
     @orig_stdout = $stdout