rubocop-sketchup 0.4.1 → 0.5.0

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

@@ -14,7 +14,7 @@ module RuboCop
         # We check only against the top level namespaces. The core define more
         # objects, but they are under one of the top level namespaces listed.
 
-        NAMESPACES_ADVANCED_CAMERA_TOOLS = %w(
+        NAMESPACES_ADVANCED_CAMERA_TOOLS = %w[
           ACTUtil
           CameraAppObserver
           CameraEntityObserver
@@ -28,9 +28,9 @@ module RuboCop
           FSGeomUtils
           FSValidate
           PageNameChangeObserver
-        ).freeze
+        ].freeze
 
-        NAMESPACES_DYNAMIC_COMPONENTS = %w(
+        NAMESPACES_DYNAMIC_COMPONENTS = %w[
           DCConverter
           DCDownloader
           DCFunctionsV1
@@ -39,11 +39,11 @@ module RuboCop
           DCProgressBar
           DynamicComponents
           DynamicComponentsV1
-        ).freeze
+        ].freeze
 
-        NAMESPACES_TRIMBLE_CONNECT = %w(
+        NAMESPACES_TRIMBLE_CONNECT = %w[
           Trimble
-        ).freeze
+        ].freeze
 
         NAMESPACES = (
           NAMESPACES_ADVANCED_CAMERA_TOOLS |

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

@@ -5,22 +5,33 @@ module RuboCop
     module SketchupRequirements
       # Register a single instance of SketchupExtension per extension.
       # This should be done by the root .rb file in the extension package.
+      #
+      # @example Good - a single SketchupExtension is registered.
+      #   module Example
+      #     unless file_loaded?(__FILE__)
+      #       extension = SketchupExtension.new('Hello World', 'example/main')
+      #       Sketchup.register_extension(extension, true)
+      #       file_loaded(__FILE__)
+      #     end
+      #   end
       class SketchupExtension < SketchUp::Cop
 
         include SketchUp::NoCommentDisable
         include SketchUp::ExtensionProject
         include RangeHelp
 
+        # rubocop:disable Metrics/LineLength
         MSG = 'Create and register one SketchupExtension instance per extension.'.freeze
         MSG_CREATE_ONE = 'Create only SketchupExtension instance per extension.'.freeze
         MSG_CREATE_MISSING = 'SketchupExtension.new not found.'.freeze
         MSG_REGISTER_ONE = 'Only register one SketchupExtension instance per extension.'.freeze
         MSG_REGISTER_MISSING = 'Registration of SketchupExtension not found. Expected %s'.freeze
+        # rubocop:enable Metrics/LineLength
 
         # Reference: http://rubocop.readthedocs.io/en/latest/node_pattern/
         def_node_search :sketchup_extension_new, <<-PATTERN
           (send
-            (const nil? :SketchupExtension) :new _ _)
+            (const nil? :SketchupExtension) :new ...)
         PATTERN
 
         def_node_search :sketchup_register_extension, <<-PATTERN
@@ -49,8 +60,7 @@ module RuboCop
           if extension_nodes.size > 1
             add_offense(nil,
                 location: range,
-                message: MSG_CREATE_ONE,
-                severity: :error)
+                message: MSG_CREATE_ONE)
             return
           end
 
@@ -59,8 +69,19 @@ module RuboCop
           if extension_node.nil?
             add_offense(nil,
                 location: range,
-                message: MSG_CREATE_MISSING,
-                severity: :error)
+                message: MSG_CREATE_MISSING)
+            return
+          end
+
+          # Ensure it have two arguments.
+          if extension_node.arguments.size < 2
+            message = if extension_node.arguments.size == 1
+                        'Missing second argument for the path'
+                      else
+                        'Missing required name arguments'
+                      end
+            add_offense(extension_node,
+                message: message)
             return
           end
 
@@ -79,8 +100,7 @@ module RuboCop
           # Make sure there is only one call to `register_extension`.
           if registered_vars.size > 1
             add_offense(registered_vars[1],
-                message: MSG_REGISTER_ONE,
-                severity: :error)
+                message: MSG_REGISTER_ONE)
             return
           end
 
