rubocop-sketchup 1.3.0 → 1.4.0

data/lib/rubocop/sketchup/namespace_checker.rb

@@ -1,103 +1,103 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module SketchUp
-    module NamespaceChecker
-
-      extend NodePattern::Macros
-
-      # Example:
-      #   Array.include(Example)
-      def_node_matcher :klass_include, <<-PATTERN
-        (send
-          (const nil? $_) { :include | :extend } _)
-      PATTERN
-
-      # Example:
-      #   class Array
-      #     include Example
-      #   end
-      def_node_matcher :klass_scope_include, <<-PATTERN
-        (
-          {
-            class (const nil? $_) nil? |
-            module (const nil? $_)
-          }
-          (send nil? { :include | :extend } _))
-      PATTERN
-
-      # Example:
-      #   include Example
-      def_node_matcher :include_call?, <<-PATTERN
-        (send nil? { :include | :extend } _)
-      PATTERN
-
-
-      def on_class(node)
-        check_namespace(node)
-      end
-
-      def on_module(node)
-        check_namespace(node)
-      end
-
-      def on_def(node)
-        check_namespace(node)
-      end
-      alias on_defs on_def
-
-      # Constant assignment.
-      def on_casgn(node)
-        check_namespace(node)
-      end
-
-      def on_send(node)
-        klass = klass_include(node) || klass_scope_include(node.parent)
-
-        if klass
-          namespace = SketchUp::Namespace.new(klass.to_s)
-          return unless namespaces.include?(namespace.first)
-        else
-          # If klass is `nil` we either don't have a `include` call or we're in
-          # global namespace.
-          return unless top_level_include?(node)
-        end
-
-        add_offense(node, location: :selector, severity: :error)
-      end
-
-      def check_namespace(node)
-        return unless in_namespace?(node)
-
-        add_offense(node, location: :name, severity: :error)
-      end
-
-      def top_level?(node)
-        # parent_module_name might return nil if for instance a method is
-        # defined within a block. (Apparently that is possible...)
-        return false if node.parent_module_name.nil?
-
-        namespace = SketchUp::Namespace.new(node.parent_module_name)
-        namespace.top_level?
-      end
-
-      def top_level_include?(node)
-        include_call?(node) && top_level?(node)
-      end
-
-      def in_namespace?(node)
-        # parent_module_name might return nil if for instance a method is
-        # defined within a block. (Apparently that is possible...)
-        return false if node.parent_module_name.nil?
-
-        namespace = SketchUp::Namespace.new(node.parent_module_name)
-        namespaces.include?(namespace.first)
-      end
-
-      def namespaces
-        raise NotImplementedError
-      end
-
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module SketchUp
+    module NamespaceChecker
+
+      extend NodePattern::Macros
+
+      # Example:
+      #   Array.include(Example)
+      def_node_matcher :klass_include, <<-PATTERN
+        (send
+          (const nil? $_) { :include | :extend } _)
+      PATTERN
+
+      # Example:
+      #   class Array
+      #     include Example
+      #   end
+      def_node_matcher :klass_scope_include, <<-PATTERN
+        (
+          {
+            class (const nil? $_) nil? |
+            module (const nil? $_)
+          }
+          (send nil? { :include | :extend } _))
+      PATTERN
+
+      # Example:
+      #   include Example
+      def_node_matcher :include_call?, <<-PATTERN
+        (send nil? { :include | :extend } _)
+      PATTERN
+
+
+      def on_class(node)
+        check_namespace(node)
+      end
+
+      def on_module(node)
+        check_namespace(node)
+      end
+
+      def on_def(node)
+        check_namespace(node)
+      end
+      alias on_defs on_def
+
+      # Constant assignment.
+      def on_casgn(node)
+        check_namespace(node)
+      end
+
+      def on_send(node)
+        klass = klass_include(node) || klass_scope_include(node.parent)
+
+        if klass
+          namespace = SketchUp::Namespace.new(klass.to_s)
+          return unless namespaces.include?(namespace.first)
+        else
+          # If klass is `nil` we either don't have a `include` call or we're in
+          # global namespace.
+          return unless top_level_include?(node)
+        end
+
+        add_offense(node, location: :selector, severity: :error)
+      end
+
+      def check_namespace(node)
+        return unless in_namespace?(node)
+
+        add_offense(node, location: :name, severity: :error)
+      end
+
+      def top_level?(node)
+        # parent_module_name might return nil if for instance a method is
+        # defined within a block. (Apparently that is possible...)
+        return false if node.parent_module_name.nil?
+
+        namespace = SketchUp::Namespace.new(node.parent_module_name)
+        namespace.top_level?
+      end
+
+      def top_level_include?(node)
+        include_call?(node) && top_level?(node)
+      end
+
+      def in_namespace?(node)
+        # parent_module_name might return nil if for instance a method is
+        # defined within a block. (Apparently that is possible...)
+        return false if node.parent_module_name.nil?
+
+        namespace = SketchUp::Namespace.new(node.parent_module_name)
+        namespaces.include?(namespace.first)
+      end
+
+      def namespaces
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/rubocop/sketchup/no_comment_disable.rb

