rubocop-sketchup 1.4.0 → 1.5.0

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

@@ -1,45 +1,45 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupSuggestions
-      # When drawing 3D geometry to the viewport from a tool, make sure to
-      # implement `getExtents` that return a `Geom::BoundingBox` object large
-      # enough to encompass what you draw.
-      #
-      # With out doing that the drawn content might end up being clipped.
-      #
-      # @example
-      #   # good
-      #   class ExampleTool
-      #
-      #     def getExtents
-      #       bounds = Geom::BoundingBox.new
-      #       bounds.add(@points)
-      #       bounds
-      #     end
-      #
-      #     def draw(view)
-      #       view.draw(GL_LINES, @points)
-      #     end
-      #
-      #   end
-      class ToolDrawingBounds < Cop
-
-        include SketchUp::ToolChecker
-
-        MSG_MISSING_GET_EXTENTS = 'When drawing to the viewport implement ' \
-                                  '`getExtents` so drawn geometry is not ' \
-                                  'clipped.'
-
-        def on_tool_class(class_node, body_methods)
-          return unless find_method(body_methods, :draw)
-          return if find_method(body_methods, :getExtents)
-
-          add_offense(class_node, message: MSG_MISSING_GET_EXTENTS)
-        end
-
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupSuggestions
+      # When drawing 3D geometry to the viewport from a tool, make sure to
+      # implement `getExtents` that return a `Geom::BoundingBox` object large
+      # enough to encompass what you draw.
+      #
+      # With out doing that the drawn content might end up being clipped.
+      #
+      # @example
+      #   # good
+      #   class ExampleTool
+      #
+      #     def getExtents
+      #       bounds = Geom::BoundingBox.new
+      #       bounds.add(@points)
+      #       bounds
+      #     end
+      #
+      #     def draw(view)
+      #       view.draw(GL_LINES, @points)
+      #     end
+      #
+      #   end
+      class ToolDrawingBounds < Cop
+
+        include SketchUp::ToolChecker
+
+        MSG_MISSING_GET_EXTENTS = 'When drawing to the viewport implement ' \
+                                  '`getExtents` so drawn geometry is not ' \
+                                  'clipped.'
+
+        def on_tool_class(class_node, body_methods)
+          return unless find_method(body_methods, :draw)
+          return if find_method(body_methods, :getExtents)
+
+          add_offense(class_node, message: MSG_MISSING_GET_EXTENTS)
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,68 +1,68 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupSuggestions
-      # After having drawn to the viewport from a tool, make sure to invalidate
-      # the view on `deactivate` and `suspend`.
-      #
-      # If you don't do that the things you drew might stick around for longer
-      # than the life-span of the tool and cause confusion for the user.
-      #
-      # @example
-      #   # good
-      #   class ExampleTool
-      #
-      #     def deactivate(view)
-      #       view_invalidate
-      #     end
-      #
-      #     def suspend(view)
-      #       view_invalidate
-      #     end
-      #
-      #     def draw(view)
-      #       view.draw(GL_LINES, @points)
-      #     end
-      #
-      #   end
-      class ToolInvalidate < Cop
-
-        include SketchUp::ToolChecker
-
-        MSG_MISSING_INVALIDATE_METHOD = 'When drawing to the viewport, make ' \
-                                        'sure to `suspend` and `deactivate` ' \
-                                        'calls `view.invalidate`.'
-
-        MSG_MISSING_INVALIDATE = 'When drawing to the viewport, make sure to ' \
-                                 'call `view.invalidate` when the tool ' \
-                                 'becomes inactive.'
-
-        def_node_search :view_invalidate?, <<-PATTERN
-          (send (lvar :view) :invalidate ...)
-        PATTERN
-
-        def on_tool_class(class_node, body_methods)
-          return unless find_method(body_methods, :draw)
-
-          check_method_invalidate(:deactivate, body_methods, class_node)
-          check_method_invalidate(:suspend, body_methods, class_node)
-        end
-
-        private
-
-        def check_method_invalidate(method_name, body_methods, class_node)
-          method_node = find_method(body_methods, method_name)
-          if method_node
-            return if view_invalidate?(method_node)
-
-            add_offense(method_node, message: MSG_MISSING_INVALIDATE)
-          else
-            add_offense(class_node, message: MSG_MISSING_INVALIDATE_METHOD)
-          end
-        end
-
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupSuggestions
+      # After having drawn to the viewport from a tool, make sure to invalidate
+      # the view on `deactivate` and `suspend`.
+      #
+      # If you don't do that the things you drew might stick around for longer
+      # than the life-span of the tool and cause confusion for the user.
+      #
+      # @example
+      #   # good
+      #   class ExampleTool
+      #
+      #     def deactivate(view)
+      #       view_invalidate
+      #     end
+      #
+      #     def suspend(view)
+      #       view_invalidate
+      #     end
+      #
+      #     def draw(view)
+      #       view.draw(GL_LINES, @points)
+      #     end
+      #
+      #   end
+      class ToolInvalidate < Cop
+
+        include SketchUp::ToolChecker
+
+        MSG_MISSING_INVALIDATE_METHOD = 'When drawing to the viewport, make ' \
+                                        'sure to `suspend` and `deactivate` ' \
+                                        'calls `view.invalidate`.'
+
+        MSG_MISSING_INVALIDATE = 'When drawing to the viewport, make sure to ' \
+                                 'call `view.invalidate` when the tool ' \
+                                 'becomes inactive.'
+
+        def_node_search :view_invalidate?, <<-PATTERN
+          (send (lvar :view) :invalidate ...)
+        PATTERN
+
+        def on_tool_class(class_node, body_methods)
+          return unless find_method(body_methods, :draw)
+
+          check_method_invalidate(:deactivate, body_methods, class_node)
+          check_method_invalidate(:suspend, body_methods, class_node)
+        end
+
+        private
+
+        def check_method_invalidate(method_name, body_methods, class_node)
+          method_node = find_method(body_methods, method_name)
+          if method_node
+            return if view_invalidate?(method_node)
+
+            add_offense(method_node, message: MSG_MISSING_INVALIDATE)
+          else
+            add_offense(class_node, message: MSG_MISSING_INVALIDATE_METHOD)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,41 +1,41 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupSuggestions
-      # When a tool takes user input via `onUserText`, make sure to define
-      # `enableVCB?` so that the VCB is enabled.
-      #
-      # @example
-      #   # good
-      #   class ExampleTool
-      #
-      #     def enableVCB?
-      #       true
-      #     end
-      #
-      #     def onUserText(text, view)
-      #       # ...
-      #     end
-      #
-      #   end
-      class ToolUserInput < Cop
-
-        include SketchUp::ToolChecker
-
-        MSG_MISSING_ENABLE_VCB = 'When accepting user input, make sure to ' \
-                                 'define `enableVCB?`.'
-
-        def on_tool_class(class_node, body_methods)
-          return unless find_method(body_methods, :onUserText)
-
-          method_node = find_method(body_methods, :enableVCB?)
-          return if method_node
-
-          add_offense(class_node, message: MSG_MISSING_ENABLE_VCB)
-        end
-
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupSuggestions
+      # When a tool takes user input via `onUserText`, make sure to define
+      # `enableVCB?` so that the VCB is enabled.
+      #
+      # @example
+      #   # good
+      #   class ExampleTool
+      #
+      #     def enableVCB?
+      #       true
+      #     end
+      #
+      #     def onUserText(text, view)
+      #       # ...
+      #     end
+      #
+      #   end
+      class ToolUserInput < Cop
+
+        include SketchUp::ToolChecker
+
+        MSG_MISSING_ENABLE_VCB = 'When accepting user input, make sure to ' \
+                                 'define `enableVCB?`.'
+
+        def on_tool_class(class_node, body_methods)
+          return unless find_method(body_methods, :onUserText)
+
+          method_node = find_method(body_methods, :enableVCB?)
+          return if method_node
+
+          add_offense(class_node, message: MSG_MISSING_ENABLE_VCB)
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,65 +1,65 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupSuggestions
-      # Wrapping `toolbar.restore` in `UI.start_timer` is redundant. It was a
-      # workaround for an issue in a very old version of SketchUp. There is no
-      # need to still be using this workaround.
-      #
-      # @example Creating a new toolbar
-      #   # bad
-      #   toolbar = UI::Toolbar.new('Example')
-      #   # ...
-      #   toolbar.restore
-      #   UI.start_timer(0.1, false) {
-      #     toolbar.restore
-      #   }
-      #
-      #   # good
-      #   toolbar = UI::Toolbar.new('Example')
-      #   # ...
-      #   toolbar.restore
-      class ToolbarTimer < Cop
-
-        include RangeHelp
-
-        MSG = 'Wrapping `toolbar.restore` in `UI.start_timer` is ' \
-              'redundant.'
-
-        def_node_matcher :toolbar_new?, <<-PATTERN
-          (send (const (const nil? :UI) :Toolbar) :new _)
-        PATTERN
-
-        def_node_search :ui_start_timer_restore, <<-PATTERN
-          (block
-            (send
-              (const nil? :UI) :start_timer
-              (float _)
-              (false))
-            (args)
-            (send
-              $_ :restore))
-        PATTERN
-
-        def on_send(node)
-          return unless toolbar_new?(node)
-          return unless node.parent.assignment?
-
-          assignment_node = node.parent
-          toolbar_variable_name = assignment_node.children.first
-
-          receiver = ui_start_timer_restore(assignment_node.parent).first
-          return unless receiver&.variable?
-
-          receiver_variable_name = receiver.children.first
-
-          return unless receiver_variable_name == toolbar_variable_name
-
-          add_offense(receiver.parent)
-        end
-
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupSuggestions
+      # Wrapping `toolbar.restore` in `UI.start_timer` is redundant. It was a
+      # workaround for an issue in a very old version of SketchUp. There is no
+      # need to still be using this workaround.
+      #
+      # @example Creating a new toolbar
+      #   # bad
+      #   toolbar = UI::Toolbar.new('Example')
+      #   # ...
+      #   toolbar.restore
+      #   UI.start_timer(0.1, false) {
+      #     toolbar.restore
+      #   }
+      #
+      #   # good
+      #   toolbar = UI::Toolbar.new('Example')
+      #   # ...
+      #   toolbar.restore
+      class ToolbarTimer < Cop
+
+        include RangeHelp
+
+        MSG = 'Wrapping `toolbar.restore` in `UI.start_timer` is ' \
+              'redundant.'
+
+        def_node_matcher :toolbar_new?, <<-PATTERN
+          (send (const (const nil? :UI) :Toolbar) :new _)
+        PATTERN
+
+        def_node_search :ui_start_timer_restore, <<-PATTERN
+          (block
+            (send
+              (const nil? :UI) :start_timer
+              (float _)
+              (false))
+            (args)
+            (send
+              $_ :restore))
+        PATTERN
+
+        def on_send(node)
+          return unless toolbar_new?(node)
+          return unless node.parent.assignment?
+
+          assignment_node = node.parent
+          toolbar_variable_name = assignment_node.children.first
+
+          receiver = ui_start_timer_restore(assignment_node.parent).first
+          return unless receiver&.variable?
+
+          receiver_variable_name = receiver.children.first
+
+          return unless receiver_variable_name == toolbar_variable_name
+
+          add_offense(receiver.parent)
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/cop.rb

