Layout/CaseIndentation

This commit enables the Rubocop Layout/CaseIndentation cop.

Author: mhashizume

.rubocop_todo.yml

@@ -69,12 +69,6 @@ Layout/AssignmentIndentation:
     - 'lib/puppet/util.rb'
     - 'lib/puppet/util/windows/daemon.rb'
 
-# This cop supports safe auto-correction (--auto-correct).
-# Configuration parameters: EnforcedStyle, IndentOneStep, IndentationWidth.
-# SupportedStyles: case, end
-Layout/CaseIndentation:
-  Enabled: false
-
 # This cop supports safe auto-correction (--auto-correct).
 Layout/ClosingHeredocIndentation:
   Enabled: false

lib/puppet/file_system/uniquefile.rb

@@ -100,14 +100,14 @@ def path
 
   def make_tmpname(prefix_suffix, n)
     case prefix_suffix
-      when String
-        prefix = prefix_suffix
-        suffix = ""
-      when Array
-        prefix = prefix_suffix[0]
-        suffix = prefix_suffix[1]
-      else
-        raise ArgumentError, _("unexpected prefix_suffix: %{value}") % { value: prefix_suffix.inspect }
+    when String
+      prefix = prefix_suffix
+      suffix = ""
+    when Array
+      prefix = prefix_suffix[0]
+      suffix = prefix_suffix[1]
+    else
+      raise ArgumentError, _("unexpected prefix_suffix: %{value}") % { value: prefix_suffix.inspect }
     end
     t = Time.now.strftime("%Y%m%d")
     path = "#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}"

lib/puppet/http/dns.rb

@@ -49,9 +49,9 @@ def each_srv_record(domain, service_name = :puppet, &block)
       Puppet.debug "Searching for SRV records for domain: #{domain}"
 
       case service_name
-        when :puppet then service = '_x-puppet'
-        when :file   then service = '_x-puppet-fileserver'
-        else              service = "_x-puppet-#{service_name}"
+      when :puppet then service = '_x-puppet'
+      when :file   then service = '_x-puppet-fileserver'
+      else              service = "_x-puppet-#{service_name}"
       end
       record_name = "#{service}._tcp.#{domain}"
 

lib/puppet/indirector/catalog/compiler.rb

@@ -158,17 +158,17 @@ def get_content_uri(metadata, source, environment_path)
   # Also used to profile/log reasons for not inlining.
   def inlineable?(resource, sources)
     case
-      when resource[:ensure] == 'absent'
-        #TRANSLATORS Inlining refers to adding additional metadata (in this case we are not inlining)
-        return Puppet::Util::Profiler.profile(_("Not inlining absent resource"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :absent]) { false }
-      when sources.empty?
-        #TRANSLATORS Inlining refers to adding additional metadata (in this case we are not inlining)
-        return Puppet::Util::Profiler.profile(_("Not inlining resource without sources"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :no_sources]) { false }
-      when (not (sources.all? {|source| source =~ /^puppet:/}))
-        #TRANSLATORS Inlining refers to adding additional metadata (in this case we are not inlining)
-        return Puppet::Util::Profiler.profile(_("Not inlining unsupported source scheme"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :unsupported_scheme]) { false }
-      else
-        return true
+    when resource[:ensure] == 'absent'
+      #TRANSLATORS Inlining refers to adding additional metadata (in this case we are not inlining)
+      return Puppet::Util::Profiler.profile(_("Not inlining absent resource"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :absent]) { false }
+    when sources.empty?
+      #TRANSLATORS Inlining refers to adding additional metadata (in this case we are not inlining)
+      return Puppet::Util::Profiler.profile(_("Not inlining resource without sources"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :no_sources]) { false }
+    when (not (sources.all? {|source| source =~ /^puppet:/}))
+      #TRANSLATORS Inlining refers to adding additional metadata (in this case we are not inlining)
+      return Puppet::Util::Profiler.profile(_("Not inlining unsupported source scheme"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :unsupported_scheme]) { false }
+    else
+      return true
     end
   end
 

lib/puppet/module_tool/metadata.rb

