rubocop-sketchup 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fba3184334c70efb554cf67e75f076c52364e70e
+  data.tar.gz: f6e53f835f85a1a6a431901a0a4b9ee734a205df
+SHA512:
+  metadata.gz: e3f65b200bc51f212498cfd5fde5d311e3b0279f92c44832d60a5ceb2d54828bd423c0aa4e24abdc3abc8ccdd10d890d2df38cefb9c399cf8a486248b16d62fc
+  data.tar.gz: 6ed3c4b0f7203e628108d688a4ee5a11e2be2c40abb6e1d4e4dfd67e9c3464aeb5df893876aa4b288cdc0c7faca2f7e9dd8c516c833971382fc0cef87d20bf67

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'rake', '~> 10.0', require: false
+  gem 'rspec', '~> 3.4', require: false
+end

data/lib/rubocop-sketchup.rb

@@ -0,0 +1,12 @@
+require 'rubocop'
+require 'rubocop/sketchup/version'
+
+require 'rubocop/sketchup/namespace'
+require 'rubocop/sketchup/namespace_checker'
+require 'rubocop/sketchup/no_comment_disable'
+
+# Load all custom cops.
+pattern = File.join(__dir__, 'rubocop', 'sketchup', '**/*rb')
+Dir.glob(pattern) { |file|
+  require file
+}

