midwire_common 1.1.1 → 2.0.0

data/docs/plans/2026-02-13-refinements-modernization-design.md

@@ -0,0 +1,109 @@
+# midwire_common 2.0.0 — Refinements & Modernization Design
+
+## Summary
+
+Replace all monkey-patching of Ruby core classes with **refinements**, modernize dependencies, bump minimum Ruby to 3.2, remove methods that overlap with stdlib, and release as version 2.0.0. Clean break — no backward compatibility layer.
+
+## Approach: Refinements
+
+Each monkey-patched file becomes a refinement module. Consumers opt in with `using`:
+
+```ruby
+using MidwireCommon::StringExtensions
+"MyClass".snakerize  # => "my_class"
+```
+
+Or use `MidwireCommon::All` to activate everything:
+
+```ruby
+using MidwireCommon::All
+```
+
+## Module Structure
+
+| Current file | New module | Notes |
+|---|---|---|
+| `string.rb` | `MidwireCommon::StringExtensions` | |
+| `array.rb` | `MidwireCommon::ArrayExtensions` | |
+| `hash.rb` | `MidwireCommon::HashExtensions` | |
+| `float.rb` | `MidwireCommon::FloatExtensions` | |
+| `fixnum.rb` | `MidwireCommon::IntegerExtensions` | Fixnum → Integer |
+| `enumerable.rb` | `MidwireCommon::EnumerableExtensions` | |
+| `time.rb` | `MidwireCommon::TimeExtensions` | |
+| `file.rb` + `file/stat.rb` | `MidwireCommon::FileExtensions` | |
+
+`NumberBehavior` stays as a module, included inside `refine` blocks for Float and Integer.
+
+`BottomlessHash` moves under `MidwireCommon::BottomlessHash` namespace.
+
+## Methods Removed (stdlib equivalents)
+
+- `String#trim`, `#trim!`, `#left_trim`, `#left_trim!`, `#right_trim`, `#right_trim!` — use `strip`/`lstrip`/`rstrip`
+- `Array#binsearch` — use `Array#bsearch` (built-in since Ruby 2.0)
+- `Hash#except` — built into Ruby 3.0+
+
+## Methods Kept (by module)
+
+### StringExtensions
+- `String.random` (class method)
+- `#left_substr`, `#right_substr`
+- `#here_with_pipe`
+- `#alpha_numeric?`, `#email_address?`, `#zipcode?`, `#numeric?`
+- `#format_phone`, `#sanitize`, `#sanitize!`, `#shorten`
+- `#escape_single_quotes`, `#escape_double_quotes`
+- `#snakerize`, `#camelize`
+
+### ArrayExtensions
+- `#count_occurrences`, `#randomize`, `#randomize!`
+- `#sort_case_insensitive`
+- `#each_with_first_last`
+- `#superjoin`
+
+### HashExtensions
+- `#bottomless` (returns `MidwireCommon::BottomlessHash`)
+- `#grep`, `#diff`, `#apply_diff`, `#apply_diff!`
+- `#only`, `#pop`
+- `#to_query_string` (fix: `URI.encode` → `URI.encode_www_form_component`)
+- `#symbolize_keys`, `#symbolize_keys!`, `#recursively_symbolize_keys!`
+
+### IntegerExtensions / FloatExtensions
+- `#commify` (via `NumberBehavior`)
+
+### EnumerableExtensions
+- `#sort_by_frequency`
+
+### TimeExtensions
+- `Time.timestamp` (class method)
+
+### FileExtensions
+- `File::Stat.device_name` (class method)
+
+## Utility Classes (unchanged, already namespaced)
+- `MidwireCommon::DataFileCache`
+- `MidwireCommon::YamlSetting`
+- `MidwireCommon::TimeTool`
+- `MidwireCommon::RakeHelper`
+
+## Dependency Updates
+
+| Gem | From | To |
+|---|---|---|
+| `required_ruby_version` | `~> 2` | `>= 3.2` |
+| `rspec` | `~> 2.14` | `~> 3.12` |
+| `rake` | `~> 10.1` | `~> 13.0` |
+| `rubocop` | `~> 0.36` | current |
+| `simplecov` | `~> 0.7` | `~> 0.22` |
+| `pry-nav` | `~> 0.2` | **removed** (use `debug` gem, built into Ruby 3.2+) |
+| `guard`, `guard-*` | various | **removed** |
+
+## Test Changes
+
+- Update all specs to use refinements (`using MidwireCommon::StringExtensions` etc.)
+- Add missing specs for `Hash#apply_diff` and `Hash#apply_diff!`
+- Remove specs for deleted methods
+- Rename `fixnum_spec.rb` → `integer_spec.rb`
+- Remove Guardfile
+
+## Version
+
+2.0.0 — major bump signals breaking API change.

