rubocop-sketchup 0.4.1 → 0.5.0

data/lib/rubocop/sketchup/cop/performance/selection_bulk.rb

@@ -3,8 +3,9 @@
 module RuboCop
   module Cop
     module SketchupPerformance
-      # Avoid modifying the selection set within loops. It's much faster to
-      # change the selection in bulk.
+      # Prefer changing selection in bulk instead of modifying selection within
+      # loops. It's much faster to change the selection in bulk. UI updates are
+      # triggered when you update the selection, so reduce the amount of calls.
       #
       # @example Poor performance
       #   model = Sketchup.active_model
@@ -24,7 +25,11 @@ module RuboCop
       #   faces = model.active_entities.grep(Sketchup::Face)
       #   model.selection.add(faces)
       class SelectionBulkChanges < SketchUp::Cop
-        MSG = 'Avoid modifying selecting within loops.'.freeze
+
+        include RangeHelp
+
+        MSG = 'Prefer changing selection in bulk instead of modifying '\
+              'selection within loops.'.freeze
 
         # http://www.rubydoc.info/gems/rubocop/RuboCop/NodePattern
         # https://rubocop.readthedocs.io/en/latest/node_pattern/
@@ -64,8 +69,10 @@ module RuboCop
         def on_send(node)
           return unless selection?(node)
           return unless node.ancestors.any?(&method(:iterator?))
-          add_offense(node, location: :expression)
+
+          add_offense(node, location: range_with_receiver(node))
         end
+
       end
     end
   end

data/lib/rubocop/sketchup/cop/performance/type_check.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupPerformance
+      # String comparisons for type checks are very slow.
+      #
+      # `entity.class.name == 'Sketchup::Face'` is slow because it performs a
+      # string comparison. `is_a?` is much faster because it's a simple type
+      # check.
+      #
+      # If you know you need a strict type check, compare the classes directly:
+      # `entity.class == Sketchup::Face`.
+      #
+      # @example Poor performance
+      #   entity.class.name == 'Sketchup::Face'
+      #
+      # @example Good performance
+      #   entity.class == Sketchup::Face
+      #
+      # @example Good performance and idiomatic Ruby convention
+      #   entity.is_a?(Sketchup::Face)
+      class TypeCheck < SketchUp::Cop
+
+        # TODO(thomthom): It probably makes sense to eventually merge the
+        #   Typename cop into this cop. But until this cop have been
+        #   battle tested they remain separate. .typename is no prevalent in
+        #   use (wrongly) that it's better to err in the name of caution, making
+        #   sure we don't miss any scenarios.
+
+        include RangeHelp
+
+        MSG = 'String comparisons are very slow, prefer `.is_a?` '\
+              'instead.'.freeze
+
+        def_node_matcher :string_class_compare?, <<-PATTERN
+          (send
+            (send
+              (send
+                _ :class) :name) {:== :=== :!=}
+            (str _))
+        PATTERN
+
+        def on_send(node)
+          return unless string_class_compare?(node)
+
+          add_offense(node, location: comparison_range(node))
+        end
+
+        private
+
+        def comparison_range(node)
+          lhs = node.receiver
+          rhs = node.arguments.first
+
+          loc_begin = lhs.receiver.loc.selector.begin_pos
+          loc_end = rhs.loc.expression.end_pos
+          range_between(loc_begin, loc_end)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/cop/performance/typename.rb

@@ -3,15 +3,20 @@
 module RuboCop
   module Cop
     module SketchupPerformance
+      # `.typename` is very slow, prefer `.is_a?` instead.
+      #
+      # `entity.typename == 'Face'` is slow because it performs a string
+      # comparison. `is_a?` is much faster because it's a simple type check.
       class Typename < SketchUp::Cop
         MSG = '`.typename` is very slow, prefer `.is_a?` instead.'.freeze
 
         def on_send(node)
           _, method_name = *node
           return unless method_name == :typename
+
           # TODO(thomthom): Should we try to detect use of #typename
           # in context of comparing against a string?
-          add_offense(node, location: :expression)
+          add_offense(node, location: :selector)
         end
       end
     end

data/lib/rubocop/sketchup/cop/requirements/api_namespace.rb

@@ -3,6 +3,12 @@
 module RuboCop
   module Cop
     module SketchupRequirements