data/lib/rubocop/sketchup/deprecations/operation_next_transparent.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupDeprecations
+      # Weak warning. (Question?)
+      class OperationNextTransparent < Cop
+        MSG = 'Third argument is deprecated.'.freeze
+        
+        def on_send(node)
+          _, method_name, *args = *node
+          return unless method_name == :start_operation
+          return if args.size < 3
+          argument = args[2]
+          next_transparent = argument.type == :true
+          add_offense(argument, :expression) if next_transparent
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/namespace.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchUp
+      class Namespace
+
+        attr_reader :namespace
+
+        SEPARATOR = '::'.freeze
+
+        # @param [String] namespace
+        def initialize(namespace)
+          @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?
+          parts.last == 'Object'
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/namespace_checker.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sketchup
+      module NamespaceChecker
+
+        include OnMethodDef
+
+        def on_class(node)
+          check_namespace(node)
+        end
+
+        def on_module(node)
+          check_namespace(node)
+        end
+
+        def on_method_def(node, method_name, _args, _body)
+          check_namespace(node)
+        end
+
+        # Constant assignment.
+        def on_casgn(node)
+          check_namespace(node)
+        end
+
+        def check_namespace(node)
+          add_offense(node, :name, nil, :error) if in_namespace?(node)
+        end
+
+        def in_namespace?(node)
+          namespace = SketchUp::Namespace.new(node.parent_module_name)
+          namespaces.include?(namespace.first)
+        end
+
+        def namespaces
+          raise NotImplementedError
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/no_comment_disable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    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/performance/operation_disable_ui.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupPerformance
+      # Weak warning. (Question?)
+      class OperationDisableUI < Cop
+        MSG = 'Operations should disable the UI for performance gain.'.freeze
+
+        def on_send(node)
+          _, method_name, *args = *node
+          return unless method_name == :start_operation
+          if args.size < 2
+            add_offense(node, :expression)
+            return
+          end
+          argument = args[1]
+          disable_ui = argument.children.first
+          return if disable_ui
+          add_offense(argument, :expression)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/performance/typename.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupPerformance
+      class Typename < 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, :expression)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupRequirements
+      class ApiNamespace < Cop
+
+        include 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/requirements/extension_namespace.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'rubocop/sketchup/requirements/api_namespace'
+require 'rubocop/sketchup/requirements/ruby_core_namespace'
+require 'rubocop/sketchup/requirements/ruby_stdlib_namespace'
+
+module RuboCop
+  module Cop
+    module SketchupRequirements
+      class ExtensionNamespace < Cop
+
+        include NoCommentDisable
+        include SketchUp
+
+        def on_class(node)
+          check_class_or_module(node)
+        end
+
+        def on_module(node)
+          check_class_or_module(node)
+        end
+
+        def check_class_or_module(node)
+          name = node.defined_module_name
+          parent = Namespace.new(node.parent_module_name)
+          # Don't want to process anything that aren't top level namespaces.
+          return unless parent.top_level?
+          check_namespace(node, parent.join(name))
+        end
+
+        # Class variables are normally frowned upon since they leak through all
+        # instances. However, in this case this is exactly what we want.
+        # The Cop picks up the first top level namespace it encounters and then
+        # keep track of whether it detects more top level namespaces.
+        @@namespace = nil
+        def check_namespace(node, namespace)
+          # Make sure the namespace isn't part of reserved namespaces that other
+          # cops are checking.
+          return if reserved?(namespace)
+          # Remember the first namespace encountered and log an offence if
+          # more top level namespaces are registered.
+          top = namespace.first
+          @@namespace ||= top
+          return if @@namespace == top
+          add_offense(node, :name, nil, :error)
+        end
+
+        def reserved?(namespace)
+          top = namespace.first
+          return true if RubyCoreNamespace::NAMESPACES.include?(top)
+          return true if RubyStdLibNamespace::NAMESPACES.include?(top)
+          return true if ApiNamespace::NAMESPACES.include?(top)
+          false
+        end
+
+        def message(node)
+          namespace = Namespace.new(node.defined_module_name).from_root
+          format('Use a single root namespace. (Found %s; Previously found %s)', namespace, @@namespace)
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/requirements/global_constants.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupRequirements
+      class GlobalConstants < Cop
+
+        include NoCommentDisable
+        include SketchUp
+
+        MSG = 'Do not introduce global constants.'.freeze
+
+        # Constant assignment.
+        def on_casgn(node)
+          namespace = Namespace.new(node.parent_module_name)
+          add_offense(node, :name, nil, :error) if namespace.top_level?
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/requirements/global_methods.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupRequirements
+      class GlobalMethods < Cop
+
+        include NoCommentDisable
+        include OnMethodDef
+        include SketchUp
+
+        MSG = 'Do not introduce global methods.'.freeze
+
+        # Reference: http://www.rubydoc.info/gems/rubocop/RuboCop/NodePattern
+        #
+        # Matchers for methods defined with this syntax:
+        #
+        # def Example.foo
+        # end
+        #
+        # def (Example::Foo).bar
+        # end
+
+        def_node_matcher :class_method?, <<-PATTERN
+          (defs
+            (const _ _) ...
+          )
+        PATTERN
+
+        def_node_matcher :class_method, <<-PATTERN
+          (defs
+            {
+              (const nil $_)
+              (const (const nil $_) ...)
+            }
+            ...
+          )
+        PATTERN
+
+        def on_method_def(node, method_name, _args, _body)
+          class_method_parent = class_method(node)
+          if class_method_parent
+            namespace = Namespace.new(class_method_parent.to_s)
+          else
+            namespace = Namespace.new(node.parent_module_name)
+          end
+          add_offense(node, :name, nil, :error) if namespace.top_level?
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/requirements/global_variables.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupRequirements
+      # This cops looks for uses of global variables.
+      # It does not report offenses for built-in global variables.
+      # Built-in global variables are allowed by default. Additionally
+      # users can allow additional variables via the AllowedVariables option.
+      #
+      # Note that backreferences like $1, $2, etc are not global variables.
+      class GlobalVariables < Cop
+        include NoCommentDisable
+        MSG = 'Do not introduce global variables.'.freeze
+
+        # predefined global variables their English aliases
+        # http://www.zenspider.com/Languages/Ruby/QuickRef.html
+        BUILT_IN_VARS = %w(
+          $: $LOAD_PATH
+          $" $LOADED_FEATURES
+          $0 $PROGRAM_NAME
+          $! $ERROR_INFO
+          $@ $ERROR_POSITION
+          $; $FS $FIELD_SEPARATOR
+          $, $OFS $OUTPUT_FIELD_SEPARATOR
+          $/ $RS $INPUT_RECORD_SEPARATOR
+          $\\ $ORS $OUTPUT_RECORD_SEPARATOR
+          $. $NR $INPUT_LINE_NUMBER
+          $_ $LAST_READ_LINE
+          $> $DEFAULT_OUTPUT
+          $< $DEFAULT_INPUT
+          $$ $PID $PROCESS_ID
+          $? $CHILD_STATUS
+          $~ $LAST_MATCH_INFO
+          $= $IGNORECASE
+          $* $ARGV
+          $& $MATCH
+          $` $PREMATCH
+          $' $POSTMATCH
+          $+ $LAST_PAREN_MATCH
+          $stdin $stdout $stderr
+          $DEBUG $FILENAME $VERBOSE $SAFE
+          $-0 $-a $-d $-F $-i $-I $-l $-p $-v $-w
+          $CLASSPATH $JRUBY_VERSION $JRUBY_REVISION $ENV_JAVA
+        ).map(&:to_sym)
+
+        def allowed_var?(global_var)
+          BUILT_IN_VARS.include?(global_var)
+        end
+
+        def on_gvar(node)
+          check(node)
+        end
+
+        def on_gvasgn(node)
+          check(node)
+        end
+
+        def check(node)
+          global_var, = *node
+
+          add_offense(node, :name, nil, :error) unless allowed_var?(global_var)
+        end
+      end
+    end
+  end
+end