Apply base rubocop ssettings to the repo

Author: aetherknight

.rubocop.yml

@@ -10,3 +10,32 @@
 # See https://docs.rubocop.org/rubocop/configuration
 Layout/LineLength:
   Max: 120
+
+Metrics/BlockLength:
+  Exclude:
+    - "spec/**/*.rb"
+    - "*.gemspec"
+
+Metrics/MethodLength:
+  Enabled: false
+
+Naming/FileName:
+  Exclude:
+    # This file is deliberately named with dashes, to match the package name
+    - 'lib/recursive-open-struct.rb'
+
+Style/CommentedKeyword:
+  Exclude:
+    - "spec/**/*.rb"
+
+Style/Documentation:
+  Enabled: false
+
+# Can't really disable this in the gemspec file (it is reported on line 1, but
+# line 1 has the frozen string literal comment)
+Gemspec/RequiredRubyVersion:
+  Enabled: false
+# TODO: should I set a required ruby version? At the moment, the project policy
+# is to officially support supported Ruby versions (and JRuby), but to not
+# officially support no-longer-maintained Ruby versions.
+

Gemfile

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 gemspec

Rakefile

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require 'rubygems'
 require 'bundler/gem_tasks'
@@ -9,16 +9,16 @@ RSpec::Core::RakeTask.new(:spec) do |spec|
 end
 namespace :spec do
   if RUBY_VERSION =~ /^1\.8/
-    desc "Rspec code coverage (1.8.7)"
+    desc 'Rspec code coverage (1.8.7)'
     RSpec::Core::RakeTask.new(:coverage) do |spec|
       spec.pattern = 'spec/**/*_spec.rb'
       spec.rcov = true
     end
   else
-    desc "Rspec code coverage (1.9+)"
+    desc 'Rspec code coverage (1.9+)'
     task :coverage do
       ENV['COVERAGE'] = 'true'
-      Rake::Task["spec"].execute
+      Rake::Task['spec'].execute
     end
   end
 end
@@ -28,36 +28,36 @@ RuboCop::RakeTask.new
 
 require 'rdoc/task'
 Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+  version = File.exist?('VERSION') ? File.read('VERSION') : ''
 
   rdoc.rdoc_dir = 'rdoc'
   rdoc.title = "recursive-open-struct #{version}"
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-task :default => [:spec, :rubocop]
+task default: %i[spec rubocop]
 
 task :fix_permissions do
-  File.umask 0022
+  File.umask 0o022
   filelist = `git ls-files`.split("\n")
-  FileUtils.chmod 0644, filelist, :verbose => true
-  FileUtils.chmod 0755, ['lib','spec'], :verbose => true
+  FileUtils.chmod 0o644, filelist, verbose: true
+  FileUtils.chmod 0o755, %w[lib spec], verbose: true
 end
 
-desc "Update the AUTHORS.txt file"
+desc 'Update the AUTHORS.txt file'
 task :update_authors do
   authors = `git log --format="%aN <%aE>"|sort -f|uniq`
   File.open('AUTHORS.txt', 'w') do |f|
     f.write("Recursive-open-struct was written by these fine people:\n\n")
-    f.write(authors.split("\n").map { |a| "* #{a}" }.join( "\n" ))
+    f.write(authors.split("\n").map { |a| "* #{a}" }.join("\n"))
     f.write("\n")
   end
 end
 
-task :build => [:update_authors, :fix_permissions]
+task build: %i[update_authors fix_permissions]
 
-desc "Run an interactive pry shell with ros required"
+desc 'Run an interactive pry shell with ros required'
 task :pry do
-  sh "pry -I lib -r recursive-open-struct"
+  sh 'pry -I lib -r recursive-open-struct'
 end

lib/recursive-open-struct.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require 'recursive_open_struct'

lib/recursive_open_struct.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'ostruct'
 require 'recursive_open_struct/version'
 
@@ -12,6 +14,7 @@
 # TODO: `#*_as_a_hash` deprecated. Nested hashes can be referenced using
 # `#to_h`.
 
+# rubocop:disable Metrics/ClassLength
 class RecursiveOpenStruct < OpenStruct
   include Dig if OpenStruct.public_instance_methods.include? :dig
 
@@ -28,7 +31,9 @@ def self.default_options
     }
   end
 
-  def initialize(hash=nil, passed_options={})
+  # rubocop:disable Lint/MissingSuper
+  # Intentionally doesn't call super and initializes +@table+ itself.
+  def initialize(hash = nil, passed_options = {})
     hash = hash.to_h if [hash.is_a?(RecursiveOpenStruct), hash.is_a?(OpenStruct)].any?
     hash ||= {}
 