+      # Do not modify the Sketch API. This will affect other extensions and
+      # very likely cause them to fail.
+      #
+      # This requirement also include adding things into the SketchUp API
+      # namespace. The API namespace is reserved for future additions to the
+      # API.
       class ApiNamespace < SketchUp::Cop
 
         include SketchUp::NoCommentDisable
@@ -10,9 +16,9 @@ module RuboCop
 
         MSG = 'Do not modify the SketchUp API.'.freeze
 
-        NAMESPACES = %w(
+        NAMESPACES = %w[
           Geom Layout Sketchup SketchupExtension UI
-        ).freeze
+        ].freeze
 
         def namespaces
           NAMESPACES

data/lib/rubocop/sketchup/cop/requirements/exit.rb

@@ -7,12 +7,14 @@ module RuboCop
       # SketchUp will trap `exit` and prevent that, with a message in the
       # console. But `exit!` is not trapped and with terminate SketchUp without
       # shutting down cleanly.
-      # Use `return`, `next` or `break` instead.
+      #
+      # Use `return`, `next`, `break` or `raise` instead.
       class Exit < SketchUp::Cop
 
         include SketchUp::NoCommentDisable
 
-        MSG = 'Exit attempts to kill the Ruby interpreter. Use return, next or break instead.'.freeze
+        MSG = '`exit` attempts to kill the Ruby interpreter. Use `return`, '\
+              '`next`, `break` or `raise` instead.'.freeze
 
         # Reference: http://rubocop.readthedocs.io/en/latest/development/
         def_node_matcher :exit?, <<-PATTERN
@@ -20,7 +22,9 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          add_offense(node, location: :expression, severity: :error) if exit?(node)
+          return unless exit?(node)
+
+          add_offense(node, location: :selector)
         end
       end
     end

data/lib/rubocop/sketchup/cop/requirements/extension_namespace.rb

@@ -7,6 +7,30 @@ require 'rubocop/sketchup/cop/requirements/ruby_stdlib_namespace'
 module RuboCop
   module Cop
     module SketchupRequirements
+      # Extensions in SketchUp all share the same Ruby environment on the user's
+      # machine. Because of this it's important that each extension isolate
+      # itself to avoid clashing with other extensions.
+      #
+      # Extensions submitted to Extension Warehouse is expected to use only one
+      # root module.
+      #
+      # @example Good - this contains everything in the extension.
+      #   module MyExtension
+      #     class Foo
+      #     end
+      #     class Bar
+      #     end
+      #   end
+      #
+      # @example Better - this further reduce chance of clashing.
+      #   module MyCompany
+      #     module MyExtension
+      #       class Foo
+      #       end
+      #       class Bar
+      #       end
+      #     end
+      #   end
       class ExtensionNamespace < SketchUp::Cop
 
         include SketchUp::NoCommentDisable
@@ -28,6 +52,7 @@ module RuboCop
           return unless parent.top_level?
           # Don't check excluded namespaces.
           return if exempted?(namespace)
+
           check_namespace(node, namespace)
         end
 
@@ -40,12 +65,14 @@ module RuboCop
           # Make sure the namespace isn't part of reserved namespaces that other
           # cops are checking.
           return if reserved?(namespace)
+
           # Remember the first namespace encountered and log an offence if
           # more top level namespaces are registered.
           top = namespace.first
           @@namespace ||= top
           return if @@namespace == top
-          add_offense(node, location: :name, severity: :error)
+
+          add_offense(node, location: :name)
         end
 
         def reserved?(namespace)
@@ -53,12 +80,15 @@ module RuboCop
           return true if RubyCoreNamespace::NAMESPACES.include?(top)
           return true if RubyStdLibNamespace::NAMESPACES.include?(top)
           return true if ApiNamespace::NAMESPACES.include?(top)
+
           false
         end
 
         def message(node)
           namespace = Namespace.new(node.defined_module_name).from_root
-          format('Use a single root namespace. (Found `%s`; Previously found `%s`)', namespace, @@namespace)
+          format('Use a single root namespace. '\
+                 '(Found `%<found>s`; Previously found `%<expected>s`)',
+              found: namespace, expected: @@namespace)
         end
 
         def exempted?(namespace)

data/lib/rubocop/sketchup/cop/requirements/file_structure.rb

