rubocop-sketchup 1.2.0 → 1.4.0

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.'
-
-        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.'
+
+        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.'
-
-        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.'
+
+        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.'
-
-        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.'
+
+        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

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

@@ -1,30 +1,30 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupDeprecations
-      # From SketchUp 6 until SketchUp 2013 the SketchUp API shipped with a
-      # `Set` class. When SketchUp started shipping with the Ruby StdLib in
-      # SketchUp 2014 the class was changed from `Set` to `Sketchup::Set` in
-      # order to avoid conflict with the Ruby Standard Library.
-      #
-      # The `Sketchup::Set` class is much slower than Ruby's own `Set` class
-      # and less versatile.
-      class SketchupSet < SketchUp::Cop
-
-        MSG = 'Class is deprecated.'
-
-        def_node_matcher :sketchup_set?, <<-PATTERN
-          (const (const nil? :Sketchup) :Set)
-        PATTERN
-
-        def on_const(node)
-          return unless sketchup_set?(node)
-
-          add_offense(node, location: :expression)
-        end
-
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupDeprecations
+      # From SketchUp 6 until SketchUp 2013 the SketchUp API shipped with a
+      # `Set` class. When SketchUp started shipping with the Ruby StdLib in
+      # SketchUp 2014 the class was changed from `Set` to `Sketchup::Set` in
+      # order to avoid conflict with the Ruby Standard Library.
+      #
+      # The `Sketchup::Set` class is much slower than Ruby's own `Set` class
+      # and less versatile.
+      class SketchupSet < SketchUp::Cop
+
+        MSG = 'Class is deprecated.'
+
+        def_node_matcher :sketchup_set?, <<-PATTERN
+          (const (const nil? :Sketchup) :Set)
+        PATTERN
+
+        def on_const(node)
+          return unless sketchup_set?(node)
+
+          add_offense(node, location: :expression)
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,41 +1,41 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupPerformance
-      # There are performance issue with the OpenSSL library that Ruby ship. In
-      # a clean SU session, default model there is a small delay observed in the
-      # Windows version of SU.
-      #
-      # But with a larger model loaded, or session that have had larger files
-      # loaded the lag will be minutes.
-      #
-      # `SecureRandom` is  also affected by this, as it uses OpenSSL to seed.
-      #
-      # It also affects `Net::HTTP` if making HTTPS connections.
-      class OpenSSL < SketchUp::Cop
-
-        MSG = 'Avoid use of OpenSSL within SketchUp due to severe performance '\
-              'issues.'
-
-        # http://www.rubydoc.info/gems/rubocop/RuboCop/NodePattern
-        # https://rubocop.readthedocs.io/en/latest/node_pattern/
-        def_node_matcher :require, <<-PATTERN
-          (send nil? :require
-            (str $_)
-          )
-        PATTERN
-
-        OPEN_SSL_USAGE = %w[openssl securerandom net/https net/http].freeze
-
-        def on_send(node)
-          filename = require(node)
-          return if filename.nil?
-          return unless OPEN_SSL_USAGE.include?(filename.downcase)
-
-          add_offense(node, location: :expression)
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupPerformance
+      # There are performance issue with the OpenSSL library that Ruby ship. In
+      # a clean SU session, default model there is a small delay observed in the
+      # Windows version of SU.
+      #
+      # But with a larger model loaded, or session that have had larger files
+      # loaded the lag will be minutes.
+      #
+      # `SecureRandom` is  also affected by this, as it uses OpenSSL to seed.
+      #
+      # It also affects `Net::HTTP` if making HTTPS connections.
+      class OpenSSL < SketchUp::Cop
+
+        MSG = 'Avoid use of OpenSSL within SketchUp due to severe ' \
+              'performance issues.'
+
+        # http://www.rubydoc.info/gems/rubocop/RuboCop/NodePattern
+        # https://rubocop.readthedocs.io/en/latest/node_pattern/
+        def_node_matcher :require, <<-PATTERN
+          (send nil? :require
+            (str $_)
+          )
+        PATTERN
+
+        OPEN_SSL_USAGE = %w[openssl securerandom net/https net/http].freeze
+
+        def on_send(node)
+          filename = require(node)
+          return if filename.nil?
+          return unless OPEN_SSL_USAGE.include?(filename.downcase)
+
+          add_offense(node, location: :expression)
+        end
+      end
+    end
+  end
+end

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

@@ -1,33 +1,33 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupPerformance
-      # Operations should disable the UI for performance gain.
-      #
-      # @example
-      #   model = Sketchup.active_model
-      #   model.start_operation('Operation Name', true)
-      #   # <model changes>
-      #   model.commit_operation
-      class OperationDisableUI < SketchUp::Cop
-        MSG = 'Operations should disable the UI for performance gain.'
-
-        def on_send(node)
-          _, method_name, *args = *node
-          return unless method_name == :start_operation
-
-          if args.size < 2
-            add_offense(node, location: :selector)
-            return
-          end
-          argument = args[1]
-          disable_ui = argument.truthy_literal?
-          return if disable_ui
-
-          add_offense(argument, location: :expression)
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupPerformance
+      # Operations should disable the UI for performance gain.
+      #
+      # @example
+      #   model = Sketchup.active_model
+      #   model.start_operation('Operation Name', true)
+      #   # <model changes>
+      #   model.commit_operation
+      class OperationDisableUI < SketchUp::Cop
+        MSG = 'Operations should disable the UI for performance gain.'
+
+        def on_send(node)
+          _, method_name, *args = *node
+          return unless method_name == :start_operation
+
+          if args.size < 2
+            add_offense(node, location: :selector)
+            return
+          end
+          argument = args[1]
+          disable_ui = argument.truthy_literal?
+          return if disable_ui
+
+          add_offense(argument, location: :expression)
+        end
+      end
+    end
+  end
+end

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

