rubocop-sketchup 0.6.0 → 0.7.0

data/lib/rubocop/sketchup/inject.rb

@@ -1,19 +1,19 @@
-# frozen_string_literal: true
-
-module RuboCop
-  # Ripped directly from rubocop-rspec.
-  module SketchUp
-    # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
-    # bit of our configuration.
-    module Inject
-      def self.defaults!
-        path = CONFIG_DEFAULT.to_s
-        hash = ConfigLoader.send(:load_yaml_configuration, path)
-        config = RuboCop::Config.new(hash, path)
-        puts "configuration from #{path}" if ConfigLoader.debug?
-        config = ConfigLoader.merge_with_default(config, path)
-        ConfigLoader.instance_variable_set(:@default_configuration, config)
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  # Ripped directly from rubocop-rspec.
+  module SketchUp
+    # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
+    # bit of our configuration.
+    module Inject
+      def self.defaults!
+        path = CONFIG_DEFAULT.to_s
+        hash = ConfigLoader.send(:load_yaml_configuration, path)
+        config = RuboCop::Config.new(hash, path)
+        puts "configuration from #{path}" if ConfigLoader.debug?
+        config = ConfigLoader.merge_with_default(config, path)
+        ConfigLoader.instance_variable_set(:@default_configuration, config)
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/namespace.rb

@@ -1,47 +1,47 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module SketchUp
-    class Namespace
-
-      attr_reader :namespace
-
-      SEPARATOR = '::'.freeze
-
-      # @param [String] namespace
-      def initialize(namespace)
-        raise TypeError unless namespace.is_a?(String)
-
-        @namespace = namespace
-      end
-
-      # Get the first component of a namespace relative to Object.
-      # May return 'Object' if the namespace is in the global namespace.
-      def first
-        parts.find { |name| name != 'Object' } || 'Object'
-      end
-
-      # Get a namespace string that is relative to Object.
-      def from_root
-        items = parts
-        items.shift if items.size > 1 && items.first == 'Object'
-        items.join(SEPARATOR)
-      end
-
-      def join(other)
-        self.class.new("#{@namespace}#{SEPARATOR}#{other}")
-      end
-
-      # Get the first component of a namespace relative to Object.
-      # May return 'Object' if the namespace is in the global namespace.
-      def parts
-        namespace.split(SEPARATOR)
-      end
-
-      def top_level?
-        %w[Kernel Object].include?(parts.first)
-      end
-
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module SketchUp
+    class Namespace
+
+      attr_reader :namespace
+
+      SEPARATOR = '::'.freeze
+
+      # @param [String] namespace
+      def initialize(namespace)
+        raise TypeError unless namespace.is_a?(String)
+
+        @namespace = namespace
+      end
+
+      # Get the first component of a namespace relative to Object.
+      # May return 'Object' if the namespace is in the global namespace.
+      def first
+        parts.find { |name| name != 'Object' } || 'Object'
+      end
+
+      # Get a namespace string that is relative to Object.
+      def from_root
+        items = parts
+        items.shift if items.size > 1 && items.first == 'Object'
+        items.join(SEPARATOR)
+      end
+
+      def join(other)
+        self.class.new("#{@namespace}#{SEPARATOR}#{other}")
+      end
+
+      # Get the first component of a namespace relative to Object.
+      # May return 'Object' if the namespace is in the global namespace.
+      def parts
+        namespace.split(SEPARATOR)
+      end
+
+      def top_level?
+        %w[Kernel Object].include?(parts.first)
+      end
+
+    end
+  end
+end

data/lib/rubocop/sketchup/namespace_checker.rb

@@ -1,46 +1,46 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module SketchUp
-    module NamespaceChecker
-
-      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 check_namespace(node)
-        return unless in_namespace?(node)
-
-        add_offense(node, location: :name, severity: :error)
-      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
+
+      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 check_namespace(node)
+        return unless in_namespace?(node)
+
+        add_offense(node, location: :name, severity: :error)
+      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

@@ -0,0 +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

data/lib/rubocop/sketchup/sketchup_version.rb