@@ -89,8 +109,7 @@ module RuboCop
             msg = MSG_REGISTER_MISSING % extension_var.to_s
             add_offense(nil,
                 location: range,
-                message: msg,
-                severity: :error)
+                message: msg)
           end
         end
 

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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupRequirements
+      # Omit file extensions when using `Sketchup.require` to allow encrypted
+      # files to be loaded.
+      #
+      # Ruby C extensions, `.so`/`.bundle` libraries must always be loaded via
+      # the normal `require`. Omit the file extension to the libraries as Ruby
+      # will resolve the`.so`/`.bundle` automatically.
+      #
+      # @example Bad - This will fail if extension is encrypted
+      #   Sketchup.require 'hello/world.rb'
+      #
+      # @example Good - This will work for `.rbe`, `.rbs` and `rb` files.
+      #   Sketchup.require 'hello/world'
+      #
+      # @example Bad - This will fail if extension is encrypted
+      #   extension = SketchupExtension.new("Example", "Example/main.rb")
+      #
+      # @example Good - This will work for `.rbe`, `.rbs` and `rb` files.
+      #   extension = SketchupExtension.new("Example", "Example/main")
+      class SketchupRequire < SketchUp::Cop
+
+        include SketchUp::ExtensionProject
+        include SketchUp::NoCommentDisable
+        include RangeHelp
+
+        MSG_SKETCHUP_REQUIRE_EXT_NAME = 'Do not hard code file extensions '\
+                                        'with `Sketchup.require`.'.freeze
+
+        MSG_EXTENSION_NEW_EXT_NAME = 'Do not hard code file extensions '\
+                                      'with `SketchupExtension.new`.'.freeze
+
+        MSG_REQUIRE_FOR_BINARY = 'Use `require` instead of `Sketchup.require` '\
+                                 'to load binary Ruby libraries.'.freeze
+
+        MSG_OMIT_BINARY_EXT = 'Do not hard code .so/.bundle file '\
+                              'extensions'.freeze
+
+        MSG_REQUIRE_ENCRYPTED = 'Use `Sketchup.require` when loading Ruby '\
+                                'files for encrypted extensions.'.freeze
+
+        def_node_matcher :ruby_require, <<-PATTERN
+          (send nil? :require (str $_))
+        PATTERN
+
+        def_node_matcher :ruby_require?, <<-PATTERN
+          (send nil? :require (str _))
+        PATTERN
+
+
+        def_node_matcher :sketchup_require, <<-PATTERN
+          (send (const nil? :Sketchup) :require (str $_))
+        PATTERN
+
+        def_node_matcher :sketchup_require?, <<-PATTERN
+          (send (const nil? :Sketchup) :require (str _))
+        PATTERN
+
+
+        def_node_matcher :sketchup_extension_new, <<-PATTERN
+          (send (const nil? :SketchupExtension) :new _ (str $_))
+        PATTERN
+
+        def_node_matcher :sketchup_extension_new?, <<-PATTERN
+          (send (const nil? :SketchupExtension) :new _ (str _))
+        PATTERN
+
+
+        TOOLS_RUBY_FILES = %w[extensions.rb langhandler.rb sketchup.rb].freeze
+
+
+        def on_send(node)
+          if sketchup_require?(node)
+            filename = sketchup_require(node)
+            return if check_binary_sketchup_require(node, filename)
+            return if check_sketchup_require_filename(node, filename)
+
+          elsif ruby_require?(node)
+            filename = ruby_require(node)
+            return if check_binary_ruby_require(node, filename)
+            return if check_encrypted_require(node, filename)
+
+          elsif sketchup_extension_new?(node)
+            filename = sketchup_extension_new(node)
+            return if check_sketchup_extension_new_filename(node, filename)
+
+          end
+        end
+
+        private
+
+        def binary_require?(filename)
+          return unless extension_binaries?
+          return if extension_binaries.empty?
+
+          extension_binaries.include?(filename)
+        end
+
+        def check_binary_sketchup_require(node, filename)
+          return unless binary_require?(filename)
+
+          end_pos = node.loc.dot.end_pos
+          range = node.receiver.loc.expression.with(end_pos: end_pos)
+          add_offense(node, location: range, message: MSG_REQUIRE_FOR_BINARY)
+          true
+        end
+
+        def check_binary_ruby_require(node, filename)
+          ext_name = File.extname(filename)
+          return unless %w[.so .bundle].include?(ext_name)
+
+          add_offense(node, location: file_ext_range(node.arguments.first),
+                            message: MSG_OMIT_BINARY_EXT)
+          true
+        end
+
+        def check_sketchup_require_filename(node, filename)
+          return if valid_filename?(filename)
+
+          add_offense(node, location: file_ext_range(node.arguments.first),
+                            message: MSG_SKETCHUP_REQUIRE_EXT_NAME)
+          true
+        end
+
+        def check_sketchup_extension_new_filename(node, filename)
+          return if valid_filename?(filename)
+
+          add_offense(node, location: file_ext_range(node.arguments.last),
+                            message: MSG_EXTENSION_NEW_EXT_NAME)
+          true
+        end
+
+        def check_encrypted_require(node, filename)
+          return unless encrypted_extension?
+          return unless extension_file?(filename)
+
+          add_offense(node, location: node.loc.selector,
+                            message: MSG_REQUIRE_ENCRYPTED)
+          true
+        end
+
+        def first_directory(path)
+          path.to_s.split(File::SEPARATOR).first.downcase
+        end
+
+        def extension_file?(filename)
+          pathname = Pathname.new(filename).cleanpath
+          return false unless pathname.relative?
+
+          first_directory(extension_directory) == first_directory(pathname)
+        end
+
+        def valid_filename?(filename)
+          File.extname(filename).empty? || TOOLS_RUBY_FILES.include?(filename)
+        end
+
+      end
+    end
+  end
+end

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

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