@@ -172,14 +172,14 @@ def validate_name(name)
       modname = :namespace_missing if namespace == ''
 
       err = case modname
-      when nil, '', :namespace_missing
-        _("the field must be a namespaced module name")
-      when /[^a-z0-9_]/i
-        _("the module name contains non-alphanumeric (or underscore) characters")
-      when /^[^a-z]/i
-        _("the module name must begin with a letter")
-      else
-        _("the namespace contains non-alphanumeric characters")
+            when nil, '', :namespace_missing
+              _("the field must be a namespaced module name")
+            when /[^a-z0-9_]/i
+              _("the module name contains non-alphanumeric (or underscore) characters")
+            when /^[^a-z]/i
+              _("the module name must begin with a letter")
+            else
+              _("the namespace contains non-alphanumeric characters")
       end
 
       raise ArgumentError, _("Invalid 'name' field in metadata.json: %{err}") % { err: err }

lib/puppet/pops/evaluator/access_operator.rb

@@ -43,36 +43,36 @@ def access_Binary(o, scope, keys)
   def access_String(o, scope, keys)
     keys.flatten!
     result = case keys.size
-    when 0
-      fail(Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
-    when 1
-      # Note that Ruby 1.8.7 requires a length of 1 to produce a String
-      k1 = Utils.to_n(keys[0])
-      bad_string_access_key_type(o, 0, k1.nil? ? keys[0] : k1) unless k1.is_a?(Integer)
-      k2 = 1
-      k1 = k1 < 0 ? o.length + k1 : k1           # abs pos
-      # if k1 is outside, a length of 1 always produces an empty string
-      if k1 < 0
-        EMPTY_STRING
-      else
-        o[ k1, k2 ]
-      end
-    when 2
-      k1 = Utils.to_n(keys[0])
-      k2 = Utils.to_n(keys[1])
-      [k1, k2].each_with_index { |k,i| bad_string_access_key_type(o, i, k.nil? ? keys[i] : k) unless k.is_a?(Integer) }
-
-      k1 = k1 < 0 ? o.length + k1 : k1           # abs pos (negative is count from end)
-      k2 = k2 < 0 ? o.length - k1 + k2 + 1 : k2  # abs length (negative k2 is length from pos to end count)
-      # if k1 is outside, adjust to first position, and adjust length
-      if k1 < 0
-        k2 = k2 + k1
-        k1 = 0
-      end
-      o[ k1, k2 ]
-    else
-      fail(Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
-    end
+             when 0
+               fail(Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
+             when 1
+               # Note that Ruby 1.8.7 requires a length of 1 to produce a String
+               k1 = Utils.to_n(keys[0])
+               bad_string_access_key_type(o, 0, k1.nil? ? keys[0] : k1) unless k1.is_a?(Integer)
+               k2 = 1
+               k1 = k1 < 0 ? o.length + k1 : k1           # abs pos
+               # if k1 is outside, a length of 1 always produces an empty string
+               if k1 < 0
+                 EMPTY_STRING
+               else
+                 o[ k1, k2 ]
+               end
+             when 2
+               k1 = Utils.to_n(keys[0])
+               k2 = Utils.to_n(keys[1])
+               [k1, k2].each_with_index { |k,i| bad_string_access_key_type(o, i, k.nil? ? keys[i] : k) unless k.is_a?(Integer) }
+
+               k1 = k1 < 0 ? o.length + k1 : k1           # abs pos (negative is count from end)
+               k2 = k2 < 0 ? o.length - k1 + k2 + 1 : k2  # abs length (negative k2 is length from pos to end count)
+               # if k1 is outside, adjust to first position, and adjust length
+               if k1 < 0
+                 k2 = k2 + k1
+                 k1 = 0
+               end
+               o[ k1, k2 ]
+             else
+               fail(Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
+             end
     # Specified as: an index outside of range, or empty result == empty string
     (result.nil? || result.empty?) ? EMPTY_STRING : result
   end
@@ -592,15 +592,15 @@ def access_PResourceType(o, scope, keys)
     # type_name is LHS type_name if set, else the first given arg
     type_name = o.type_name || Types::TypeFormatter.singleton.capitalize_segments(keys.shift)
     type_name = case type_name
-    when Types::PResourceType
-      type_name.type_name
-    when String
-      type_name
-    else
-      # blame given left expression if it defined the type, else the first given key expression
-      blame = o.type_name.nil? ? @semantic.keys[0] : @semantic.left_expr
-      fail(Issues::ILLEGAL_RESOURCE_SPECIALIZATION, blame, {:actual => bad_key_type_name(type_name)})
-    end
+                when Types::PResourceType
+                  type_name.type_name
+                when String
+                  type_name
+                else
+                  # blame given left expression if it defined the type, else the first given key expression
+                  blame = o.type_name.nil? ? @semantic.keys[0] : @semantic.left_expr
+                  fail(Issues::ILLEGAL_RESOURCE_SPECIALIZATION, blame, {:actual => bad_key_type_name(type_name)})
+                end
 
     # type name must conform
     if type_name !~ Patterns::CLASSREF_EXT

lib/puppet/pops/evaluator/evaluator_impl.rb

@@ -1208,31 +1208,30 @@ def concatenate(x, y)
     case x
     when Array
       y = case y
-      when Array then y
-      when Hash  then y.to_a
-      else
-        [y]
-      end
+          when Array then y
+          when Hash  then y.to_a
+          else            [y]
+          end
       x + y # new array with concatenation
     when Hash
       y = case y
-      when Hash then y
-      when Array
-        # Hash[[a, 1, b, 2]] => {}
-        # Hash[a,1,b,2] => {a => 1, b => 2}
-        # Hash[[a,1], [b,2]] => {[a,1] => [b,2]}
-        # Hash[[[a,1], [b,2]]] => {a => 1, b => 2}
-        # Use type calculator to determine if array is Array[Array[?]], and if so use second form
-        # of call
-        t = @@type_calculator.infer(y)
-        if t.element_type.is_a? Types::PArrayType
-          Hash[y]
-        else
-          Hash[*y]
-        end
-      else
-        raise ArgumentError.new(_('Can only append Array or Hash to a Hash'))
-      end
+          when Hash then y
+          when Array
+            # Hash[[a, 1, b, 2]] => {}
+            # Hash[a,1,b,2] => {a => 1, b => 2}
+            # Hash[[a,1], [b,2]] => {[a,1] => [b,2]}
+            # Hash[[[a,1], [b,2]]] => {a => 1, b => 2}
+            # Use type calculator to determine if array is Array[Array[?]], and if so use second form
+            # of call
+            t = @@type_calculator.infer(y)
+            if t.element_type.is_a? Types::PArrayType
+              Hash[y]
+            else
+              Hash[*y]
+            end
+          else
+            raise ArgumentError.new(_('Can only append Array or Hash to a Hash'))
+          end
       x.merge y # new hash with overwrite
     when URI
       raise ArgumentError.new(_('An URI can only be merged with an URI or String')) unless y.is_a?(String) || y.is_a?(URI)
@@ -1256,16 +1255,16 @@ def delete(x, y)
     case x
     when Array
       y = case y
-      when Array then y
-      when Hash then y.to_a
+          when Array then y
+          when Hash then y.to_a
       else
         [y]
       end
       y.each {|e| result.delete(e) }
     when Hash
       y = case y
-      when Array then y
-      when Hash then y.keys
+          when Array then y
+          when Hash then y.keys
       else
         [y]
       end

lib/puppet/pops/evaluator/runtime3_converter.rb

@@ -133,23 +133,23 @@ def convert_PCatalogEntryType(o, scope, undef_value)
   def catalog_type_to_split_type_title(catalog_type)
     split_type = catalog_type.is_a?(Puppet::Pops::Types::PTypeType) ? catalog_type.type : catalog_type
     case split_type
-      when Puppet::Pops::Types::PClassType
-        class_name = split_type.class_name
-        ['class', class_name.nil? ? nil : class_name.sub(/^::/, '')]
-      when Puppet::Pops::Types::PResourceType
-        type_name = split_type.type_name
-        title = split_type.title
-        if type_name =~ /^(::)?[Cc]lass$/
-          ['class', title.nil? ? nil : title.sub(/^::/, '')]
-        else
-          # Ensure that title is '' if nil
-          # Resources with absolute name always results in error because tagging does not support leading ::
-          [type_name.nil? ? nil : type_name.sub(/^::/, '').downcase, title.nil? ? '' : title]
-        end
+    when Puppet::Pops::Types::PClassType
+      class_name = split_type.class_name
+      ['class', class_name.nil? ? nil : class_name.sub(/^::/, '')]
+    when Puppet::Pops::Types::PResourceType
+      type_name = split_type.type_name
+      title = split_type.title
+      if type_name =~ /^(::)?[Cc]lass$/
+        ['class', title.nil? ? nil : title.sub(/^::/, '')]
       else
-        #TRANSLATORS 'PClassType' and 'PResourceType' are Puppet types and should not be translated
-        raise ArgumentError, _("Cannot split the type %{class_name}, it represents neither a PClassType, nor a PResourceType.") %
-            { class_name: catalog_type.class }
+        # Ensure that title is '' if nil
+        # Resources with absolute name always results in error because tagging does not support leading ::
+        [type_name.nil? ? nil : type_name.sub(/^::/, '').downcase, title.nil? ? '' : title]
+      end
+    else
+      #TRANSLATORS 'PClassType' and 'PResourceType' are Puppet types and should not be translated
+      raise ArgumentError, _("Cannot split the type %{class_name}, it represents neither a PClassType, nor a PResourceType.") %
+          { class_name: catalog_type.class }
     end
   end
 

lib/puppet/pops/lookup/explainer.rb

@@ -469,32 +469,32 @@ def initialize(explain_options = false, only_explain_options = false)
 
     def push(qualifier_type, qualifier)
       node = case (qualifier_type)
-        when :global
-         ExplainGlobal.new(@current, qualifier)
-        when :location
-          ExplainLocation.new(@current, qualifier)
-        when :interpolate
-          ExplainInterpolate.new(@current, qualifier)
-        when :data_provider
-          ExplainDataProvider.new(@current, qualifier)
-        when :merge
-          ExplainMerge.new(@current, qualifier)
-        when :module
-          ExplainModule.new(@current, qualifier)
-        when :scope
-          ExplainScope.new(@current, qualifier)
-        when :sub_lookup
-          ExplainSubLookup.new(@current, qualifier)
-        when :segment
-          ExplainKeySegment.new(@current, qualifier)
-        when :meta, :data
-          ExplainTop.new(@current, qualifier_type, qualifier)
-        when :invalid_key
-          ExplainInvalidKey.new(@current, qualifier)
-        else
-          #TRANSLATORS 'Explain' is referring to the 'Explainer' class and should not be translated
-          raise ArgumentError, _("Unknown Explain type %{qualifier_type}") % { qualifier_type: qualifier_type }
-        end
+             when :global
+               ExplainGlobal.new(@current, qualifier)
+             when :location
+               ExplainLocation.new(@current, qualifier)
+             when :interpolate
+              ExplainInterpolate.new(@current, qualifier)
+             when :data_provider
+              ExplainDataProvider.new(@current, qualifier)
+             when :merge
+              ExplainMerge.new(@current, qualifier)
+             when :module
+               ExplainModule.new(@current, qualifier)
+             when :scope
+               ExplainScope.new(@current, qualifier)
+             when :sub_lookup
+               ExplainSubLookup.new(@current, qualifier)
+             when :segment
+              ExplainKeySegment.new(@current, qualifier)
+             when :meta, :data
+              ExplainTop.new(@current, qualifier_type, qualifier)
+             when :invalid_key
+               ExplainInvalidKey.new(@current, qualifier)
+             else
+               #TRANSLATORS 'Explain' is referring to the 'Explainer' class and should not be translated
+               raise ArgumentError, _("Unknown Explain type %{qualifier_type}") % { qualifier_type: qualifier_type }
+             end
       @current.branches << node
       @current = node
     end