@@ -1,87 +1,117 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module SketchUp
-    class SketchUpVersion
-
-      include Comparable
-
-      attr_reader :version, :maintenance
-
-      class InvalidVersion < StandardError; end
-
-      def initialize(version)
-        @version, @maintenance = parse_version(version)
-      end
-
-      def <=>(other)
-        if version == other.version
-          maintenance <=> other.maintenance
-        else
-          version <=> other.version
-        end
-      end
-
-      def to_s
-        string_version = version < 2013 ? version.to_f : version.to_i
-        if maintenance > 0
-          "SketchUp #{string_version} M#{maintenance}"
-        else
-          "SketchUp #{string_version}"
-        end
-      end
-
-      private
-
-      VERSION_NUMBER_REGEX = /^(?:SketchUp )?([0-9.]+)(?: M(\d+))?$/.freeze
-
-      # This list is compiled from the list of versions reported by YARD when
-      # running the `versions` template;
-      #
-      #   yardoc -t versions -f text
-      #
-      # TODO(thomthom): Push the version template to the API stubs repository.
-      VALID_VERSIONS = [
-        [2018, 0],
-        [2017, 0],
-        [2016, 1],
-        [2016, 0],
-        [2015, 0],
-        [2014, 0],
-        [2013, 0],
-        [8.0, 2],
-        [8.0, 1],
-        [8.0, 0],
-        [7.1, 1],
-        [7.1, 0],
-        [7.0, 1],
-        [7.0, 0],
-        [6.0, 0],
-      ].freeze
-
-      def parse_version(version)
-        v = 0
-        m = 0
-        if version.is_a?(String)
-          # Treat all LayOut versions as SketchUp versions for now.
-          normalised_version = version.gsub('LayOut', 'SketchUp')
-          result = normalised_version.match(VERSION_NUMBER_REGEX)
-          if result
-            v = result.captures[0].to_f
-            m = (result.captures[1] || '0').to_i
-          end
-        elsif version.is_a?(Numeric)
-          v = version
-          m = 0
-        end
-        version_parts = [v, m]
-        unless VALID_VERSIONS.include?(version_parts)
-          raise InvalidVersion, "#{version} is not a valid SketchUp version"
-        end
-
-        version_parts
-      end
-
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module SketchUp
+    class SketchUpVersion
+
+      include Comparable
+
+      attr_reader :version, :maintenance
+
+      class InvalidVersion < StandardError; end
+
+      # @overload initialize(version_string)
+      #   @param [String] version_string
+      #
+      # @overload initialize(version, maintenance)
+      #   @param [Integer, Float] version
+      #   @param [Integer] maintenance
+      def initialize(*args)
+        if args.size == 1
+          @version, @maintenance = parse_version(args.first)
+        elsif args.size == 2
+          validate(args)
+          @version, @maintenance = args
+        else
+          raise ArgumentError, "expected 1..2 arguments, got #{args.size}"
+        end
+      end
+
+      # @return [SketchUpVersion, nil]
+      def succ
+        version_parts = [@version, @maintenance]
+        index = VALID_VERSIONS.index(version_parts)
+        next_version_parts = VALID_VERSIONS[index + 1]
+        return nil if next_version_parts.nil?
+
+        self.class.new(*next_version_parts)
+      end
+
+      def <=>(other)
+        if version == other.version
+          maintenance <=> other.maintenance
+        else
+          version <=> other.version
+        end
+      end
+
+      # @return [String]
+      def to_s
+        string_version = version < 2013 ? version.to_f : version.to_i
+        if maintenance > 0
+          "SketchUp #{string_version} M#{maintenance}"
+        else
+          "SketchUp #{string_version}"
+        end
+      end
+
+      private
+
+      VERSION_NUMBER_REGEX = /^(?:SketchUp )?([0-9.]+)(?: M(\d+))?$/.freeze
+
+      # This list is compiled from the list of versions reported by YARD when
+      # running the `versions` template;
+      #
+      #   yardoc -t versions -f text
+      #
+      # TODO(thomthom): Push the version template to the API stubs repository.
+      VALID_VERSIONS = [
+        [2018, 0],
+        [2017, 0],
+        [2016, 1],
+        [2016, 0],
+        [2015, 0],
+        [2014, 0],
+        [2013, 0],
+        [8.0, 2],
+        [8.0, 1],
+        [8.0, 0],
+        [7.1, 1],
+        [7.1, 0],
+        [7.0, 1],
+        [7.0, 0],
+        [6.0, 0],
+      ].reverse.freeze
+
+      # @param [String] version
+      # @return [Array(Float, Integer)]
+      def parse_version(version)
+        v = 0
+        m = 0
+        if version.is_a?(String)
+          # Treat all LayOut versions as SketchUp versions for now.
+          normalized_version = version.gsub('LayOut', 'SketchUp')
+          result = normalized_version.match(VERSION_NUMBER_REGEX)
+          if result
+            v = result.captures[0].to_f
+            m = (result.captures[1] || '0').to_i
+          end
+        elsif version.is_a?(Numeric)
+          v = version
+          m = 0
+        end
+        validate([v, m])
+      end
+
+      # @param [Array(Float, Integer)] version_parts
+      def validate(version_parts)
+        unless VALID_VERSIONS.include?(version_parts)
+          raise InvalidVersion, "#{version} is not a valid SketchUp version"
+        end
+
+        version_parts
+      end
+
+    end
+  end
+end