rubocop-sketchup 1.2.0 → 1.4.0

data/lib/rubocop/sketchup/cop/suggestions/add_group.rb

@@ -1,49 +1,49 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupSuggestions
-      # The idiomatic way to create groups via the Ruby API differ from the
-      # way you'd do it from the UI.
-      #
-      # Using the API you should prefer to create the group first, then add
-      # your geometry into the group. This is more performant and predictable.
-      #
-      # Grouping existing geometry via the API have historically been affected
-      # by bugs and issues.
-      #
-      # If you do have to group existing geometry via the API, make sure you
-      # group geometry from the active context; `model.active_entities`.
-      # Otherwise you might run into unexpected issues, even crashes.
-      #
-      # @example Adding new geometry
-      #   # bad
-      #   face1 = model.active_entities.add_face(points1)
-      #   face2 = model.active_entities.add_face(points2)
-      #   group = model.active_entities.add_group([face1, face2])
-      #
-      #   # good
-      #   group = model.active_entities.add_group
-      #   face1 = group.entities.add_face(points1)
-      #   face2 = group.entities.add_face(points2)
-      class AddGroup < Cop
-
-        include RangeHelp
-
-        MSG = 'Avoid creating groups out of existing entities.'
-
-        def_node_matcher :add_group?, <<-PATTERN
-          (send _ :add_group ...)
-        PATTERN
-
-        def on_send(node)
-          return unless add_group?(node)
-          return if node.arguments.empty?
-
-          add_offense(node, location: arguments_range(node))
-        end
-
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupSuggestions
+      # The idiomatic way to create groups via the Ruby API differ from the
+      # way you'd do it from the UI.
+      #
+      # Using the API you should prefer to create the group first, then add
+      # your geometry into the group. This is more performant and predictable.
+      #
+      # Grouping existing geometry via the API have historically been affected
+      # by bugs and issues.
+      #
+      # If you do have to group existing geometry via the API, make sure you
+      # group geometry from the active context; `model.active_entities`.
+      # Otherwise you might run into unexpected issues, even crashes.
+      #
+      # @example Adding new geometry
+      #   # bad
+      #   face1 = model.active_entities.add_face(points1)
+      #   face2 = model.active_entities.add_face(points2)
+      #   group = model.active_entities.add_group([face1, face2])
+      #
+      #   # good
+      #   group = model.active_entities.add_group
+      #   face1 = group.entities.add_face(points1)
+      #   face2 = group.entities.add_face(points2)
+      class AddGroup < Cop
+
+        include RangeHelp
+
+        MSG = 'Avoid creating groups out of existing entities.'
+
+        def_node_matcher :add_group?, <<-PATTERN
+          (send _ :add_group ...)
+        PATTERN
+
+        def on_send(node)
+          return unless add_group?(node)
+          return if node.arguments.empty?
+
+          add_offense(node, location: arguments_range(node))
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/cop/suggestions/compatibility.rb

