rubocop-sketchup 0.5.0 → 0.6.0

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

@@ -1,24 +1,24 @@
-# frozen_string_literal: true
-
-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: :selector)
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+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: :selector)
+        end
+      end
+    end
+  end
+end

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

@@ -1,30 +1,30 @@
-# frozen_string_literal: true
-
-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
-        include SketchUp::NamespaceChecker
-
-        MSG = 'Do not modify the SketchUp API.'.freeze
-
-        NAMESPACES = %w[
-          Geom Layout Sketchup SketchupExtension UI
-        ].freeze
-
-        def namespaces
-          NAMESPACES
-        end
-
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+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
+        include SketchUp::NamespaceChecker
+
+        MSG = 'Do not modify the SketchUp API.'.freeze
+
+        NAMESPACES = %w[
+          Geom Layout Sketchup SketchupExtension UI
+        ].freeze
+
+        def namespaces
+          NAMESPACES
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,32 +1,32 @@
-# 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 Exit < SketchUp::Cop
-
-        include SketchUp::NoCommentDisable
-
-        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
-          (send {(const nil? :Kernel) nil?} {:exit :exit!} ...)
-        PATTERN
-
-        def on_send(node)
-          return unless exit?(node)
-
-          add_offense(node, location: :selector)
-        end
-      end
-    end
-  end
-end
+# 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 Exit < SketchUp::Cop
+
+        include SketchUp::NoCommentDisable
+
+        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
+          (send {(const nil? :Kernel) nil?} {:exit :exit!} ...)
+        PATTERN
+
+        def on_send(node)
+          return unless exit?(node)
+
+          add_offense(node, location: :selector)
+        end
+      end
+    end
+  end
+end