data/lib/midwire_common/all.rb

@@ -1,11 +1,26 @@
+# frozen_string_literal: true
+
 require 'midwire_common/array'
 require 'midwire_common/enumerable'
 require 'midwire_common/data_file_cache'
 require 'midwire_common/file'
-require 'midwire_common/fixnum'
+require 'midwire_common/integer'
 require 'midwire_common/float'
 require 'midwire_common/hash'
 require 'midwire_common/string'
 require 'midwire_common/time'
 require 'midwire_common/time_tool'
 require 'midwire_common/yaml_setting'
+
+module MidwireCommon
+  module All
+    include MidwireCommon::StringExtensions
+    include MidwireCommon::ArrayExtensions
+    include MidwireCommon::HashExtensions
+    include MidwireCommon::IntegerExtensions
+    include MidwireCommon::FloatExtensions
+    include MidwireCommon::EnumerableExtensions
+    include MidwireCommon::TimeExtensions
+    include MidwireCommon::FileExtensions
+  end
+end

data/lib/midwire_common/array.rb

@@ -1,54 +1,44 @@
-# A light-weight super Array class
-class Array
-  def count_occurrences
-    hash = Hash.new(0)
-    each { |elem| hash[elem] += 1 }
-    hash
-  end
+# frozen_string_literal: true
 
-  def randomize
-    sort_by { rand }
-  end
+module MidwireCommon
+  module ArrayExtensions
+    refine Array do
+      def count_occurrences
+        hash = Hash.new(0)
+        each { |elem| hash[elem] += 1 }
+        hash
+      end
 
-  def randomize!
-    replace(randomize)
-  end
+      def randomize
+        sort_by { rand }
+      end
 
-  def sort_case_insensitive
-    sort_by(&:downcase)
-  end
+      def randomize!
+        replace(randomize)
+      end
 
-  def each_with_first_last(first_code, main_code, last_code)
-    each_with_index do |item, ndx|
-      case ndx
-      when 0 then first_code.call(item)
-      when size - 1 then last_code.call(item)
-      else main_code.call(item)
+      def sort_case_insensitive
+        sort_by(&:downcase)
       end
-    end
-  end
 
-  # Binary search returns index if found or nil
-  # rubocop:disable Metrics/LineLength
-  # rubocop:disable Style/SpaceAfterComma, Style/SpaceAroundOperators, Style/SpaceAfterColon, Style/SpaceAfterSemicolon, Style/Semicolon
-  def binsearch(e, l = 0, u = length - 1)
-    return if l>u;m=(l+u)/2;e<self[m]?u=m-1:l=m+1;e==self[m]?m:binsearch(e,l,u)
-  end
-  # rubocop:enable Style/SpaceAfterComma, Style/SpaceAroundOperators, Style/SpaceAfterColon, Style/SpaceAfterSemicolon, Style/Semicolon
+      def each_with_first_last(first_code, main_code, last_code)
+        each_with_index do |item, ndx|
+          case ndx
+          when 0 then first_code.call(item)
+          when size - 1 then last_code.call(item)
+          else main_code.call(item)
+          end
+        end
+      end
 