@@ -1,110 +1,110 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module SketchUp
-
-    WorkaroundCop = RuboCop::Cop::Cop.dup
-
-    # Clone of the the normal RuboCop::Cop::Cop class so we can rewrite
-    # the inherited method without breaking functionality
-    class WorkaroundCop
-      # Remove the Cop.inherited method to be a noop. Our SketchUp::Cop
-      # class will invoke the inherited hook instead
-      class << self
-        undef inherited
-        def inherited(*) end # rubocop:disable Lint/MissingSuper
-      end
-
-      # Special case `Module#<` so that the rspec support rubocop exports
-      # is compatible with our subclass
-      def self.<(other)
-        other.equal?(RuboCop::Cop::Cop) || super
-      end
-    end
-    private_constant(:WorkaroundCop)
-
-    # @abstract parent class to SketchUp cops
-    #
-    # The criteria for whether rubocop-sketchup analyzes a certain ruby file
-    # is configured via `AllCops/SketchUp`. For example, if you want to
-    # customize your project to scan all files within a `test/` directory
-    # then you could add this to your configuration:
-    #
-    # @example configuring analyzed paths
-    #
-    #   AllCops:
-    #     SketchUp:
-    #       SketchupDeprecations:
-    #         Exclude:
-    #         - '_test.rb$'
-    #         - '(?:^|/)test/'
-    class Cop < WorkaroundCop
-
-      include SketchUp::Config
-
-      SKETCHUP_DEPARTMENT_SEVERITY = {
-        SketchupRequirements: :error,
-        SketchupDeprecations: :warning,
-        SketchupPerformance: :warning,
-        SketchupBugs: :warning,
-        SketchupSuggestions: :convention,
-      }.freeze
-
-      # Invoke the original inherited hook so our cops are recognized
-      def self.inherited(subclass) # rubocop:disable Lint/MissingSuper
-        RuboCop::Cop::Cop.inherited(subclass)
-      end
-
-      def relevant_file?(file)
-        relevant_rubocop_sketchup_file?(file) && super
-      end
-
-      private
-
-      def default_severity
-        sketchup_severity || super
-      end
-
-      def sketchup_severity
-        SKETCHUP_DEPARTMENT_SEVERITY[self.class.department]
-      end
-
-      def department_name
-        self.class.department.to_s
-      end
-
-      def relevant_rubocop_sketchup_file?(file)
-        !sketchup_excluded?(file)
-      end
-
-      def sketchup_excluded?(file)
-        matches_file?(file, sketchup_exclude_pattern) ||
-          matches_file?(file, sketchup_department_exclude_pattern)
-      end
-
-      def matches_file?(file, patterns)
-        path = nil
-        patterns.any? do |pattern|
-          # Try to match the absolute path, as Exclude properties are absolute.
-          next true if match_path?(pattern, file)
-
-          # Try with relative path.
-          path ||= config.path_relative_to_config(file)
-          match_path?(pattern, path)
-        end
-      end
-
-      def sketchup_department_exclude_pattern
-        sketchup_cops_config
-          .fetch(department_name, {})
-          .fetch('Exclude', [])
-      end
-
-      def sketchup_exclude_pattern
-        sketchup_cops_config
-          .fetch('Exclude', [])
-      end
-
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module SketchUp
+
+    WorkaroundCop = RuboCop::Cop::Cop.dup
+
+    # Clone of the the normal RuboCop::Cop::Cop class so we can rewrite
+    # the inherited method without breaking functionality
+    class WorkaroundCop
+      # Remove the Cop.inherited method to be a noop. Our SketchUp::Cop
+      # class will invoke the inherited hook instead
+      class << self
+        undef inherited
+        def inherited(*) end # rubocop:disable Lint/MissingSuper
+      end
+
+      # Special case `Module#<` so that the rspec support rubocop exports
+      # is compatible with our subclass
+      def self.<(other)
+        other.equal?(RuboCop::Cop::Cop) || super
+      end
+    end
+    private_constant(:WorkaroundCop)
+
+    # @abstract parent class to SketchUp cops
+    #
+    # The criteria for whether rubocop-sketchup analyzes a certain ruby file
+    # is configured via `AllCops/SketchUp`. For example, if you want to
+    # customize your project to scan all files within a `test/` directory
+    # then you could add this to your configuration:
+    #
+    # @example configuring analyzed paths
+    #
+    #   AllCops:
+    #     SketchUp:
+    #       SketchupDeprecations:
+    #         Exclude:
+    #         - '_test.rb$'
+    #         - '(?:^|/)test/'
+    class Cop < WorkaroundCop
+
+      include SketchUp::Config
+
+      SKETCHUP_DEPARTMENT_SEVERITY = {
+        SketchupRequirements: :error,
+        SketchupDeprecations: :warning,
+        SketchupPerformance: :warning,
+        SketchupBugs: :warning,
+        SketchupSuggestions: :convention,
+      }.freeze
+
+      # Invoke the original inherited hook so our cops are recognized
+      def self.inherited(subclass) # rubocop:disable Lint/MissingSuper
+        RuboCop::Cop::Cop.inherited(subclass)
+      end
+
+      def relevant_file?(file)
+        relevant_rubocop_sketchup_file?(file) && super
+      end
+
+      private
+
+      def default_severity
+        sketchup_severity || super
+      end
+
+      def sketchup_severity
+        SKETCHUP_DEPARTMENT_SEVERITY[self.class.department]
+      end
+
+      def department_name
+        self.class.department.to_s
+      end
+
+      def relevant_rubocop_sketchup_file?(file)
+        !sketchup_excluded?(file)
+      end
+
+      def sketchup_excluded?(file)
+        matches_file?(file, sketchup_exclude_pattern) ||
+          matches_file?(file, sketchup_department_exclude_pattern)
+      end
+
+      def matches_file?(file, patterns)
+        path = nil
+        patterns.any? do |pattern|
+          # Try to match the absolute path, as Exclude properties are absolute.
+          next true if match_path?(pattern, file)
+
+          # Try with relative path.
+          path ||= config.path_relative_to_config(file)
+          match_path?(pattern, path)
+        end
+      end
+
+      def sketchup_department_exclude_pattern
+        sketchup_cops_config
+          .fetch(department_name, {})
+          .fetch('Exclude', [])
+      end
+
+      def sketchup_exclude_pattern
+        sketchup_cops_config
+          .fetch('Exclude', [])
+      end
+
+    end
+  end
+end