@@ -3,22 +3,31 @@
 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
 
-        MSG = "Incompatible feature with target SketchUp version".freeze
+        MSG = 'Incompatible feature with target SketchUp version'.freeze
 
         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}"
-            check_feature(node, :method, feature_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
@@ -26,9 +35,10 @@ module RuboCop
             # 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}"
-            check_feature(node, :method, feature_name)
           end
+          check_feature(node, :method, feature_name)
         end
 
         def on_const(node)
@@ -42,15 +52,20 @@ module RuboCop
 
         def check_feature(node, type, feature_name)
           return unless sketchup_target_version?
+
           full_feature_name = feature_name
           FEATURES.each { |feature_set|
-            feature_version = SketchUp::SketchUpVersion.new(feature_set[:version])
+            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) }
+              full_feature_name = objects.find { |object|
+                object.end_with?(feature_name)
+              }
               next unless full_feature_name
             else
               next unless objects.include?(feature_name)
@@ -63,7 +78,21 @@ module RuboCop
           message = "The #{feature_type} `#{feature_name}` was added in "\
                     "#{feature_version} which is incompatible with target "\
                     "#{sketchup_target_version}."
-          add_offense(node, message: message)
+          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
+            :expression
+          end
         end
 
         def module_method?(node)

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

@@ -4,12 +4,14 @@ module RuboCop
   module Cop
     module SketchupSuggestions
       # Tapping into the internals of Dynamic Components is risky. It could
-      # change at any time.
+      # 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.".freeze
+        MSG = 'Avoid relying on internal logic of Dynamic Components.'.freeze
 
         def on_gvar(node)
           check_global(node)
@@ -22,7 +24,8 @@ module RuboCop
         def check_global(node)
           global_var, = *node
           return unless dc_global_var?(global_var)
-          add_offense(node, location: :name, severity: :error)
+
+          add_offense(node, location: :name, severity: :warning)
         end
 
       end

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

@@ -40,6 +40,7 @@ module RuboCop
         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
 
@@ -54,8 +55,10 @@ module RuboCop
           # 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
 

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

@@ -3,9 +3,15 @@
 module RuboCop
   module Cop
     module SketchupSuggestions
+      # Prefer `model.active_entities` over `model.entities`.
+      #
+      # Most tools/actions act upon the active entities context. This could be
+      # an opened group or component instance. Because of this, prefer
+      # `model.active_entities` by default over `model.entities` unless you
+      # have an explicit reason to work in the root model context.
       class ModelEntities < SketchUp::Cop
 
-        MSG = 'Typically one should use model.active_entities instead of model.entities.'.freeze
+        MSG = 'Prefer `model.active_entities` over `model.entities`.'.freeze
 
         # Reference: http://www.rubydoc.info/gems/rubocop/RuboCop/NodePattern
         def_node_matcher :active_model_entities?, <<-PATTERN