-  # Make a string from a multi-dimensional array :
-  # 1 dimension :
-  # [1,2,3].superjoin(["pre-array","between-cell","post-array"])
-  #
-  # 2 dimensions: (html table)
-  # [[1,2],[2,3]].superjoin( %w{<table><tr> </tr><tr> </tr></table>}, %w{<td> </td><td> </td>} )
-  # => <table><tr><td>1</td><td>2</td></tr><tr><td>2</td><td>3</td></tr></table>
-  def superjoin(*ldescr)
-    dim = ldescr[0]
-    rest = ldescr[1..-1]
-    dim[0] + map do |arr|
-      (arr.respond_to?(:superjoin) && !rest.empty?) ? arr.superjoin(*rest) : arr.to_s
-    end.join(dim[1]) + dim[2]
+      # Make a string from a multi-dimensional array
+      def superjoin(*ldescr)
+        dim = ldescr[0]
+        rest = ldescr[1..]
+        dim[0] + map do |arr|
+          arr.respond_to?(:superjoin) && !rest.empty? ? arr.superjoin(*rest) : arr.to_s
+        end.join(dim[1]) + dim[2]
+      end
+    end
   end
-  # rubocop:enable Metrics/LineLength
 end

data/lib/midwire_common/data_file_cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MidwireCommon
   # A simple class to cache data in a file
   class DataFileCache
@@ -10,7 +12,7 @@ module MidwireCommon
     def put(data)
       newdata = data.dup
       newdata = newdata.join("\n") if newdata.is_a? Array
-      File.open(@cache_file, 'w') { |file| file.write(newdata) }
+      File.write(@cache_file, newdata)
     end
 
     def get
@@ -19,19 +21,18 @@ module MidwireCommon
 
     def age
       return 999_999_99.0 unless File.exist?(@cache_file)
+
       (Time.now - File.ctime(@cache_file)).to_f
     end
 
     private
 
     def ensure_cache_dir
-      FileUtils.mkdir_p(@cache_dir) unless File.exist?(@cache_dir)
+      FileUtils.mkdir_p(@cache_dir)
     end
 
     def normalize_filename(filename)
-      unless filename.match(Regexp.new(@cache_dir))
-        filename = "#{@cache_dir}/#{filename}"
-      end
+      filename = "#{@cache_dir}/#{filename}" unless filename.match(Regexp.new(@cache_dir))
       filename
     end
   end

data/lib/midwire_common/enumerable.rb

@@ -1,11 +1,15 @@
-# A more useful Enumerable module
-module Enumerable
-  # Sort by frequency of occurrence
-  def sort_by_frequency
-    histogram = each_with_object(Hash.new(0)) do |elem, hash|
-      hash[elem] += 1
-      hash
+# frozen_string_literal: true
+
+module MidwireCommon
+  module EnumerableExtensions
+    refine Enumerable do
+      def sort_by_frequency
+        histogram = each_with_object(Hash.new(0)) do |elem, hash|
+          hash[elem] += 1
+          hash
+        end
+        sort_by { |elem| [histogram[elem] * -1, elem] }
+      end
     end
-    sort_by { |elem| [histogram[elem] * -1, elem] }
   end
 end

data/lib/midwire_common/file.rb

@@ -1 +1,13 @@
-require 'midwire_common/file/stat'
+# frozen_string_literal: true
+
+module MidwireCommon
+  module FileExtensions
+    refine File::Stat.singleton_class do
+      def device_name(file)
+        Dir['/dev/*'].inject({}) do |hash, node|
+          hash.update(File.stat(node).rdev => node)
+        end.values_at(File.stat(file).dev).first || nil
+      end
+    end
+  end
+end

data/lib/midwire_common/float.rb

@@ -1,4 +1,11 @@
-# A more useful Float class
-class Float
-  include MidwireCommon::NumberBehavior
+# frozen_string_literal: true
+
+require 'midwire_common'
+
+module MidwireCommon
+  module FloatExtensions
+    refine Float do
+      import_methods MidwireCommon::NumberBehavior
+    end
+  end
 end

data/lib/midwire_common/hash.rb

@@ -1,128 +1,117 @@
-# By Nick Ostrovsky
-# http://firedev.com/posts/2015/bottomless-ruby-hash/
-class BottomlessHash < Hash
-  def initialize
-    super(&-> (hash, key) { hash[key] = self.class.new })
-  end
+# frozen_string_literal: true
 