@@ -1,79 +1,79 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupPerformance
-      # 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
-      #   model.active_entities.each { |entity|
-      #     model.selection.add(entity) if entity.is_a?(Sketchup::Face)
-      #   }
-      #
-      # @example Better performance
-      #   model = Sketchup.active_model
-      #   faces = model.active_entities.map { |entity|
-      #     entity.is_a?(Sketchup::Face)
-      #   }
-      #   model.selection.add(faces)
-      #
-      # @example Better performance and simpler
-      #   model = Sketchup.active_model
-      #   faces = model.active_entities.grep(Sketchup::Face)
-      #   model.selection.add(faces)
-      class SelectionBulkChanges < SketchUp::Cop
-
-        include RangeHelp
-
-        MSG = 'Prefer changing selection in bulk instead of modifying '\
-              'selection within loops.'
-
-        # http://www.rubydoc.info/gems/rubocop/RuboCop/NodePattern
-        # https://rubocop.readthedocs.io/en/latest/node_pattern/
-        def_node_matcher :selection?, <<-PATTERN
-          (send
-            (send _ {:selection :sel}) {:add :remove :toggle}
-            ...)
-        PATTERN
-
-        def_node_matcher :block_loop?, <<-PATTERN
-          (block
-            (send
-              (send _ _) {
-                :each :each_with_index :each_with_object
-                :each_entry :each_index :each_slice
-                :each_key :each_pair :each_value
-                :grep
-              } ...)
-              ...)
-        PATTERN
-
-        def_node_matcher :numeric_loop?, <<-PATTERN
-          (block
-            (send
-              ({int float} _) {:times :upto :downto} ...)
-              ...)
-        PATTERN
-
-        def iterator?(node)
-          node.is_a?(RuboCop::AST::ForNode) ||
-            node.is_a?(RuboCop::AST::UntilNode) ||
-            node.is_a?(RuboCop::AST::WhileNode) ||
-            block_loop?(node) ||
-            numeric_loop?(node)
-        end
-
-        def on_send(node)
-          return unless selection?(node)
-          return unless node.ancestors.any?(&method(:iterator?))
-
-          add_offense(node, location: range_with_receiver(node))
-        end
-
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupPerformance
+      # 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
+      #   model.active_entities.each { |entity|
+      #     model.selection.add(entity) if entity.is_a?(Sketchup::Face)
+      #   }
+      #
+      # @example Better performance
+      #   model = Sketchup.active_model
+      #   faces = model.active_entities.map { |entity|
+      #     entity.is_a?(Sketchup::Face)
+      #   }
+      #   model.selection.add(faces)
+      #
+      # @example Better performance and simpler
+      #   model = Sketchup.active_model
+      #   faces = model.active_entities.grep(Sketchup::Face)
+      #   model.selection.add(faces)
+      class SelectionBulkChanges < SketchUp::Cop
+
+        include RangeHelp
+
+        MSG = 'Prefer changing selection in bulk instead of modifying ' \
+              'selection within loops.'
+
+        # http://www.rubydoc.info/gems/rubocop/RuboCop/NodePattern
+        # https://rubocop.readthedocs.io/en/latest/node_pattern/
+        def_node_matcher :selection?, <<-PATTERN
+          (send
+            (send _ {:selection :sel}) {:add :remove :toggle}
+            ...)
+        PATTERN
+
+        def_node_matcher :block_loop?, <<-PATTERN
+          (block
+            (send
+              (send _ _) {
+                :each :each_with_index :each_with_object
+                :each_entry :each_index :each_slice
+                :each_key :each_pair :each_value
+                :grep
+              } ...)
+              ...)
+        PATTERN
+
+        def_node_matcher :numeric_loop?, <<-PATTERN
+          (block
+            (send
+              ({int float} _) {:times :upto :downto} ...)
+              ...)
+        PATTERN
+
+        def iterator?(node)
+          node.is_a?(RuboCop::AST::ForNode) ||
+            node.is_a?(RuboCop::AST::UntilNode) ||
+            node.is_a?(RuboCop::AST::WhileNode) ||
+            block_loop?(node) ||
+            numeric_loop?(node)
+        end
+
+        def on_send(node)
+          return unless selection?(node)
+          return unless node.ancestors.any?(&method(:iterator?))
+
+          add_offense(node, location: range_with_receiver(node))
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,63 +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.'
-
-        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
+# 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.'
+
+        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