rubocop-sketchup 0.5.0 → 0.6.0

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

@@ -1,163 +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
+# 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

@@ -1,49 +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
+# 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

@@ -1,117 +1,117 @@
-# frozen_string_literal: true
-
-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
-
-        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}"
-          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}"
-          end
-          check_feature(node, :method, feature_name)
-        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|
-            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)
-              }
-              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}."
-          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)
-          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
+# frozen_string_literal: true
+
+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
+
+        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}"
+          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}"
+          end
+          check_feature(node, :method, feature_name)
+        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|
+            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)
+              }
+              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}."
+          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)
+          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