-  def self.from_hash(hash)
-    new.merge(hash)
-  end
-end
+require 'uri'
 
-# A more useful Hash class
-class Hash
-  def bottomless
-    BottomlessHash.from_hash(self)
-  end
+module MidwireCommon
+  # By Nick Ostrovsky
+  # http://firedev.com/posts/2015/bottomless-ruby-hash/
+  class BottomlessHash < Hash
+    def self.from_hash(hash)
+      new.merge(hash)
+    end
 
-  # A better grep
-  def grep(pattern)
-    each_with_object([]) do |kv, res|
-      res << kv if kv[0] =~ pattern || kv[1] =~ pattern
-      res
+    def initialize
+      super(&->(hash, key) { hash[key] = self.class.new })
     end
+
   end
 
-  # rubocop:disable Metrics/AbcSize
-  def diff(other)
-    (keys + other.keys).uniq.each_with_object({}) do |key, memo|
-      unless self[key] == other[key]
-        memo[key] = if self[key].is_a?(Hash) && other[key].is_a?(Hash)
-                      self[key].diff(other[key])
-                    else
-                      [self[key], other[key]]
-                    end
+  module HashExtensions
+    refine Hash do
+      def bottomless
+        MidwireCommon::BottomlessHash.from_hash(self)
       end
-      memo
-    end
-  end
-  # rubocop:enable Metrics/AbcSize
 
-  # TODO: Spec/Test this method
-  def apply_diff!(changes, direction = :right)
-    path = [[self, changes]]
-    pos, local_changes = path.pop
-    while local_changes
-      local_changes.each_pair do |key, change|
-        if change.is_a?(Array)
-          pos[key] = (direction == :right) ? change[1] : change[0]
-        else
-          path.push([pos[key], change])
+      def grep(pattern)
+        each_with_object([]) do |kv, res|
+          res << kv if kv[0] =~ pattern || kv[1] =~ pattern
+          res
         end
       end
-      pos, local_changes = path.pop
-    end
-    self
-  end
 
-  # TODO: Spec/Test this method
-  # rubocop:disable Metrics/AbcSize
-  def apply_diff(changes, direction = :right)
-    cloned = clone
-    path = [[cloned, changes]]
-    pos, local_changes = path.pop
-    while local_changes
-      local_changes.each_pair do |key, change|
-        if change.is_a?(Array)
-          pos[key] = (direction == :right) ? change[1] : change[0]
-        else
-          pos[key] = pos[key].clone
-          path.push([pos[key], change])
+      def diff(other)
+        (keys + other.keys).uniq.each_with_object({}) do |key, memo|
+          unless self[key] == other[key]
+            memo[key] = if self[key].is_a?(Hash) && other[key].is_a?(Hash)
+              self[key].diff(other[key])
+                        else
+                          [self[key], other[key]]
+            end
+          end
+          memo
         end
       end
-      pos, local_changes = path.pop
-    end
-    cloned
-  end
-  # rubocop:enable Metrics/AbcSize
 
-  # Usage { :a => 1, :b => 2, :c => 3}.except(:a) -> { :b => 2, :c => 3}
-  def except(*keys)
-    reject { |key, _v| keys.flatten.include?(key.to_sym) }
-  end
+      def apply_diff!(changes, direction = :right)
+        path = [[self, changes]]
+        pos, local_changes = path.pop
+        while local_changes
+          local_changes.each_pair do |key, change|
+            if change.is_a?(Array)
+              pos[key] = direction == :right ? change[1] : change[0]
+            else
+              path.push([pos[key], change])
+            end
+          end
+          pos, local_changes = path.pop
+        end
+        self
+      end
 
-  # Usage { :a => 1, :b => 2, :c => 3}.only(:a) -> {:a => 1}
-  def only(*keys)
-    dup.reject { |key, _v| !keys.flatten.include?(key.to_sym) }
-  end
+      def apply_diff(changes, direction = :right)
+        cloned = clone
+        path = [[cloned, changes]]
+        pos, local_changes = path.pop
+        while local_changes
+          local_changes.each_pair do |key, change|
+            if change.is_a?(Array)
+              pos[key] = direction == :right ? change[1] : change[0]
+            else
+              pos[key] = pos[key].clone
+              path.push([pos[key], change])
+            end
+          end
+          pos, local_changes = path.pop
+        end
+        cloned
+      end
 
