rubocop-sketchup 0.2.1 → 0.3.0

data/lib/rubocop/sketchup/inject.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RuboCop
   # Ripped directly from rubocop-rspec.
   module SketchUp

data/lib/rubocop/sketchup/namespace.rb

@@ -38,7 +38,7 @@ module RuboCop
       end
 
       def top_level?
-        parts.last == 'Object'
+        %w[Kernel Object].include?(parts.first)
       end
 
     end

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

@@ -23,9 +23,12 @@ module RuboCop
         def check_class_or_module(node)
           name = node.defined_module_name
           parent = Namespace.new(node.parent_module_name)
+          namespace = parent.join(name)
           # Don't want to process anything that aren't top level namespaces.
           return unless parent.top_level?
-          check_namespace(node, parent.join(name))
+          # Don't check excluded namespaces.
+          return if exempted?(namespace)
+          check_namespace(node, namespace)
         end
 
         # Class variables are normally frowned upon since they leak through all
@@ -58,6 +61,17 @@ module RuboCop
           format('Use a single root namespace. (Found `%s`; Previously found `%s`)', namespace, @@namespace)
         end
 
+        def exempted?(namespace)
+          namespace_exceptions.include?(namespace.first)
+        end
+
+        def namespace_exceptions
+          exceptions = cop_config['Exceptions'] || []
+          return exceptions if exceptions.is_a?(Array)
+
+          raise 'exceptions needs to be an array of strings!'
+        end
+
       end
     end
   end

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

@@ -9,6 +9,7 @@ module RuboCop
 
         include SketchUp::NoCommentDisable
         include SketchUp::ExtensionProject