@@ -5,6 +5,16 @@ module RuboCop
     module SketchupRequirements
       # Check that the extension conform to expected file structure with a
       # single root .rb file and a support folder with matching name.
+      #
+      # Make sure to match upper and lower case characters between the root .rb
+      # file and the support folder.
+      #
+      # @example
+      #   SketchUp/Plugins
+      #   + ex_hello_world.rb
+      #   + ex_hello_world
+      #     + main.rb
+      #     + ...
       class FileStructure < SketchUp::Cop
 
         include SketchUp::NoCommentDisable
@@ -27,41 +37,40 @@ module RuboCop
 
           # Ensure there is only one root Ruby file.
           if root_ruby_files.size != 1
-            msg = "Extensions must have exactly one root Ruby (.rb) file. Found: %d"
+            msg = 'Extensions must have exactly one root Ruby (.rb) file. '\
+                  'Found: %d'
             add_offense(nil,
                 location: range,
-                message: format(msg, root_ruby_files.size),
-                severity: :error)
+                message: format(msg, root_ruby_files.size))
             return
           end
 
           # Find the root file and collect the sub-directories.
           root_file = root_ruby_files.first
           extension_basename = File.basename(root_file, '.*')
-          sub_folders = source_path.children.select { |c| c.directory? }
+          sub_folders = source_path.children.select(&:directory?)
           sub_folders.reject! { |folder|
             IGNORED_DIRECTORIES.include?(folder.basename.to_s)
           }
 
           # Ensure there is only one sub-directory.
           if sub_folders.size != 1
-            msg = "Extensions must have exactly one support directory. Found %d"
+            msg = 'Extensions must have exactly one support directory. Found %d'
             add_offense(nil,
                 location: range,
-                message: format(msg, sub_folders.size),
-                severity: :error)
+                message: format(msg, sub_folders.size))
             return
           end
 
           # Ensure support directory's name match the root Ruby file.
           support_directory = sub_folders.first
           unless support_directory.basename.to_s == extension_basename
-            msg = 'Extensions must have a support directory matching the name of the root Ruby file. Expected %s, found %s'
+            msg = 'Extensions must have a support directory matching the name '\
+                  'of the root Ruby file. Expected %s, found %s'
             msg = format(msg, extension_basename, support_directory.basename)
             add_offense(nil,
                 location: range,
-                message: msg,
-                severity: :error)
+                message: msg)
           end
         end
 
@@ -71,13 +80,16 @@ module RuboCop
 
         def already_run?
           return true if @@already_run
+
           @@already_run = true
           false
         end
 
+        # rubocop:disable Lint/IneffectiveAccessModifier
         def self.reset
           @@already_run = false
         end
+        # rubocop:enable Lint/IneffectiveAccessModifier
 
       end
     end