@@ -40,6 +45,7 @@ def initialize(hash=nil, passed_options={})
 
     @sub_elements = {}
   end
+  # rubocop:enable Lint/MissingSuper
 
   def marshal_load(attributes)
     hash, @options = attributes
@@ -69,17 +75,17 @@ def to_h
 
   # TODO: deprecated, unsupported by OpenStruct. OpenStruct does not consider
   # itself to be a "kind of" Hash.
-  alias_method :to_hash, :to_h
+  alias to_hash to_h
 
   # Continue supporting older rubies -- JRuby 9.1.x.x is still considered
   # stable, but is based on Ruby
   # 2.3.x and so uses :modifiable instead of :modifiable?. Furthermore, if
   # :modifiable is private, then make :modifiable? private too.
-  if !OpenStruct.private_instance_methods.include?(:modifiable?)
+  unless OpenStruct.private_instance_methods.include?(:modifiable?)
     if OpenStruct.private_instance_methods.include?(:modifiable)
-      alias_method :modifiable?, :modifiable
+      alias modifiable? modifiable
     elsif OpenStruct.public_instance_methods.include?(:modifiable)
-      alias_method :modifiable?, :modifiable
+      alias modifiable? modifiable
       private :modifiable?
     end
   end
@@ -89,7 +95,7 @@ def [](name)
     v = @table[key_name]
     if v.is_a?(Hash)
       @sub_elements[key_name] ||= _create_sub_element_(v, mutate_input_hash: true)
-    elsif v.is_a?(Array) and @options[:recurse_over_arrays]
+    elsif v.is_a?(Array) && @options[:recurse_over_arrays]
       @sub_elements[key_name] ||= recurse_over_array(v)
       @sub_elements[key_name] = recurse_over_array(@sub_elements[key_name])
     else
@@ -100,7 +106,7 @@ def [](name)
   if private_instance_methods.include?(:modifiable?) || public_instance_methods.include?(:modifiable?)
     def []=(name, value)
       key_name = _get_key_from_table_(name)
-      tbl = modifiable?  # Ensure we are modifiable
+      tbl = modifiable? # Ensure we are modifiable
       @sub_elements.delete(key_name)
       tbl[key_name] = value
     end
@@ -120,19 +126,20 @@ def respond_to_missing?(mid, include_private = false)
 
   # Adapted implementation of method_missing to accommodate the differences
   # between ROS and OS.
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/PerceivedComplexity
   def method_missing(mid, *args)
     len = args.length
     if mid =~ /^(.*)=$/
-      if len != 1
-        raise ArgumentError, "wrong number of arguments (#{len} for 1)", caller(1)
-      end
+      raise ArgumentError, "wrong number of arguments (#{len} for 1)", caller(1) if len != 1
+
       # self[$1.to_sym] = args[0]
       # modifiable?[new_ostruct_member!($1.to_sym)] = args[0]
-      new_ostruct_member!($1.to_sym)
+      new_ostruct_member!(::Regexp.last_match(1).to_sym)
       public_send(mid, args[0])
-    elsif len == 0
+    elsif len.zero?
       key = mid
-      key = $1 if key =~ /^(.*)_as_a_hash$/
+      key = ::Regexp.last_match(1) if key =~ /^(.*)_as_a_hash$/
       if @table.key?(_get_key_from_table_(key))
         new_ostruct_member!(key)
         public_send(mid)
@@ -147,6 +154,8 @@ def method_missing(mid, *args)
       raise err
     end
   end
+  # rubocop:enable Metrics/PerceivedComplexity
+  # rubocop:enable Metrics/AbcSize
 
   def freeze
     @table.each_key do |key|
@@ -160,7 +169,7 @@ def freeze
   # 2.4.0.
   def new_ostruct_member(name)
     key_name = _get_key_from_table_(name)
-    unless self.singleton_class.method_defined?(name.to_sym)
+    unless singleton_class.method_defined?(name.to_sym)
       class << self; self; end.class_eval do
         define_method(name) do
           self[key_name]
@@ -185,7 +194,12 @@ class << self; self; end.class_eval do
 
   def delete_field(name)
     sym = _get_key_from_table_(name)
-    singleton_class.__send__(:remove_method, sym, "#{sym}=") rescue NoMethodError # ignore if methods not yet generated.
+    begin
+      singleton_class.__send__(:remove_method, sym, "#{sym}=")
+    rescue StandardError
+      # ignore if methods not yet generated.
+      NoMethodError
+    end
     @sub_elements.delete(sym)
     @table.delete(sym)
   end