@@ -18,10 +24,11 @@ module RuboCop
             ({lvar ivar cvar} $_) :entities)
         PATTERN
 
-        MODEL_VARIABLE_NAMES = %w[model mod]
+        MODEL_VARIABLE_NAMES = %w[model mod].freeze
 
         def model_entities?(node)
           return true if active_model_entities?(node)
+
           name = entities_receiver(node)
           name && model_variable?(name)
         end

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

@@ -23,6 +23,7 @@ module RuboCop
 
           if dc_method.key?(:variables)
             return unless node.receiver && node.receiver.variable?
+
             receiver_name = node.receiver.children.first
             # Account for instance and class variables.
             receiver_name = receiver_name.to_s.tr('@', '').to_sym
@@ -32,7 +33,10 @@ module RuboCop
           path = dc_method[:path]
           message = "#{path}##{name} is not part of the official API. "\
                     "It's a monkey-patched addition by Dynamic Components."
-          add_offense(node, severity: :error, message: message)
+          add_offense(node,
+              location: :selector,
+              severity: :warning,
+              message: message)
         end
 
       end

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

@@ -3,31 +3,43 @@
 module RuboCop
   module Cop
     module SketchupSuggestions
+      # Operation name should be a short capitalized description. It will be
+      # visible to the user in the Edit > Undo menu. Make sure to give it a
+      # short human readable name, similar to SketchUp's own operation names.
+      #
+      # This cop make some very naive assumptions and will have more false
+      # positives than most of the other cops. It's purpose is mainly to enable
+      # awareness.
       class OperationName < SketchUp::Cop
 
         include RangeHelp
 
         MSG = 'Operation name should be a short capitalized description.'.freeze
-        MSG_MAX = "Operation names should not be short and concise. [%d/%d]".freeze
+        MSG_MAX = 'Operation names should not be short and concise. [%d/%d]'.freeze
 
         def on_send(node)
           _, method_name, *args = *node
           return unless method_name == :start_operation
           return if args.empty? || !args.first.str_type?
+
+          # Ignore transparent operations.
+          return if args.size == 4 && args.last.true_type?
+
           operation_name = args.first.str_content
           # We can only inspect string literals.
           return unless operation_name.is_a?(String)
+
           # Check the format of the operation name.
           unless acceptable_operation_name?(operation_name)
-            msg = %[#{MSG} Expected: `"#{titleize(operation_name)}"`]
+            msg = %(#{MSG} Expected: `"#{titleize(operation_name)}"`)
             add_offense(args.first, location: :expression, message: msg)
           end
           # Check the length of the operation name.
           unless operation_name.size <= max_operation_name_length
             message = format(MSG_MAX, operation_name.size, max_operation_name_length)
             add_offense(args.first,
-              location: excess_range(args.first, operation_name),
-              message: message)
+                location: excess_range(args.first, operation_name),
+                message: message)
           end
           # Ensure operation name is not empty.
           if operation_name.empty?
@@ -54,6 +66,7 @@ module RuboCop
           # Capitalization, no programmer name, no punctuation.
           return false if name.end_with?('.')
           return false if titleize(name) != name
+
           true
         end
 
@@ -67,21 +80,19 @@ module RuboCop
         TITLEIZE_EXCLUDE = %w[
           by for from in of to
           and or if
-        ]
+        ].freeze
 
         def titleize(string)
           string = string.gsub(/[_.]/, ' ')
           words = string.split.map { |word|
-            if TITLEIZE_EXCLUDE.include?(word)
-              word
-            else
+            unless TITLEIZE_EXCLUDE.include?(word)
               # word.capitalize won't work here, as we want to allow words like:
               # "HTML", "SketchUp". So instead only the first character in each
               # word is modified.
               char = word[0].upcase
               word[0, 1] = char
-              word
             end
+            word
           }
           words.join(' ')
         end

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

@@ -3,10 +3,20 @@
 module RuboCop
   module Cop
     module SketchupSuggestions
-      # Avoid Sketchup.find_support_file to find your extension's files.
+      # 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
+        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/
@@ -19,6 +29,7 @@ module RuboCop
 
         def on_send(node)
           return unless sketchup_find_support_file?(node)
+
           add_offense(node, location: :expression)
         end
 

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

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