rubocop-sketchup 0.6.0 → 0.7.0

data/lib/rubocop/sketchup/cop/bugs/material_name.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupBugs
+      # Prior to SketchUp 2018 it was possible for the Ruby API to cause
+      # materials to have duplicate names. This is not a valid SketchUp model
+      # as SketchUp expects material names to be unique identifiers.
+      #
+      # `model.materials.add('Example')` have always made materials unique by
+      # appending a numeric post-fix to the name.
+      #
+      # However, `material.name = 'Example'` did not perform such check. It
+      # would blindly set the new name.
+      #
+      # As of SketchUp 2018 the API behavior was changed to prevent this.
+      # `material.name = 'Example'` will now raise an `ArgumentError` is the
+      # name is not unique.
+      #
+      # A new method was added to allow a unique material name to be generated:
+      # `model.material.unique_name('Example')`.
+      #
+      # Changing the name of materials can now follow the same pattern as layers
+      # and component definitions.
+      #
+      # Note that in SketchUp 2018 there was also a second bug introduced. A
+      # name cache was introduced to speed up the lookup and generation of
+      # unique names. Unfortunately this got out of sync between changing name
+      # via the UI versus via the API. This has been fixed in SketchUp 2019.
+      #
+      # @example Pattern for setting material name from SketchUp 2018
+      #   material.name = model.materials.unique_name('Example')
+      #
+      # @example Pattern for setting name prior to SketchUp 2018
+      #   # Works with SketchUp 2014 or newer:
+      #   require 'set'
+      #
+      #   module Example
+      #
+      #     def self.rename_material(material, name)
+      #       materials = material.model.materials
+      #       material.name = self.unique_name(materials, name)
+      #     end
+      #
+      #     def self.unique_material_name(materials, name)
+      #       if materials.respond_to?(:unique_name)
+      #         # Use fast native implementation if possible.
+      #         materials.unique_name(name)
+      #       else
+      #         # Cache names in a Set for fast lookup.
+      #         names = Set.new(materials.map(&:name))
+      #         unique_name = name
+      #         # Extract the base name and post-fix.
+      #         match = unique_name.match(/^\D.*?(\d*)$/)
+      #         base, postfix = match ? match.captures : [unique_name, 0]
+      #         # Ensure basename has length and postfix is an integer.
+      #         base = unique_name if base.empty?
+      #         postfix = postfix.to_i
+      #         # Iteratively find a unique name.
+      #         until !names.include?(unique_name)
+      #           postfix = postfix.next
+      #           unique_name = "#{base}#{postfix}"
+      #         end
+      #         unique_name
+      #       end
+      #     end
+      #
+      #   end
+      class MaterialName < SketchUp::Cop
+
+        include SketchUp::SketchUpTargetRange
+
+        define_sketchup_target_max_version 'SketchUp 2017'
+
+        MATERIAL_VARIABLES = %i[material mat].freeze
+
+        def_node_matcher :material_set_name?, <<-PATTERN
+          (send #material? :name= _)
+        PATTERN
+
+        MSG_SET_NAME = '`material.name=` might add duplicate materials in '\
+            'SU2017 and older versions.'.freeze
+
+        def on_send(node)
+          return unless valid_for_target_sketchup_version?
+          return unless material_set_name?(node)
+
+          add_offense(node, message: MSG_SET_NAME)
+        end
+
+        private
+
+        def material?(node)
+          return false unless node && (node.send_type? || node.variable?)
+
+          name = variable_name(node.children.last)
+          MATERIAL_VARIABLES.include?(name)
+        end
+
+        # Returns the name without the @ or $ prefix.
+        def variable_name(symbol)
+          symbol.to_s.tr('$@', '').to_sym
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/cop/bugs/render_mode.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupBugs
+      # A regression was introduced in SketchUp 2017 that cause invalid render
+      # modes to crash SketchUp. The crash might not happen exactly when the
+      # new mode is set, but later when the viewport re-draws.
+      #
+      # Valid render modes are: (Internal enum names in parentheses)
+      #
+      # * `0` (`kRenderWireframe`)
+      # * `1` (`kRenderHidden`)
+      # * `2` (`kRenderFlat`)
+      # * `3` (`kRenderSmooth`)
+      # * `5` (`kRenderNoMaterials`)
+      #
+      # @example This obsolete render mode will crash SketchUp 2017 and newer
+      #   Sketchup.active_model.rendering_options["RenderMode"] = 4
+      #
+      # @example This invalid render mode will crash SketchUp 2017 and newer
+      #   Sketchup.active_model.rendering_options["RenderMode"] = 99
+      class RenderMode < SketchUp::Cop
+
+        include SketchUp::SketchUpTargetRange
+
+        define_sketchup_target_min_version 'SketchUp 2017'
+
+        RENDER_MODE_VALID = [
+          0, # kRenderWireframe,
+          1, # kRenderHidden,
+          2, # kRenderFlat,
+          3, # kRenderSmooth,
+          5, # kRenderNoMaterials
+        ].freeze
+
+        RENDER_MODE_OBSOLETE = [
+          4, # kRenderTextureObsolete,
+        ].freeze
+
+        def_node_matcher :set_render_mode, <<-PATTERN
+          (send _ :[]= (str "RenderMode") (int $_))
+        PATTERN
+
+        MSG_OBSOLETE = 'Obsolete render mode will crash in SU2017 and '\
+            'newer versions.'.freeze
+
+        MSG_INVALID = 'Invalid render mode will crash in SU2017 and '\
+            'newer versions.'.freeze
+
+        def on_send(node)
+          return unless valid_for_target_sketchup_version?
+
+          value = set_render_mode(node)
+          return if value.nil?
+          return if RENDER_MODE_VALID.include?(value)
+
+          value_node = node.arguments.last
+          message = obsolete?(value) ? MSG_OBSOLETE : MSG_INVALID
+          add_offense(value_node, message: message)
+        end
+
+        private
+
+        def obsolete?(value)
+          RENDER_MODE_OBSOLETE.include?(value)
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/cop/bugs/uniform_scaling.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupBugs
+      # Until SketchUp 2018 `Geom::Transformation.scaling(scale)` modified the
+      # 16th value in the transformation matrix. This way of scaling the matrix
+      # isn't fully accounted in all places in SketchUp. There are also a number
+      # of exporters and render engines which also doesn't fully handle this.
+      #
+      # @example Workaround for SketchUp versions older than SketchUp 2018
+      #     tr = Geom::Transformation.scaling(scale, scale, scale)
+      class UniformScaling < SketchUp::Cop
+
+        include SketchUp::SketchUpTargetRange
+
+        define_sketchup_target_max_version 'SketchUp 2017'
+
+        def_node_matcher :transformation_scaling?, <<-PATTERN
+          (send (const (const nil? :Geom) :Transformation) :scaling _)
+        PATTERN
+
+        MSG = 'Resulting transformation matrix might yield unexpected '\
+            'results.'.freeze
+
+        def on_send(node)
+          return unless valid_for_target_sketchup_version?
+          return unless transformation_scaling?(node)
+
+          add_offense(node.arguments.first)
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/cop/deprecations/add_separator_to_menu.rb

@@ -1,25 +1,25 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupDeprecations
-      # Avoid adding separators to top level menus. If you require grouping use
-      # a sub-menu instead.
-      class AddSeparatorToMenu < SketchUp::Cop
-
-        MSG = 'Method is deprecated.'.freeze
-
-        def_node_matcher :add_separator_to_menu?, <<-PATTERN
-          (send nil? :add_separator_to_menu _)
-        PATTERN
-
-        def on_send(node)
-          return unless add_separator_to_menu?(node)
-
-          add_offense(node, location: :selector)
-        end
-
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupDeprecations
+      # Avoid adding separators to top level menus. If you require grouping use
+      # a sub-menu instead.
+      class AddSeparatorToMenu < SketchUp::Cop
+
+        MSG = 'Method is deprecated.'.freeze
+
+        def_node_matcher :add_separator_to_menu?, <<-PATTERN
+          (send nil? :add_separator_to_menu _)
+        PATTERN
+
+        def on_send(node)
+          return unless add_separator_to_menu?(node)
+
+          add_offense(node, location: :selector)
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/cop/deprecations/operation_next_transparent.rb

@@ -1,30 +1,30 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupDeprecations
-      # If set to true, then whatever operation comes after this one will be
-      # appended into one combined operation, allowing the user the undo both
-      # actions with a single undo command.
-      #
-      # This flag is a highly difficult one, since there are so many ways that a
-      # SketchUp user can interrupt a given operation with one of their own.
-      #
-      # Only use this flag if you have no other option, for instance to work
-      # around bug in how `Sketchup::Model#place_component` starts operations.
-      class OperationNextTransparent < SketchUp::Cop
-        MSG = 'Third argument is deprecated.'.freeze
-
-        def on_send(node)
-          _, method_name, *args = *node
-          return unless method_name == :start_operation
-          return if args.size < 3
-
-          argument = args[2]
-          next_transparent = (argument.type == :true)
-          add_offense(argument, location: :expression) if next_transparent
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupDeprecations
+      # If set to true, then whatever operation comes after this one will be
+      # appended into one combined operation, allowing the user the undo both
+      # actions with a single undo command.
+      #
+      # This flag is a highly difficult one, since there are so many ways that a
+      # SketchUp user can interrupt a given operation with one of their own.
+      #
+      # Only use this flag if you have no other option, for instance to work
+      # around bug in how `Sketchup::Model#place_component` starts operations.
+      class OperationNextTransparent < SketchUp::Cop
+        MSG = 'Third argument is deprecated.'.freeze
+
+        def on_send(node)
+          _, method_name, *args = *node
+          return unless method_name == :start_operation
+          return if args.size < 3
+
+          argument = args[2]
+          next_transparent = (argument.type == :true)
+          add_offense(argument, location: :expression) if next_transparent
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/cop/deprecations/require_all.rb

@@ -1,27 +1,27 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupDeprecations
-      # Method is deprecated because it adds the given path to `$LOAD_PATH`.
-      # Modifying `$LOAD_PATH` is bad practice because it can cause extensions
-      # to inadvertently load the wrong file.
-      class RequireAll < SketchUp::Cop
-
-        MSG = 'Method is deprecated because it adds the given path '\
-              'to $LOAD_PATH.'.freeze
-
-        def_node_matcher :require_all?, <<-PATTERN
-          (send nil? :require_all _)
-        PATTERN
-
-        def on_send(node)
-          return unless require_all?(node)
-
-          add_offense(node, location: :selector)
-        end
-
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupDeprecations
+      # Method is deprecated because it adds the given path to `$LOAD_PATH`.
+      # Modifying `$LOAD_PATH` is bad practice because it can cause extensions
+      # to inadvertently load the wrong file.
+      class RequireAll < SketchUp::Cop
+
+        MSG = 'Method is deprecated because it adds the given path '\
+              'to $LOAD_PATH.'.freeze
+
+        def_node_matcher :require_all?, <<-PATTERN
+          (send nil? :require_all _)
+        PATTERN
+
+        def on_send(node)
+          return unless require_all?(node)
+
+          add_offense(node, location: :selector)
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/cop/deprecations/set_texture_projection.rb

@@ -1,26 +1,26 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupDeprecations
-      # Method is deprecated because it creates invalid UV mapping. Saving the
-      # model will display a dialog indicating that the model needs to be
-      # repaired. Once repaired the UV mapping will visually change.
-      class SetTextureProjection < SketchUp::Cop
-
-        MSG = 'Method is deprecated. It can create invalid UV mapping.'.freeze
-
-        def_node_matcher :set_texture_projection?, <<-PATTERN
-          (send _ :set_texture_projection ...)
-        PATTERN
-
-        def on_send(node)
-          return unless set_texture_projection?(node)
-
-          add_offense(node, location: :selector)
-        end
-
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupDeprecations
+      # Method is deprecated because it creates invalid UV mapping. Saving the
+      # model will display a dialog indicating that the model needs to be
+      # repaired. Once repaired the UV mapping will visually change.
+      class SetTextureProjection < SketchUp::Cop
+
+        MSG = 'Method is deprecated. It can create invalid UV mapping.'.freeze
+
+        def_node_matcher :set_texture_projection?, <<-PATTERN
+          (send _ :set_texture_projection ...)
+        PATTERN
+
+        def on_send(node)
+          return unless set_texture_projection?(node)
+
+          add_offense(node, location: :selector)
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/cop/deprecations/show_ruby_panel.rb

@@ -1,25 +1,25 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupDeprecations
-      # Method is deprecated. Use `SKETCHUP_CONSOLE.show` instead.
-      class ShowRubyPanel < SketchUp::Cop
-
-        MSG = 'Method is deprecated. Use `SKETCHUP_CONSOLE.show` '\
-               'instead.'.freeze
-
-        def_node_matcher :show_ruby_panel?, <<-PATTERN
-          (send nil? :show_ruby_panel)
-        PATTERN
-
-        def on_send(node)
-          return unless show_ruby_panel?(node)
-
-          add_offense(node, location: :expression)
-        end
-
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupDeprecations
+      # Method is deprecated. Use `SKETCHUP_CONSOLE.show` instead.
+      class ShowRubyPanel < SketchUp::Cop
+
+        MSG = 'Method is deprecated. Use `SKETCHUP_CONSOLE.show` '\
+               'instead.'.freeze
+
+        def_node_matcher :show_ruby_panel?, <<-PATTERN
+          (send nil? :show_ruby_panel)
+        PATTERN
+
+        def on_send(node)
+          return unless show_ruby_panel?(node)
+
+          add_offense(node, location: :expression)
+        end
+
+      end
+    end
+  end
+end