data/lib/rubocop/sketchup/cop/requirements/gem_install.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupRequirements
+      # It's tempting to use gems in an extension. However, there are issues if
+      # consuming them via Gem.install;
+      #
+      # * Net::HTTP is unreliable. (SSL certificate issues, OpenSSL performance
+      #   freeze under Windows)
+      # * Compiled extensions cannot be installed like this as they require
+      #   DevKit.
+      # * While downloading and installing SketchUp freezes. (Bad thing if done
+      #   automatically upon loading the extensions - especially without user
+      #   notice. It's easy to think SU have stopped working)
+      # * Version collisions. If multiple extensions want to use different
+      #   versions of a gem they will clash if the versions aren't compatible
+      #   with the features they use.
+      #
+      # They only way to ensure extensions doesn't clash is to namespace
+      # everything into extension namespace. This means making a copy of the
+      # gem you want to use and wrap it in your own namespace.
+      class GemInstall < SketchUp::Cop
+
+        include RangeHelp
+        include SketchUp::NoCommentDisable
+
+        MSG = '`Gem.install` is unreliable in SketchUp, and can cause '\
+              'extensions to clash.'.freeze
+
+        # Reference: http://rubocop.readthedocs.io/en/latest/development/
+        def_node_matcher :gem_install?, <<-PATTERN
+          (send (const nil? :Gem) :install ...)
+        PATTERN
+
+        def on_send(node)
+          return unless gem_install?(node)
+
+          range = range_with_receiver(node)
+          add_offense(node, location: range)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/cop/requirements/get_extension_license.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupRequirements
+      # Don't attempt to kill the Ruby interpreter by calling `exit` or `exit!`.
+      # SketchUp will trap `exit` and prevent that, with a message in the
+      # console. But `exit!` is not trapped and with terminate SketchUp without
+      # shutting down cleanly.
+      #
+      # Use `return`, `next`, `break` or `raise` instead.
+      class GetExtensionLicense < SketchUp::Cop
+
+        include RangeHelp
+        include SketchUp::NoCommentDisable
+
+        MSG_INVALID = 'Invalid extension GUID'.freeze
+
+        MSG_WRONG_TYPE = 'Only pass in extension GUID from local string '\
+                         'literals.'.freeze
+
+        MSG_TRAILING_SPACE = 'Extra space in extension GUID'.freeze
+
+        def_node_matcher :get_extension_license, <<-PATTERN
+          (send
+            (const
+              (const nil? :Sketchup) :Licensing) :get_extension_license
+            $_)
+        PATTERN
+
+        # rubocop:disable Metrics/LineLength
+        EXTENSION_ID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/
+        # rubocop:enable Metrics/LineLength
+
+        def on_send(node)
+          argument = get_extension_license(node)
+          return unless argument
+
+          if argument.lvar_type?
+            variable_name = argument.children.first
+            assignment_node = find_assignment(node, variable_name)
+            argument = assignment_node.children.last
+          end
+
+          if argument.str_type?
+            validate_extension_id(argument)
+          else
+            location = argument.loc.expression
+            add_offense(node, location: location, message: MSG_WRONG_TYPE)
+          end
+        end
+
+        private
+
+        def find_assignment(node, variable_name)
+          scope = node
+          until scope.parent.nil?
+            scope = scope.parent
+            scope.each_child_node { |child|
+              # next unless child.is_a?(RuboCop::AST::Node)
+              next unless child.lvasgn_type?
+              next unless child.children.first == variable_name
+
+              return child
+            }
+          end
+          nil
+        end
+
+        def validate_extension_id(node)
+          extension_id = node.str_content
+
+          # Trailing spaces
+          if extension_id.rstrip.size < extension_id.size
+            end_pos = node.loc.end.begin_pos
+            begin_pos = node.loc.begin.end_pos + extension_id.rstrip.size
+            range = range_between(begin_pos, end_pos)
+            add_offense(node, location: range, message: MSG_TRAILING_SPACE)
+            return false
+          end
+
+          # Invalid format.
+          if extension_id !~ EXTENSION_ID_PATTERN
+            range = string_contents_range(node)
+            add_offense(node, location: range, message: MSG_INVALID)
+            return false
+          end
+
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/cop/requirements/global_constants.rb

@@ -3,6 +3,12 @@
 module RuboCop
   module Cop
     module SketchupRequirements
+      # Extensions in SketchUp all share the same Ruby environment on the user's
+      # machine. Because of this it's important that each extension isolate
+      # itself to avoid clashing with other extensions.
+      #
+      # Extensions submitted to Extension Warehouse is expected to not define
+      # global constants.
       class GlobalConstants < SketchUp::Cop
 
         include SketchUp::NoCommentDisable
@@ -19,8 +25,11 @@ module RuboCop
         # Constant assignment.
         def on_casgn(node)
           return if namespaced_constant?(node)
+
           namespace = Namespace.new(node.parent_module_name)
-          add_offense(node, location: :name, severity: :error) if namespace.top_level?
+          return unless namespace.top_level?
+
+          add_offense(node, location: :name)
         end
 
       end

data/lib/rubocop/sketchup/cop/requirements/global_include.rb

@@ -3,6 +3,12 @@
 module RuboCop
   module Cop
     module SketchupRequirements
+      # Extensions in SketchUp all share the same Ruby environment on the user's
+      # machine. Because of this it's important that each extension isolate
+      # itself to avoid clashing with other extensions.
+      #
+      # Extensions submitted to Extension Warehouse is expected to not pollute
+      # the global namespace by including mix-in modules.
       class GlobalInclude < SketchUp::Cop
 
         include SketchUp::NoCommentDisable
@@ -16,7 +22,8 @@ module RuboCop
 
         def on_send(node)
           return unless global_include?(node)