+        include RangeHelp
 
         IGNORED_DIRECTORIES = %w[
           __MACOSX

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupRequirements
+      class GlobalInclude < Cop
+
+        include SketchUp::NoCommentDisable
+        include SketchUp
+
+        MSG = 'Do not include into global namespace.'.freeze
+
+        def_node_matcher :is_include?, <<-PATTERN
+          (send nil? :include ...)
+        PATTERN
+
+        def on_send(node)
+          return unless global_include?(node)
+          add_offense(node, severity: :error)
+        end
+
+        private
+
+        def global_include?(node)
+          is_include?(node) && global_namespace?(node)
+        end
+
+        def global_namespace?(node)
+          ['Kernel', 'Object'].include?(node.parent_module_name)
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/requirements/minimal_registration.rb

@@ -16,7 +16,7 @@ module RuboCop
 
         # Reference: http://rubocop.readthedocs.io/en/latest/node_pattern/
         def_node_matcher :require_filename, <<-PATTERN
-          (:send
+          (send
             {(const nil? :Sketchup) nil?} :require
             (str $_))
         PATTERN

data/lib/rubocop/sketchup/requirements/observers_start_operation.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupRequirements
+      class ObserversStartOperation < Cop
+
+        include SketchUp::NoCommentDisable
+        include RangeHelp
+
+        MSG = 'Observers should create transparent operations.'.freeze
+
+        def_node_search :start_operation, <<-PATTERN
+          (send
+            _ :start_operation
+            ...)
+        PATTERN
+
+        OBSERVER_METHODS = %i[
+          onActivateModel
+          onNewModel
+          onOpenModel
+          onQuit
+          onUnloadExtension
+
+          onComponentInstanceAdded
+          onComponentInstanceRemoved
+
+          onComponentAdded
+          onComponentPropertiesChanged
+          onComponentRemoved
+          onComponentTypeChanged
+
+          onTextChanged
+
+          onActiveSectionPlaneChanged
+          onElementAdded
+          onElementModified
+          onElementRemoved
+          onEraseEntities
+
+          onChangeEntity
+          onEraseEntity
+
+          onClose
+          onOpen
+
+          onCurrentLayerChanged
+          onLayerAdded
+          onLayerChanged
+          onLayerRemoved
+          onRemoveAllLayers
+
+          onMaterialAdd
+          onMaterialChange
+          onMaterialRefChange
+          onMaterialRemove
+          onMaterialSetCurrent
+          onMaterialUndoRedo
+
+          onActivePathChanged
+          onAfterComponentSaveAs
+          onBeforeComponentSaveAs
+          onDeleteModel
+          onEraseAll
+          onExplode
+          onPidChanged
+          onPlaceComponent
+          onPostSaveModel
+          onPreSaveModel
+          onSaveModel
+          onTransactionAbort
+          onTransactionCommit
+          onTransactionEmpty
+          onTransactionRedo
+          onTransactionStart
+          onTransactionUndo
+
+          onOptionsProviderChanged
+
+          onContentsModified
+          onElementAdded
+          onElementRemoved
+
+          onRenderingOptionsChanged
+
+          onSelectionAdded
+          onSelectionBulkChange
+          onSelectionCleared
+          onSelectionRemoved
+
+          onShadowInfoChanged
+
+          onActiveToolChanged
+          onToolStateChanged
+
+          onViewChanged
+        ]
+
+        def on_def(node)
+          return unless observer_event?(node)
+          operations = start_operation(node)
+          operations.each { |operation|
+            _name, _disable_ui, _next_tr, transparent = operation.arguments
+            next unless transparent.nil? || transparent.falsey_literal?
+            location = operation_location(operation)
+            add_offense(operation, location: location, severity: :error)
+          }
+        end
+
+        private
+
+        def range(node)
+          range_between(node.begin_pos, node.end_pos)
+        end
+
+        def operation_location(node)
+          # Highlight the fourth argument if it's used. Fall back to the method
+          # name.
+          transparent_argument = node.arguments[3]
+          if transparent_argument
+            range(transparent_argument.loc.expression)
+          else
+            :selector
+          end
+        end
+
+        def observer_event?(node)
+          OBSERVER_METHODS.include?(node.method_name)
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/requirements/register_extension.rb

@@ -12,7 +12,7 @@ module RuboCop
         MSG = 'Always register extensions to load by default.'.freeze
 
         def_node_search :sketchup_register_extension, <<-PATTERN
-          (:send
+          (send
             (const nil? :Sketchup) :register_extension
             $...)
         PATTERN

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

@@ -9,6 +9,7 @@ module RuboCop
 
         include SketchUp::NoCommentDisable
         include SketchUp::ExtensionProject
+        include RangeHelp
 
         MSG = 'Create and register one SketchupExtension instance per extension.'.freeze
         MSG_CREATE_ONE = 'Create only SketchupExtension instance per extension.'.freeze
@@ -18,17 +19,14 @@ module RuboCop
 
         # Reference: http://rubocop.readthedocs.io/en/latest/node_pattern/
         def_node_search :sketchup_extension_new, <<-PATTERN
-          ({:lvasgn :ivasgn :cvasgn :gvasgn :casgn} ...
-            (:send
-              (:const nil? :SketchupExtension) :new
-              _
-              _))
+          (send
+            (const nil? :SketchupExtension) :new _ _)
         PATTERN
 
         def_node_search :sketchup_register_extension, <<-PATTERN
-          (:send
+          (send
             (const nil? :Sketchup) :register_extension
-            {({:lvar :ivar :cvar :gvar} $_)(const nil? $_)}
+            {({lvar ivar cvar gvar} $_)(const nil? $_)}
             _)
         PATTERN
 
@@ -41,6 +39,13 @@ module RuboCop
 
           # Look for SketchupExtension.new.
           extension_nodes = sketchup_extension_new(source_node).to_a
+
+          # Threat instances not assigned to anything as non-existing.
+          extension_nodes.select! { |node|
+            node.parent && node.parent.assignment?
+          }
+
+          # There should not be multiple instances.
           if extension_nodes.size > 1
             add_offense(nil,
                 location: range,
@@ -48,6 +53,8 @@ module RuboCop
                 severity: :error)
             return
           end
+
+          # There should be exactly one.
           extension_node = extension_nodes.first
           if extension_node.nil?
             add_offense(nil,
@@ -58,24 +65,25 @@ module RuboCop
           end
 
           # Find the name of the value SketchupExtension.new was assigned to.
-          if extension_node.casgn_type?
-            extension_var = extension_node.to_a[1]
+          assignment_node = extension_node.parent
+          if assignment_node.casgn_type?
+            extension_var = assignment_node.to_a[1]
           else
-            extension_var = extension_node.to_a[0]
+            extension_var = assignment_node.to_a[0]
           end
 
           # Look for Sketchup.register and make sure it register the extension
           # object detected earlier.
           registered_vars = sketchup_register_extension(source_node).to_a
-          # TODO: The offences here should probably highlight the line where
-          #       Sketchup.register_extension is.
+
+          # Make sure there is only one call to `register_extension`.
           if registered_vars.size > 1
-            add_offense(nil,
-                location: range,
+            add_offense(registered_vars[1],
                 message: MSG_REGISTER_ONE,
                 severity: :error)
             return
           end
+
           registered_var = sketchup_register_extension(source_node).first
           unless registered_var == extension_var
             msg = MSG_REGISTER_MISSING % extension_var.to_s

data/lib/rubocop/sketchup/sketchup_version.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module SketchUp
+    class SketchUpVersion
+
+      include Comparable
+
+      attr_reader :version, :maintenance
+
+      class InvalidVersion < StandardError; end
+
+      def initialize(version)
+        @version, @maintenance = parse_version(version)
+      end
+
+      def <=>(other)
+        if version == other.version
+          maintenance <=> other.maintenance
+        else
+          version <=> other.version
+        end
+      end
+
+      def to_s
+        string_version = version < 2013 ? version.to_f : version.to_i
+        if maintenance > 0
+          "SketchUp #{string_version} M#{maintenance}"
+        else
+          "SketchUp #{string_version}"
+        end
+      end
+
+      private
+
+      VERSION_NUMBER_REGEX = /^(?:SketchUp )?([0-9.]+)(?: M(\d+))?$/
+
+      # This list is compiled from the list of versions reported by YARD when
+      # running the `versions` template;
+      #
+      #   yardoc -t versions -f text
+      #
+      # TODO(thomthom): Push the version template to the API stubs repository.
+      VALID_VERSIONS = [
+        [2018, 0],
+        [2017, 0],
+        [2016, 1],
+        [2016, 0],
+        [2015, 0],
+        [2014, 0],
+        [2013, 0],
+        [8.0, 2],
+        [8.0, 1],
+        [8.0, 0],
+        [7.1, 1],
+        [7.1, 0],
+        [7.0, 1],
+        [7.0, 0],
+        [6.0, 0],
+      ]
+
+      def parse_version(version)
+        v = 0
+        m = 0
+        if version.is_a?(String)
+          # Treat all LayOut versions as SketchUp versions for now.
+          normalised_version = version.gsub('LayOut', 'SketchUp')
+          result = normalised_version.match(VERSION_NUMBER_REGEX)
+          if result
+            v = result.captures[0].to_f
+            m = (result.captures[1] || '0').to_i
+          end
+        elsif version.is_a?(Numeric)
+          v, m = [version, 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
+
+    end
+  end
+end

data/lib/rubocop/sketchup/suggestions/compatibility.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupSuggestions
+      class Compatibility < Cop
+
+        include SketchUp::Config
+        include SketchUp::Features
+
+        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)
+          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
+            # will get too many false positives with method names matching
+            # 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
+        end
+
+        def on_const(node)
+          feature_name = node.const_name
+          [:class, :module, :constant].each { |type|
+            check_feature(node, type, feature_name)
+          }
+        end
+
+        private
+
+        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])
+            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) }
+              next unless full_feature_name
+            else
+              next unless objects.include?(feature_name)
+            end
+            report(node, full_feature_name, feature_version, type)
+          }
+        end
+
+        def report(node, feature_name, feature_version, feature_type)
+          message = "The #{feature_type} `#{feature_name}` was added in "\
+                    "#{feature_version} which is incompatible with target "\
+                    "#{sketchup_target_version}."
+          add_offense(node, message: message)
+        end
+
+        def module_method?(node)
+          node.receiver && node.receiver.const_type?
+        end
+
+        def instance_method?(feature_name)
+          feature_name.start_with?('#')
+        end
+
+        def checkable_instance_method?(node)
+          INSTANCE_METHODS.include?(node.method_name)
+        end
+
+        def observer_method?(node)
+          OBSERVER_METHODS.include?(node.method_name)
+        end
+
+      end
+    end
+  end
+end