-  # Usage h = { :a => 1, :b => 2, :c => 3}.pop(:a) -> {:a => 1}
-  # ... and now h == { :b => 2, :c => 3}
-  def pop(*keys)
-    ret = reject { |key, _v| !keys.flatten.include?(key.to_sym) }
-    reject! { |key, _v| keys.flatten.include?(key.to_sym) }
-    ret
-  end
+      def only(*keys)
+        dup.select { |key, _v| keys.flatten.include?(key.to_sym) }
+      end
 
-  # Usage { :a => 1, :b => 2, :c => 3}.to_query_string #= a=1&b=2&c=3
-  def to_query_string
-    require 'uri'
-    map do |key, value|
-      "#{URI.encode(key.to_s)}=#{URI.encode(value.to_s)}"
-    end.join('&')
-  end
+      def pop(*keys)
+        ret = reject { |key, _v| !keys.flatten.include?(key.to_sym) }
+        reject! { |key, _v| keys.flatten.include?(key.to_sym) }
+        ret
+      end
 
-  # rubocop:disable Style/RescueModifier
-  def symbolize_keys!
-    keys.each do |key|
-      self[(key.to_sym rescue key) || key] = delete(key)
-    end
-    self
-  end
-  # rubocop:enable Style/RescueModifier
+      def to_query_string
+        URI.encode_www_form(self)
+      end
 
-  def symbolize_keys
-    dup.symbolize_keys!
-  end
+      def symbolize_keys!
+        keys.each do |key|
+          self[begin
+            key.to_sym
+          rescue StandardError
+            key
+          end || key] = delete(key)
+        end
+        self
+      end
 
-  # Recursively change keys to symbols
-  # Modifies the hash keys in place.
-  def recursively_symbolize_keys!
-    symbolize_keys!
-    values.each do |value|
-      value.recursively_symbolize_keys! if value.is_a?(Hash)
+      def symbolize_keys
+        dup.symbolize_keys!
+      end
+
+      def recursively_symbolize_keys!
+        symbolize_keys!
+        values.each do |value|
+          value.recursively_symbolize_keys! if value.is_a?(Hash)
+        end
+        self
+      end
     end
-    self
   end
 end

data/lib/midwire_common/integer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'midwire_common'
+
+module MidwireCommon
+  module IntegerExtensions
+    refine Integer do
+      import_methods MidwireCommon::NumberBehavior
+    end
+  end
+end

data/lib/midwire_common/number_behavior.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module MidwireCommon
   # Common number behavior
   module NumberBehavior
     # Format a number with commas and a decimal point
     # rubocop:disable Style/PerlBackrefs
     def commify
-      to_s =~ /([^\.]*)(\..*)?/
+      to_s =~ /([^.]*)(\..*)?/
       int = $1.reverse
-      dec = $2 ? $2 : ''
+      dec = $2 || ''
       while int.gsub!(/(,|\.|^)(\d{3})(\d)/, '\1\2,\3')
       end
       int.reverse + dec

data/lib/midwire_common/rake_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'midwire_common'
 
 module MidwireCommon
@@ -5,20 +7,20 @@ module MidwireCommon
   class RakeHelper
     include Rake::DSL if defined? Rake::DSL
 
+    attr_reader :basedir
+
     def self.install_tasks(opts = {})
       dir = opts[:dir] || Dir.pwd
       new(dir).install
     end
 
-    attr_reader :basedir
-
     def initialize(basedir)
       @basedir = basedir
     end
 
     def install
       task_dir = File.expand_path('../tasks', File.dirname(__FILE__))
-      Dir["#{task_dir}/*.rake"].sort.each { |ext| load ext }
+      Dir["#{task_dir}/*.rake"].each { |ext| load ext }
     end
   end
 end

data/lib/midwire_common/rake_tasks.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require 'midwire_common/rake_helper'
 MidwireCommon::RakeHelper.install_tasks