-          add_offense(node, severity: :error)
+
+          add_offense(node, location: :selector)
         end
 
         private
@@ -26,7 +33,7 @@ module RuboCop
         end
 
         def global_namespace?(node)
-          ['Kernel', 'Object'].include?(node.parent_module_name)
+          %w[Kernel Object].include?(node.parent_module_name)
         end
 
       end

data/lib/rubocop/sketchup/cop/requirements/global_methods.rb

@@ -3,6 +3,12 @@
 module RuboCop
   module Cop
     module SketchupRequirements
+      # Extensions in SketchUp all share the same Ruby environment on the user's
+      # machine. Because of this it's important that each extension isolate
+      # itself to avoid clashing with other extensions.
+      #
+      # Extensions submitted to Extension Warehouse is expected to not define
+      # global methods.
       class GlobalMethods < SketchUp::Cop
 
         include SketchUp::NoCommentDisable
@@ -44,9 +50,12 @@ module RuboCop
             # If a method is defined inside a block then parent_module_name
             # will return nil.
             return if node.parent_module_name.nil?
+
             namespace = Namespace.new(node.parent_module_name)
           end
-          add_offense(node, location: :name, severity: :error) if namespace.top_level?
+          return unless namespace.top_level?
+
+          add_offense(node, location: :name)
         end
         alias on_defs on_def
 

data/lib/rubocop/sketchup/cop/requirements/global_variables.rb

@@ -3,12 +3,19 @@
 module RuboCop
   module Cop
     module SketchupRequirements
+      # Extensions in SketchUp all share the same Ruby environment on the user's
+      # machine. Because of this it's important that each extension isolate
+      # itself to avoid clashing with other extensions.
+      #
+      # Extensions submitted to Extension Warehouse is expected to not define
+      # global variables.
+      #
       # This cops looks for uses of global variables.
       # It does not report offenses for built-in global variables.
       # Built-in global variables are allowed by default. Additionally
       # users can allow additional variables via the AllowedVariables option.
       #
-      # Note that backreferences like $1, $2, etc are not global variables.
+      # Note that backreferences like `$1`, `$2`, etc are not global variables.
       class GlobalVariables < SketchUp::Cop
 
         include SketchUp::NoCommentDisable
@@ -45,11 +52,11 @@ module RuboCop
           $DEBUG $FILENAME $VERBOSE $SAFE
           $-0 $-a $-d $-F $-i $-I $-l $-p $-v $-w
           $CLASSPATH $JRUBY_VERSION $JRUBY_REVISION $ENV_JAVA
-        ]
+        ].freeze
 
         SKETCHUP_VARS = %i[
           $loaded_files
-        ]
+        ].freeze
 
         # Some globals, like DC's, are being read from so often that it's better
         # to ignore these to reduce noise.
@@ -78,7 +85,9 @@ module RuboCop
         def check(node)
           global_var, = *node
 
-          add_offense(node, location: :name, severity: :error) unless allowed_var?(global_var)
+          return if allowed_var?(global_var)
+
+          add_offense(node, location: :name)
         end
       end
     end

data/lib/rubocop/sketchup/cop/requirements/language_handler_globals.rb

@@ -3,14 +3,15 @@
 module RuboCop
   module Cop
     module SketchupRequirements
-      # Avoid using globals in general, but  especially these which are known to
+      # Avoid using globals in general, but especially these which are known to
       # be in use by other extensions made by SketchUp.
       # They are still in use due to compatibility reasons.
       class LanguageHandlerGlobals < SketchUp::Cop
 
         include SketchUp::NoCommentDisable
 
-        MSG = "Avoid globals in general, but especially these which are known to be in use.".freeze
+        MSG = 'Avoid globals in general, but especially these which are known '\
+              'to be in use.'.freeze
 
         LH_GLOBALS = %i[
           $dc_strings
@@ -26,7 +27,7 @@ module RuboCop
           $unitsStrings
           $uStrings
           $wt_strings
-        ]
+        ].freeze
 
         def hl_global_var?(global_var)
           LH_GLOBALS.include?(global_var)
@@ -35,7 +36,8 @@ module RuboCop
         def on_gvasgn(node)
           global_var, = *node
           return unless hl_global_var?(global_var)
-          add_offense(node, location: :name, severity: :error)
+
+          add_offense(node, location: :name)
         end
 
       end