@@ -1,17 +1,17 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module SketchUp
-    module NoCommentDisable
-
-      private
-
-      # This forces the cop to be run even if there is a source code comment
-      # that tries to disable it.
-      def enabled_line?(_line_number)
-        true
-      end
-
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module SketchUp
+    module NoCommentDisable
+
+      private
+
+      # This forces the cop to be run even if there is a source code comment
+      # that tries to disable it.
+      def enabled_line?(_line_number)
+        true
+      end
+
+    end
+  end
+end

data/lib/rubocop/sketchup/range_help.rb

@@ -1,52 +1,52 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Methods that calculate and return Parser::Source::Ranges
-    module RangeHelp
-
-      private
-
-      def range_with_receiver(node)
-        receiver = node.receiver
-        loc_begin = if receiver.send_type?
-                      receiver.loc.selector.begin_pos
-                    else
-                      receiver.loc.expression.begin_pos
-                    end
-        loc_end = node.loc.selector.end_pos
-        range_between(loc_begin, loc_end)
-      end
-
-      def string_contents_range(node)
-        begin_pos = node.loc.begin.end_pos
-        end_pos = node.loc.end.begin_pos
-        range_between(begin_pos, end_pos)
-      end
-
-      def arguments_range(node)
-        begin_pos = node.arguments.first.loc.expression.begin_pos
-        end_pos = node.arguments.last.loc.expression.end_pos
-        range_between(begin_pos, end_pos)
-      end
-
-      def conditional_range(node)
-        if node.modifier_form?
-          range_between(node.loc.keyword.begin_pos,
-                        node.loc.expression.end_pos)
-        else
-          :expression
-        end
-      end
-
-      def file_ext_range(argument_node)
-        filename = argument_node.str_content
-        ext_size = File.extname(filename).size
-        end_pos = argument_node.loc.end.begin_pos
-        begin_pos = end_pos - ext_size
-        range_between(begin_pos, end_pos)
-      end
-
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Methods that calculate and return Parser::Source::Ranges
+    module RangeHelp
+
+      private
+
+      def range_with_receiver(node)
+        receiver = node.receiver
+        loc_begin = if receiver.send_type?
+                      receiver.loc.selector.begin_pos
+                    else
+                      receiver.loc.expression.begin_pos
+                    end
+        loc_end = node.loc.selector.end_pos
+        range_between(loc_begin, loc_end)
+      end
+
+      def string_contents_range(node)
+        begin_pos = node.loc.begin.end_pos
+        end_pos = node.loc.end.begin_pos
+        range_between(begin_pos, end_pos)
+      end
+
+      def arguments_range(node)
+        begin_pos = node.arguments.first.loc.expression.begin_pos
+        end_pos = node.arguments.last.loc.expression.end_pos
+        range_between(begin_pos, end_pos)
+      end
+
+      def conditional_range(node)
+        if node.modifier_form?
+          range_between(node.loc.keyword.begin_pos,
+                        node.loc.expression.end_pos)
+        else
+          :expression
+        end
+      end
+
+      def file_ext_range(argument_node)
+        filename = argument_node.str_content
+        ext_size = File.extname(filename).size
+        end_pos = argument_node.loc.end.begin_pos
+        begin_pos = end_pos - ext_size
+        range_between(begin_pos, end_pos)
+      end
+
+    end
+  end
+end

