rubocop-sketchup 0.5.0 → 0.6.0

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

@@ -1,39 +1,39 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupSuggestions
-      # Avoid `Sketchup.find_support_file` to find your extension's files.
-      #
-      # Users might install your extension to locations other than the default
-      # Plugins directory. If you use `Sketchup.find_support_file` to build
-      # a path for files in your extension it will fail in these scenarios.
-      #
-      # Instead prefer to use `__FILE__` or `__dir__` to build paths relative
-      # to your source files. This have the added benefit of allowing you to
-      # load your extensions directly from external directories under version
-      # control.
-      class SketchupFindSupportFile < SketchUp::Cop
-
-        MSG = 'Avoid `Sketchup.find_support_file` to find your '\
-              "extension's files.".freeze
-
-        # http://www.rubydoc.info/gems/rubocop/RuboCop/NodePattern
-        # https://rubocop.readthedocs.io/en/latest/node_pattern/
-        def_node_matcher :sketchup_find_support_file?, <<-PATTERN
-          (send
-            (const nil? :Sketchup) :find_support_file
-            ...
-          )
-        PATTERN
-
-        def on_send(node)
-          return unless sketchup_find_support_file?(node)
-
-          add_offense(node, location: :expression)
-        end
-
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupSuggestions
+      # Avoid `Sketchup.find_support_file` to find your extension's files.
+      #
+      # Users might install your extension to locations other than the default
+      # Plugins directory. If you use `Sketchup.find_support_file` to build
+      # a path for files in your extension it will fail in these scenarios.
+      #
+      # Instead prefer to use `__FILE__` or `__dir__` to build paths relative
+      # to your source files. This have the added benefit of allowing you to
+      # load your extensions directly from external directories under version
+      # control.
+      class SketchupFindSupportFile < SketchUp::Cop
+
+        MSG = 'Avoid `Sketchup.find_support_file` to find your '\
+              "extension's files.".freeze
+
+        # http://www.rubydoc.info/gems/rubocop/RuboCop/NodePattern
+        # https://rubocop.readthedocs.io/en/latest/node_pattern/
+        def_node_matcher :sketchup_find_support_file?, <<-PATTERN
+          (send
+            (const nil? :Sketchup) :find_support_file
+            ...
+          )
+        PATTERN
+
+        def on_send(node)
+          return unless sketchup_find_support_file?(node)
+
+          add_offense(node, location: :expression)
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,44 +1,44 @@
-# 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.'.freeze
-
-        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.'.freeze
+
+        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,66 +1,66 @@
-# 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`.'.freeze
-
-        MSG_MISSING_INVALIDATE = 'When drawing to the viewport, make sure to '\
-            'call `view.invalidate` when the tool becomes inactive.'.freeze
-
-        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`.'.freeze
+
+        MSG_MISSING_INVALIDATE = 'When drawing to the viewport, make sure to '\
+            'call `view.invalidate` when the tool becomes inactive.'.freeze
+
+        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?`.'.freeze
-
-        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?`.'.freeze
+
+        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.'.freeze
-
-        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 && 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.'.freeze
+
+        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 && 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