@@ -203,8 +217,9 @@ def initialize_dup(orig)
   end
 
   def _get_key_from_table_(name)
-    return name.to_s if @table.has_key?(name.to_s)
-    return name.to_sym if @table.has_key?(name.to_sym)
+    return name.to_s if @table.key?(name.to_s)
+    return name.to_sym if @table.key?(name.to_sym)
+
     name
   end
 
@@ -222,5 +237,5 @@ def recurse_over_array(array)
     end
     array
   end
-
 end
+# rubocop:enable Metrics/ClassLength

lib/recursive_open_struct/debug_inspect.rb

@@ -1,38 +1,46 @@
-module RecursiveOpenStruct::DebugInspect
-  def debug_inspect(io = STDOUT, indent_level = 0, recursion_limit = 12)
-    display_recursive_open_struct(io, @table, indent_level, recursion_limit)
-  end
+# frozen_string_literal: true
 
-  def display_recursive_open_struct(io, ostrct_or_hash, indent_level, recursion_limit)
+# rubocop:disable Metrics/AbcSize
+# rubocop:disable Metrics/CyclomaticComplexity
+# rubocop:disable Metrics/PerceivedComplexity
+# rubocop:disable Style/StringConcatenation
+class RecursiveOpenStruct < OpenStruct
+  module DebugInspect
+    def debug_inspect(io = $stdout, indent_level = 0, recursion_limit = 12)
+      display_recursive_open_struct(io, @table, indent_level, recursion_limit)
+    end
 
-    if recursion_limit <= 0 then
-      # protection against recursive structure (like in the tests)
-      io.puts '  '*indent_level + '(recursion limit reached)'
-    else
-      #puts ostrct_or_hash.inspect
-      if ostrct_or_hash.is_a?(self.class) then
-        ostrct_or_hash = ostrct_or_hash.marshal_dump
-      end
+    def display_recursive_open_struct(io, ostrct_or_hash, indent_level, recursion_limit)
+      if recursion_limit <= 0
+        # protection against recursive structure (like in the tests)
+        io.puts '  ' * indent_level + '(recursion limit reached)'
+      else
+        # puts ostrct_or_hash.inspect
+        ostrct_or_hash = ostrct_or_hash.marshal_dump if ostrct_or_hash.is_a?(self.class)
 
-      # We'll display the key values like this :    key =  value
-      # to align display, we look for the maximum key length of the data that will be displayed
-      # (everything except hashes)
-      data_indent = ostrct_or_hash \
-        .reject { |k, v| v.is_a?(self.class) || v.is_a?(Hash) } \
-        .max {|a,b| a[0].to_s.length <=> b[0].to_s.length}[0].to_s.length
-      # puts "max length = #{data_indent}"
+        # We'll display the key values like this :    key =  value
+        # to align display, we look for the maximum key length of the data that will be displayed
+        # (everything except hashes)
+        data_indent = ostrct_or_hash \
+                      .reject { |_k, v| v.is_a?(self.class) || v.is_a?(Hash) } \
+                      .max { |a, b| a[0].to_s.length <=> b[0].to_s.length }[0].to_s.length
+        # puts "max length = #{data_indent}"
 
-      ostrct_or_hash.each do |key, value|
-        if (value.is_a?(self.class) || value.is_a?(Hash)) then
-          io.puts '  '*indent_level + key.to_s + '.'
-          display_recursive_open_struct(io, value, indent_level + 1, recursion_limit - 1)
-        else
-          io.puts '  '*indent_level + key.to_s + ' '*(data_indent - key.to_s.length) + ' = ' + value.inspect
+        ostrct_or_hash.each do |key, value|
+          if value.is_a?(self.class) || value.is_a?(Hash)
+            io.puts '  ' * indent_level + key.to_s + '.'
+            display_recursive_open_struct(io, value, indent_level + 1, recursion_limit - 1)
+          else
+            io.puts '  ' * indent_level + key.to_s + ' ' * (data_indent - key.to_s.length) + ' = ' + value.inspect
+          end
         end
       end
-    end
 
-    true
+      true
+    end
   end
-
 end
+# rubocop:enable Style/StringConcatenation
+# rubocop:enable Metrics/PerceivedComplexity
+# rubocop:enable Metrics/CyclomaticComplexity
+# rubocop:enable Metrics/AbcSize