@@ -1,128 +1,128 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupSuggestions
-      # It's easy to lose track of what API feature was added in what version or
-      # SketchUp. You can configure your target SketchUp version and be notified
-      # if you use features introduced in newer versions.
-      #
-      # @example Add this to your .rubocop.yml
-      #   AllCops:
-      #     SketchUp:
-      #       TargetSketchUpVersion: 2016 M1
-      class Compatibility < SketchUp::Cop
-
-        include SketchUp::Features
-        include SketchUp
-
-        MSG = 'Incompatible feature with target SketchUp version'
-
-        def_node_matcher :module_definition?, <<~PATTERN
-          {class module (casgn _ _ class_constructor?)}
-        PATTERN
-
-        def on_def(node)
-          return unless observer_method?(node)
-
-          feature_name = "##{node.method_name}"
-          check_feature(node, :method, feature_name)
-        end
-
-        def on_send(node)
-          feature_name = ''
-          if module_method?(node)
-            feature_name = "#{node.receiver.const_name}.#{node.method_name}"
-          else
-            # Instance methods are harder. It's difficult to infer the type of
-            # the receiver. If we only check the method name in isolation we
-            # will get too many false positives with method names matching
-            # methods in Ruby itself and other older features.
-            # We try to match names that are unlikely to cause much noise.
-            return unless checkable_instance_method?(node)
-
-            feature_name = "##{node.method_name}"
-          end
-          check_feature(node, :method, feature_name)
-        end
-
-        def on_const(node)
-          if node.parent && module_definition?(node.parent)
-            # This catches definition of classes and modules.
-            namespace = Namespace.new(node.parent_module_name)
-            return unless namespace.top_level?
-          end
-
-          feature_name = node.const_name
-          [:class, :module, :constant].each { |type|
-            check_feature(node, type, feature_name)
-          }
-        end
-
-        private
-
-        def check_feature(node, type, feature_name)
-          return unless sketchup_target_version?
-
-          full_feature_name = feature_name
-          FEATURES.each { |feature_set|
-            version = feature_set[:version]
-            feature_version = SketchUp::SketchUpVersion.new(version)
-            next unless feature_version > sketchup_target_version
-
-            objects = feature_set[:types][type] || []
-            if type == :method && instance_method?(feature_name)
-              # Instance methods are simply matching the method name since it's
-              # very difficult to determine the type of the receiver.
-              full_feature_name = objects.find { |object|
-                object.end_with?(feature_name)
-              }
-              next unless full_feature_name
-            else
-              next unless objects.include?(feature_name)
-            end
-            report(node, full_feature_name, feature_version, type)
-          }
-        end
-
-        def report(node, feature_name, feature_version, feature_type)
-          message = "The #{feature_type} `#{feature_name}` was added in "\
-                    "#{feature_version} which is incompatible with target "\
-                    "#{sketchup_target_version}."
-          location = find_node_location(node)
-          add_offense(node, location: location, message: message)
-        end
-
-        def find_node_location(node)
-          # Highlight the most pertinent piece of the expression.
-          if node.const_type?
-            :expression
-          elsif node.send_type?
-            :selector
-          elsif node.def_type?
-            :name
-          else # rubocop:disable Lint/DuplicateBranch
-            :expression
-          end
-        end
-
-        def module_method?(node)
-          node.receiver&.const_type?
-        end
-
-        def instance_method?(feature_name)
-          feature_name.start_with?('#')
-        end
-
-        def checkable_instance_method?(node)
-          INSTANCE_METHODS.include?(node.method_name)
-        end
-
-        def observer_method?(node)
-          OBSERVER_METHODS.include?(node.method_name)
-        end
-
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupSuggestions
+      # It's easy to lose track of what API feature was added in what version or
+      # SketchUp. You can configure your target SketchUp version and be notified
+      # if you use features introduced in newer versions.
+      #
+      # @example Add this to your .rubocop.yml
+      #   AllCops:
+      #     SketchUp:
+      #       TargetSketchUpVersion: 2016 M1
+      class Compatibility < SketchUp::Cop
+
+        include SketchUp::Features
+        include SketchUp
+
+        MSG = 'Incompatible feature with target SketchUp version'
+
+        def_node_matcher :module_definition?, <<~PATTERN
+          {class module (casgn _ _ class_constructor?)}
+        PATTERN
+
+        def on_def(node)
+          return unless observer_method?(node)
+
+          feature_name = "##{node.method_name}"
+          check_feature(node, :method, feature_name)
+        end
+
+        def on_send(node)
+          feature_name = ''
+          if module_method?(node)
+            feature_name = "#{node.receiver.const_name}.#{node.method_name}"
+          else
+            # Instance methods are harder. It's difficult to infer the type of
+            # the receiver. If we only check the method name in isolation we
+            # will get too many false positives with method names matching
+            # methods in Ruby itself and other older features.
+            # We try to match names that are unlikely to cause much noise.
+            return unless checkable_instance_method?(node)
+
+            feature_name = "##{node.method_name}"
+          end
+          check_feature(node, :method, feature_name)
+        end
+
+        def on_const(node)
+          if node.parent && module_definition?(node.parent)
+            # This catches definition of classes and modules.
+            namespace = Namespace.new(node.parent_module_name)
+            return unless namespace.top_level?
+          end
+
+          feature_name = node.const_name
+          [:class, :module, :constant].each { |type|
+            check_feature(node, type, feature_name)
+          }
+        end
+
+        private
+
+        def check_feature(node, type, feature_name)
+          return unless sketchup_target_version?
+
+          full_feature_name = feature_name
+          FEATURES.each { |feature_set|
+            version = feature_set[:version]
+            feature_version = SketchUp::SketchUpVersion.new(version)
+            next unless feature_version > sketchup_target_version
+
+            objects = feature_set[:types][type] || []
+            if type == :method && instance_method?(feature_name)
+              # Instance methods are simply matching the method name since it's
+              # very difficult to determine the type of the receiver.
+              full_feature_name = objects.find { |object|
+                object.end_with?(feature_name)
+              }
+              next unless full_feature_name
+            else
+              next unless objects.include?(feature_name)
+            end
+            report(node, full_feature_name, feature_version, type)
+          }
+        end
+
+        def report(node, feature_name, feature_version, feature_type)
+          message = "The #{feature_type} `#{feature_name}` was added in " \
+                    "#{feature_version} which is incompatible with target " \
+                    "#{sketchup_target_version}."
+          location = find_node_location(node)
+          add_offense(node, location: location, message: message)
+        end
+
+        def find_node_location(node)
+          # Highlight the most pertinent piece of the expression.
+          if node.const_type?
+            :expression
+          elsif node.send_type?
+            :selector
+          elsif node.def_type?
+            :name
+          else # rubocop:disable Lint/DuplicateBranch
+            :expression
+          end
+        end
+
+        def module_method?(node)
+          node.receiver&.const_type?
+        end
+
+        def instance_method?(feature_name)
+          feature_name.start_with?('#')
+        end
+
+        def checkable_instance_method?(node)
+          INSTANCE_METHODS.include?(node.method_name)
+        end
+
+        def observer_method?(node)
+          OBSERVER_METHODS.include?(node.method_name)
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/cop/suggestions/dc_internals.rb

