rubocop-sketchup 0.4.1 → 0.5.0

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

@@ -0,0 +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

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

@@ -0,0 +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

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

@@ -0,0 +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

data/lib/rubocop/sketchup/cop.rb

@@ -53,37 +53,57 @@ module RuboCop
 
       private
 
+      def default_severity
+        sketchup_severity || super
+      end
+
+      def sketchup_severity
+        case self.class.department
+        when :SketchupRequirements
+          :error
+        when :SketchupDeprecations
+          :warning
+        when :SketchupPerformance
+          :warning
+        when :SketchupSuggestions
+          :convention
+        end
+      end
+
       def department_name
         self.class.department.to_s
       end
 
       def relevant_rubocop_sketchup_file?(file)
-        !(department_exclude_pattern =~ file)
+        !sketchup_excluded?(file)
       end
 
-      def department_exclude_pattern
-        if department_exclude_config?
-          patterns = department_exclude_config.map(&Regexp.public_method(:new))
-          Regexp.union(patterns)
-        else
-          DEFAULT_CONFIGURATION
-            .fetch(department_name)
-            .fetch('Exclude')
-            .map(&Regexp.public_method(:new))
+      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 department_exclude_config?
-        return false unless all_cops_config.key?('SketchUp')
-        sketchup_config = all_cops_config.fetch('SketchUp')
-        return false unless sketchup_config.key?(department_name)
-        sketchup_config.fetch(department_name).key?('Exclude')
+      def sketchup_department_exclude_pattern
+        sketchup_cops_config
+          .fetch(department_name, {})
+          .fetch('Exclude', [])
       end
 
-      def department_exclude_config
+      def sketchup_exclude_pattern
         sketchup_cops_config
-          .fetch(department_name)
-          .fetch('Exclude')
+          .fetch('Exclude', [])
       end
 
     end

data/lib/rubocop/sketchup/dc_globals.rb

@@ -11,7 +11,7 @@ module RuboCop
         $dc_REPORTER_NAME
         $dc_MANAGER_NAME
         $dc_observers
-      ]
+      ].freeze
 
       private
 

data/lib/rubocop/sketchup/dc_methods.rb

@@ -7,123 +7,123 @@ module RuboCop
       DC_METHODS = [
         {
           name: :rotx,
-          path: 'Geom::Transformation'
+          path: 'Geom::Transformation',
         },
         {
           name: :roty,
-          path: 'Geom::Transformation'
+          path: 'Geom::Transformation',
         },
         {
           name: :rotz,
-          path: 'Geom::Transformation'
+          path: 'Geom::Transformation',
         },
         {
           name: :xscale,
-          path: 'Geom::Transformation'
+          path: 'Geom::Transformation',
         },
         {
           name: :yscale,
-          path: 'Geom::Transformation'
+          path: 'Geom::Transformation',
         },
         {
           name: :zscale,
-          path: 'Geom::Transformation'
+          path: 'Geom::Transformation',
         },
 
         {
           name: :copy,
           path: 'Sketchup::Camera',
-          variables: [:camera, :cam]
+          variables: [:camera, :cam],
         },
         {
           name: :update,
           path: 'Sketchup::Camera',
-          variables: [:camera, :cam]
+          variables: [:camera, :cam],
         },
         {
           name: :same_camera_params?,
-          path: 'Sketchup::Camera'
+          path: 'Sketchup::Camera',
         },
 
         {
           name: :copy,
           path: 'Sketchup::ComponentInstance',
-          variables: [:instance, :inst]
+          variables: [:instance, :inst],
         },
         {
           name: :description,
           path: 'Sketchup::ComponentInstance',
-          variables: [:instance, :inst]
+          variables: [:instance, :inst],
         },
 
         {
           name: :local_transformation,
-          path: 'Sketchup::Drawingelement'
+          path: 'Sketchup::Drawingelement',
         },
         {
           name: :scaled_size,
-          path: 'Sketchup::Drawingelement'
+          path: 'Sketchup::Drawingelement',
         },
         {
           name: :unscaled_size,
-          path: 'Sketchup::Drawingelement'
+          path: 'Sketchup::Drawingelement',
         },
         {
           name: :set_last_size,
-          path: 'Sketchup::Drawingelement'
+          path: 'Sketchup::Drawingelement',
         },
         {
           name: :last_scaling_factors,
-          path: 'Sketchup::Drawingelement'
+          path: 'Sketchup::Drawingelement',
         },
 
         {
           name: :get_attributes,
-          path: 'Sketchup::Entity'
+          path: 'Sketchup::Entity',
         },
         {
           name: :has_attributes?,
-          path: 'Sketchup::Entity'
+          path: 'Sketchup::Entity',
         },
 
         {
           name: :typename,
           path: 'Sketchup::Model',
-          variables: [:model, :mod]
+          variables: [:model, :mod],
         },
         {
           name: :entityID,
           path: 'Sketchup::Model',
-          variables: [:model, :mod]
+          variables: [:model, :mod],
         },
         {
           name: :delete_attribute,
           path: 'Sketchup::Model',
-          variables: [:model, :mod]
+          variables: [:model, :mod],
         },
         {
           name: :layer,
           path: 'Sketchup::Model',
-          variables: [:model, :mod]
+          variables: [:model, :mod],
         },
 
         {
           name: :last_width=,
-          path: 'UI::WebDialog'
+          path: 'UI::WebDialog',
         },
         {
           name: :last_height=,
-          path: 'UI::WebDialog'
+          path: 'UI::WebDialog',
         },
         {
           name: :last_width,
-          path: 'UI::WebDialog'
+          path: 'UI::WebDialog',
         },
         {
           name: :last_height,
-          path: 'UI::WebDialog'
+          path: 'UI::WebDialog',
         },
-      ]
+      ].freeze
 
     end
   end