data/lib/rubocop/sketchup/sketchup_target_range.rb

@@ -1,75 +1,75 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module SketchUp
-    # Mix-in module for Cops that are valid only for a given SketchUp version
-    # range. This mix-in uses the configured target SketchUp version to
-    # determine if it's relevant.
-    module SketchUpTargetRange
-
-      module ClassMethods
-
-        # @param [String] version
-        def define_sketchup_target_min_version(version)
-          @sketchup_target_min_version = SketchUpVersion.new(version)
-          nil
-        end
-
-        # @param [String] version
-        def define_sketchup_target_max_version(version)
-          @sketchup_target_max_version = SketchUpVersion.new(version)
-          nil
-        end
-
-        def sketchup_target_min_version
-          @sketchup_target_min_version
-        end
-
-        def sketchup_target_max_version
-          @sketchup_target_max_version
-        end
-
-      end # module ClassMethods
-
-      def self.included(mod)
-        mod.extend(ClassMethods)
-      end
-
-      def sketchup_target_min_version
-        self.class.sketchup_target_min_version
-      end
-
-      def sketchup_target_max_version
-        self.class.sketchup_target_max_version
-      end
-
-      def valid_for_target_sketchup_version?
-        # If no target version is configured, ignore this check.
-        return true unless sketchup_target_version?
-
-        # If no version is set - then it's valid for all known versions.
-        unless sketchup_target_min_version || sketchup_target_max_version
-          return true
-        end
-
-        # If there is a finite version range, check if the target SketchUp
-        # version is withing that.
-        if sketchup_target_min_version && sketchup_target_max_version
-          range = (sketchup_target_min_version..sketchup_target_max_version)
-          return range.include?(sketchup_target_version)
-        end
-
-        if sketchup_target_min_version
-          return sketchup_target_version >= sketchup_target_min_version
-        end
-
-        if sketchup_target_max_version
-          return sketchup_target_version <= sketchup_target_max_version
-        end
-
-        raise 'bug!' # Should not end up here.
-      end
-
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module SketchUp
+    # Mix-in module for Cops that are valid only for a given SketchUp version
+    # range. This mix-in uses the configured target SketchUp version to
+    # determine if it's relevant.
+    module SketchUpTargetRange
+
+      module ClassMethods
+
+        # @param [String] version
+        def define_sketchup_target_min_version(version)
+          @sketchup_target_min_version = SketchUpVersion.new(version)
+          nil
+        end
+
+        # @param [String] version
+        def define_sketchup_target_max_version(version)
+          @sketchup_target_max_version = SketchUpVersion.new(version)
+          nil
+        end
+
+        def sketchup_target_min_version
+          @sketchup_target_min_version
+        end
+
+        def sketchup_target_max_version
+          @sketchup_target_max_version
+        end
+
+      end # module ClassMethods
+
+      def self.included(mod)
+        mod.extend(ClassMethods)
+      end
+
+      def sketchup_target_min_version
+        self.class.sketchup_target_min_version
+      end
+
+      def sketchup_target_max_version
+        self.class.sketchup_target_max_version
+      end
+
+      def valid_for_target_sketchup_version?
+        # If no target version is configured, ignore this check.
+        return true unless sketchup_target_version?
+
+        # If no version is set - then it's valid for all known versions.
+        unless sketchup_target_min_version || sketchup_target_max_version
+          return true
+        end
+
+        # If there is a finite version range, check if the target SketchUp
+        # version is withing that.
+        if sketchup_target_min_version && sketchup_target_max_version
+          range = (sketchup_target_min_version..sketchup_target_max_version)
+          return range.include?(sketchup_target_version)
+        end
+
+        if sketchup_target_min_version
+          return sketchup_target_version >= sketchup_target_min_version
+        end
+
+        if sketchup_target_max_version
+          return sketchup_target_version <= sketchup_target_max_version
+        end
+
+        raise 'bug!' # Should not end up here.
+      end
+
+    end
+  end
+end