@@ -1,34 +1,34 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupSuggestions
-      # Tapping into the internals of Dynamic Components is risky. It could
-      # change at any time. If you create an extension that depend on the
-      # internal logic of another extension you are at the mercy of change and
-      # luck!
-      class DynamicComponentInternals < SketchUp::Cop
-
-        include SketchUp::DynamicComponentGlobals
-
-        MSG = 'Avoid relying on internal logic of Dynamic Components.'
-
-        def on_gvar(node)
-          check_global(node)
-        end
-
-        def on_gvasgn(node)
-          check_global(node)
-        end
-
-        def check_global(node)
-          global_var, = *node
-          return unless dc_global_var?(global_var)
-
-          add_offense(node, location: :name, severity: :warning)
-        end
-
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupSuggestions
+      # Tapping into the internals of Dynamic Components is risky. It could
+      # change at any time. If you create an extension that depend on the
+      # internal logic of another extension you are at the mercy of change and
+      # luck!
+      class DynamicComponentInternals < SketchUp::Cop
+
+        include SketchUp::DynamicComponentGlobals
+
+        MSG = 'Avoid relying on internal logic of Dynamic Components.'
+
+        def on_gvar(node)
+          check_global(node)
+        end
+
+        def on_gvasgn(node)
+          check_global(node)
+        end
+
+        def check_global(node)
+          global_var, = *node
+          return unless dc_global_var?(global_var)
+
+          add_offense(node, location: :name, severity: :warning)
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/cop/suggestions/file_encoding.rb