data/lib/rubocop/sketchup/extension_project.rb

@@ -20,7 +20,7 @@ module RuboCop
 
       # @return [Pathname]
       def relative_source_path
-        Pathname.new(sketchup_source_path_config)
+        Pathname.new(extension_source_path_config)
       end
 
       # @return [Pathname]
@@ -39,10 +39,27 @@ module RuboCop
       # @param [RuboCop::ProcessedSource] processed_source
       def root_file?(processed_source)
         filename = path_relative_to_source(processed_source)
-        filename.extname.downcase == '.rb' &&
+        filename.extname.casecmp('.rb').zero? &&
           filename.parent.to_s == '.'
       end
 
+      def extension_root_files
+        Dir.glob("#{source_path}/*.rb").map { |path| Pathname.new(path) }
+      end
+
+      def extension_root_file
+        unless extension_root_files.size == 1
+          num_files = extension_root_files.size
+          raise "More than one root extension file (#{num_files})"
+        end
+
+        extension_root_files.first
+      end
+
+      def extension_directory
+        extension_root_file.dirname
+      end
+
     end
   end
 end

data/lib/rubocop/sketchup/formatter/extension_review.rb

@@ -12,7 +12,7 @@ module RuboCop
     class ExtensionReviewFormatter < BaseFormatter
       ELLIPSES = '<span class="extra-code">...</span>'.freeze
       TEMPLATE_PATH =
-        File.expand_path('../../../../../assets/output.html.erb', __FILE__)
+          File.expand_path('../../../../assets/output.html.erb', __dir__)
 
       Color = Struct.new(:red, :green, :blue, :alpha) do
         def to_s
@@ -42,11 +42,14 @@ module RuboCop
       def file_finished(file, offenses)
         files << file
         offenses.each { |offense|
+          # Report only SketchUp related cops.
+          next unless offense.cop_name.start_with?('Sketchup')
+
           report = OpenStruct.new(path: file, offense: offense)
           categories[offense.cop_name] ||= []
           categories[offense.cop_name] << report
+          summary.offense_count += 1
         }
-        summary.offense_count += offenses.count
       end
 
       def finished(inspected_files)
@@ -71,22 +74,22 @@ module RuboCop
         include TextUtil
 
         SEVERITY_COLORS = {
-          refactor:   Color.new(0xED, 0x9C, 0x28, 1.0),
-          convention: Color.new(0xED, 0x9C, 0x28, 1.0),
-          warning:    Color.new(0x96, 0x28, 0xEF, 1.0),
+          refactor:   Color.new(0x29, 0x6B, 0xF0, 1.0),
+          convention: Color.new(0x29, 0x6B, 0xF0, 1.0),
+          warning:    Color.new(0xED, 0x9C, 0x28, 1.0),
           error:      Color.new(0xD2, 0x32, 0x2D, 1.0),
-          fatal:      Color.new(0xD2, 0x32, 0x2D, 1.0)
+          fatal:      Color.new(0xD2, 0x32, 0x2D, 1.0),
         }.freeze
 
         LOGO_IMAGE_PATH =
-          File.expand_path('../../../../../assets/logo.png', __FILE__)
+            File.expand_path('../../../../assets/logo.png', __dir__)
 
         SORT_ORDER = %w[
           SketchupRequirements
           SketchupDeprecations
           SketchupPerformance
           SketchupSuggestions
-        ]
+        ].freeze
 
         DEPARTMENT_DESCRIPTIONS = {
           'SketchupRequirements' => <<-DESCRIPTION,
@@ -125,7 +128,7 @@ module RuboCop
             This department is not a requirement for submission to
             Extension Warehouse.
           DESCRIPTION
-        }
+        }.freeze
 
         attr_reader :categories, :files, :summary
 
@@ -150,6 +153,7 @@ module RuboCop
           count = 0
           categories.each { |category, offenses|
             next unless department(category) == dep
+
             count += offenses.size
           }
           count
@@ -176,7 +180,18 @@ module RuboCop
             # Then sort by cop name.
             a_department, a_name = a[0].split('/')
             b_department, b_name = b[0].split('/')
-            n = SORT_ORDER.index(a_department) <=> SORT_ORDER.index(b_department)
+            # Sort SketchUp cops at the top, then all the rest comes after.
+            # First sorting by department.
+            sort_order_a = SORT_ORDER.index(a_department)
+            sort_order_b = SORT_ORDER.index(b_department)
+            if sort_order_a.nil? && sort_order_b.nil?
+              n = a_department <=> b_department
+            else
+              sort_order_a ||= SORT_ORDER.size
+              sort_order_b ||= SORT_ORDER.size
+              n = sort_order_a <=> sort_order_b
+            end
+            # Them sort by name if departments match.
             n == 0 ? a_name <=> b_name : n
           }.to_h
         end
@@ -187,9 +202,14 @@ module RuboCop
         end
 
         def decorated_message(offense)
-          offense.message.gsub(/`(.+?)`/) do
-            "<code>#{Regexp.last_match(1)}</code>"
-          end
+          offense.message
+                 .gsub(/`(.+?)`/) do
+                   "<code>#{Regexp.last_match(1)}</code>"
+                 end
+                 .gsub(/\((http[^ ]+)\)/) do
+                   url = Regexp.last_match(1)
+                   "<br><a href=\"#{url}\">#{url}</a>"
+                 end
         end
 
         def highlighted_source_line(offense)
@@ -225,8 +245,8 @@ module RuboCop
           "offense_#{title}"
         end
 
-        def escape(s)
-          CGI.escapeHTML(s)
+        def escape(string)
+          CGI.escapeHTML(string)
         end
 
         def base64_encoded_logo_image

data/lib/rubocop/sketchup/inject.rb

@@ -16,4 +16,4 @@ module RuboCop
       end
     end
   end
-end
+end

data/lib/rubocop/sketchup/namespace.rb

@@ -11,6 +11,7 @@ module RuboCop
       # @param [String] namespace
       def initialize(namespace)
         raise TypeError unless namespace.is_a?(String)
+
         @namespace = namespace
       end
 

data/lib/rubocop/sketchup/namespace_checker.rb

@@ -23,13 +23,16 @@ module RuboCop
       end
 
       def check_namespace(node)
-        add_offense(node, location:  :name, severity: :error) if in_namespace?(node)
+        return unless in_namespace?(node)
+
+        add_offense(node, location: :name, severity: :error)
       end
 
       def in_namespace?(node)
         # parent_module_name might return nil if for instance a method is
         # defined within a block. (Apparently that is possible...)
         return false if node.parent_module_name.nil?
+
         namespace = SketchUp::Namespace.new(node.parent_module_name)
         namespaces.include?(namespace.first)
       end

data/lib/rubocop/sketchup/no_comment_disable.rb

@@ -8,7 +8,7 @@ module RuboCop
 
       # This forces the cop to be run even if there is a source code comment
       # that tries to disable it.
-      def enabled_line?(line_number)
+      def enabled_line?(_line_number)
         true
       end
 

data/lib/rubocop/sketchup/range_help.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Methods that calculate and return Parser::Source::Ranges
+    module RangeHelp
+
+      private
+
+      def range_with_receiver(node)
+        receiver = node.receiver
+        loc_begin = if receiver.send_type?
+                      receiver.loc.selector.begin_pos
+                    else
+                      receiver.loc.expression.begin_pos
+                    end
+        loc_end = node.loc.selector.end_pos
+        range_between(loc_begin, loc_end)
+      end
+
+      def string_contents_range(node)
+        begin_pos = node.loc.begin.end_pos
+        end_pos = node.loc.end.begin_pos
+        range_between(begin_pos, end_pos)
+      end
+
+      def arguments_range(node)
+        begin_pos = node.arguments.first.loc.expression.begin_pos
+        end_pos = node.arguments.last.loc.expression.end_pos
+        range_between(begin_pos, end_pos)
+      end
+
+      def conditional_range(node)
+        if node.modifier_form?
+          range_between(node.loc.keyword.begin_pos,
+              node.loc.expression.end_pos)
+        else
+          :expression
+        end
+      end
+
+      def file_ext_range(argument_node)
+        filename = argument_node.str_content
+        ext_size = File.extname(filename).size
+        end_pos = argument_node.loc.end.begin_pos
+        begin_pos = end_pos - ext_size
+        range_between(begin_pos, end_pos)
+      end
+
+    end
+  end
+end

data/lib/rubocop/sketchup/sketchup_version.rb

@@ -57,7 +57,7 @@ module RuboCop
         [7.0, 1],
         [7.0, 0],
         [6.0, 0],
-      ]
+      ].freeze
 
       def parse_version(version)
         v = 0
@@ -71,12 +71,14 @@ module RuboCop
             m = (result.captures[1] || '0').to_i
           end
         elsif version.is_a?(Numeric)
-          v, m = [version, 0]
+          v = version
+          m = 0
         end
         version_parts = [v, m]
         unless VALID_VERSIONS.include?(version_parts)
           raise InvalidVersion, "#{version} is not a valid SketchUp version"
         end
+
         version_parts
       end