@@ -1,78 +1,78 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupSuggestions
-      # When using __FILE__ and __dir__, beware that Ruby doesn't apply the
-      # correct encoding to the strings under Windows. When they contain
-      # non-english characters it will lead to exceptions being raised when the
-      # strings are used. Force encoding to work around this.
-      #
-      # @example Might fail
-      #   basename = File.basename(__FILE__, '.*')
-      #
-      # @example Workaround
-      #   file = __FILE__.dup
-      #   file.force_encoding('UTF-8') if file.respond_to?(:force_encoding)
-      #   basename = File.basename(file, '.*')
-      class FileEncoding < SketchUp::Cop
-
-        MSG = 'Beware encoding bug with `__FILE__` and `__dir__`.'
-
-        def_node_matcher :file_loaded?, <<-PATTERN
-          (send nil? {:file_loaded? :file_loaded} ...)
-        PATTERN
-
-        def_node_matcher :magic_dir?, <<-PATTERN
-          (send nil? :__dir__)
-        PATTERN
-
-        def magic_file?(node)
-          node.respond_to?(:str_type?) &&
-            node.str_type? &&
-            node.source_range.is?('__FILE__')
-        end
-
-        def magic_file_or_dir?(node)
-          magic_file?(node) || magic_dir?(node)
-        end
-
-        def on_send(node)
-          return if file_loaded?(node)
-          return if node.arguments.none?(&method(:magic_file_or_dir?))
-
-          add_offense(node, location: :expression)
-        end
-
-
-        def_node_search :force_encoding, <<-PATTERN
-          (send ({lvar ivar cvar} $_) :force_encoding ...)
-        PATTERN
-
-        def on_assign(node)
-          lhs, value = *node
-          return unless magic_file_or_dir?(value)
-          # After assigning __FILE__ or __dir_ to a variable, check the parent
-          # scope to whether .force_encoding is called on the variable.
-          return if node.parent.nil?
-
-          encoded = force_encoding(node.parent).to_a
-          return if encoded.include?(lhs)
-
-          add_offense(node)
-        end
-
-        alias on_lvasgn   on_assign
-        alias on_masgn    on_assign
-        alias on_casgn    on_assign
-        alias on_ivasgn   on_assign
-        alias on_cvasgn   on_assign
-        alias on_gvasgn   on_assign
-        alias on_or_asgn  on_assign
-        alias on_and_asgn on_assign
-        alias on_op_asgn  on_assign
-
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupSuggestions
+      # When using __FILE__ and __dir__, beware that Ruby doesn't apply the
+      # correct encoding to the strings under Windows. When they contain
+      # non-english characters it will lead to exceptions being raised when the
+      # strings are used. Force encoding to work around this.
+      #
+      # @example Might fail
+      #   basename = File.basename(__FILE__, '.*')
+      #
+      # @example Workaround
+      #   file = __FILE__.dup
+      #   file.force_encoding('UTF-8') if file.respond_to?(:force_encoding)
+      #   basename = File.basename(file, '.*')
+      class FileEncoding < SketchUp::Cop
+
+        MSG = 'Beware encoding bug with `__FILE__` and `__dir__`.'
+
+        def_node_matcher :file_loaded?, <<-PATTERN
+          (send nil? {:file_loaded? :file_loaded} ...)
+        PATTERN
+
+        def_node_matcher :magic_dir?, <<-PATTERN
+          (send nil? :__dir__)
+        PATTERN
+
+        def magic_file?(node)
+          node.respond_to?(:str_type?) &&
+            node.str_type? &&
+            node.source_range.is?('__FILE__')
+        end
+
+        def magic_file_or_dir?(node)
+          magic_file?(node) || magic_dir?(node)
+        end
+
+        def on_send(node)
+          return if file_loaded?(node)
+          return if node.arguments.none?(&method(:magic_file_or_dir?))
+
+          add_offense(node, location: :expression)
+        end
+
+
+        def_node_search :force_encoding, <<-PATTERN
+          (send ({lvar ivar cvar} $_) :force_encoding ...)
+        PATTERN
+
+        def on_assign(node)
+          lhs, value = *node
+          return unless magic_file_or_dir?(value)
+          # After assigning __FILE__ or __dir_ to a variable, check the parent
+          # scope to whether .force_encoding is called on the variable.
+          return if node.parent.nil?
+
+          encoded = force_encoding(node.parent).to_a
+          return if encoded.include?(lhs)
+
+          add_offense(node)
+        end
+
+        alias on_lvasgn   on_assign
+        alias on_masgn    on_assign
+        alias on_casgn    on_assign
+        alias on_ivasgn   on_assign
+        alias on_cvasgn   on_assign
+        alias on_gvasgn   on_assign
+        alias on_or_asgn  on_assign
+        alias on_and_asgn on_assign
+        alias on_op_asgn  on_assign
+
+      end
+    end
+  end
+end