rubocop-sketchup 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 75dbf007836345a888890dbbc327ca14b599dc8e
-  data.tar.gz: 1198e5a2ac5357d3d84f467ce886ec6128ab18fd
+  metadata.gz: aaaa92ae5a979fc2fbfb37d4e809e3f747337029
+  data.tar.gz: 66216c4e9a5004d7e5a70cda380a257df65b68cf
 SHA512:
-  metadata.gz: 8dc952cdc1b5c378ee3a1e806a7e3dbe8ec0547c4f26637d48d52adb5ad8aad6c7ec578a01f11361ab19d6c3f6c773f07174ffc55a2b8971cfc001889e15cdf3
-  data.tar.gz: 91a8f974ab4cf849485559ab4c7f3cb234f6aecb2dc3fcfbaae1abc7bdd67a8b1b89893405a5aa8cab49412f7cab2cd9666416a0e8a2153d6689e2c3b0e1d7ab
+  metadata.gz: 0db51625b9ca4b001e899e5cda805ef99817badf8b710d8310204b83b86fd81b1b58519e7ebdcdf46222574c2559b93b0b9727343907b367efebaacebd084fe2
+  data.tar.gz: 6dc1219506f59c2abb7e0246715b35304acf14aa62d165be5aa2f7b5c2a696737537f8485186ac694682ef5e09797b96fee0b47e74a7cd5e24db06c500a861a8

data/config/default.yml

@@ -0,0 +1,95 @@
+---
+SketchupPerformance/SelectionBulkChanges:
+  Description: >-
+                 Avoid modifying the selection set within loops. It's much
+                 faster to change the selection in bulk.
+  Enabled: true
+
+SketchupPerformance/OpenSSL:
+  Description: >-
+                 Avoid using Ruby's OpenSSL within SketchUp. A flaw in how it
+                 obtain random bits under Windows can severely affect
+                 performance, freezing SketchUp for many minutes.
+                 This also affects SecureRandom and anything else
+                 that depend on OpenSSL. Net::HTTP is affected if connecting via
+                 HTTPS. Connecting via plain HTTP is unaffected.
+  Enabled: true
+
+SketchupRequirements/Exit:
+  Description: Exit attempts to kill the Ruby interpreter.
+  Enabled: true
+
+SketchupRequirements/FileStructure:
+  Description: >-
+                 Check that the extension conform to expected file structure
+                 with a single root .rb file and a support folder with matching
+                 name.
+  Enabled: true
+
+SketchupRequirements/LanguageHandlerGlobals:
+  Description: >-
+                 Avoid using globals in general, but  especially these which are
+                 known to be in use by other extensions made by SketchUp.
+                 They are still in use due to compatibility reasons.
+  Enabled: true
+
+SketchupRequirements/MinimalRegistration:
+  Description: >-
+                 Don't load extension files in the root file registering the
+                 extension. Extensions should not load additional files when
+                 it's disabled.
+  Enabled: true
+
+SketchupRequirements/RegisterExtension:
+  Description: >-
+                 Always register extensions to load by default. Otherwise it
+                 might confuse users to think the extension isn't working.
+  Enabled: true
+
+SketchupRequirements/ShippedExtensionsNamespace:
+  Description: ShippedExtensionsNamespace
+  Enabled: true
+
+SketchupRequirements/SketchupExtension:
+  Description: >-
+                 Register a single instance of SketchupExtension per extension.
+                 This should be done by the root .rb file in the extension
+                 package.
+  Enabled: true
+
+SketchupSuggestions/FileEncoding:
+  Description: >-
+                 When using __FILE__ and __dir__, beware that Ruby doesn't apply
+                 the correct encoding to the strings under Windows. When they
+                 contain non-english characters it will lead to exceptions being
+                 raised when the strings are used. Force encoding to work around
+                 this.
+  Enabled: true
+
+SketchupSuggestions/SketchupExtension:
+  Description: Check that extension registers a SketchupExtension object.
+  Enabled: true
+  SourcePath: src
+
+SketchupSuggestions/DynamicComponentInternals:
+  Description: >-
+                 Avoid relying on internal logic of Dynamic Components. It's
+                 behavior might change between versions.
+  Enabled: true
+
+SketchupSuggestions/OperationName:
+  Description: Check that operation names are human friendly and consistent with SketchUp.
+  Enabled: true
+  Max: 25
+
+SketchupSuggestions/SketchupFindSupportFile:
+  Description: >-
+                 Avoid Sketchup.find_support_file to find your extension's files.
+                 Extensions might be installed outside the SketchUp Plugins folder.
+                 Use __FILE__ and __dir__ to locate your files relative to the
+                 executing file.
+  Enabled: true
+
+SketchupSuggestions/SketchupRequire:
+  Description: Omit file extensions when using Sketchup.require to allow encrypted files to be loaded.
+  Enabled: true

data/lib/rubocop-sketchup.rb

@@ -1,10 +1,15 @@
 require 'rubocop'
+require 'rubocop/sketchup'
 require 'rubocop/sketchup/version'
+require 'rubocop/sketchup/inject'
 
+require 'rubocop/sketchup/extension_project'
 require 'rubocop/sketchup/namespace'
 require 'rubocop/sketchup/namespace_checker'
 require 'rubocop/sketchup/no_comment_disable'
 
+RuboCop::SketchUp::Inject.defaults!
+
 # Load all custom cops.
 pattern = File.join(__dir__, 'rubocop', 'sketchup', '**/*rb')
 Dir.glob(pattern) { |file|

data/lib/rubocop/sketchup.rb

@@ -0,0 +1,12 @@
+require 'pathname'
+
+module RuboCop
+  # RuboCop SketchUp project namespace
+  module SketchUp
+    PROJECT_ROOT   = Pathname.new(__dir__).parent.parent.expand_path.freeze
+    CONFIG_DEFAULT = PROJECT_ROOT.join('config', 'default.yml').freeze
+    CONFIG         = YAML.safe_load(CONFIG_DEFAULT.read).freeze
+
+    private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
+  end
+end

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

@@ -6,14 +6,14 @@ module RuboCop
       # 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
+          add_offense(argument, location: :expression) if next_transparent
         end
       end
     end

data/lib/rubocop/sketchup/extension_project.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module RuboCop
+  module Cop
+    module Sketchup
+      module ExtensionProject
+
+        # @return [Pathname]
+        def config_path
+          path = config.instance_variable_get(:@loaded_path)
+          if path
+            Pathname.new(path).expand_path.dirname
+          else
+            Pathname.new(Dir.pwd).expand_path
+          end
+        end
+
+        # @return [Pathname]
+        def relative_source_path
+          Pathname.new(cop_config['SourcePath'] || 'src')
+        end
+
+        # @return [Pathname]
+        def source_path
+          config_path.join(relative_source_path)
+        end
+
+        # @param [RuboCop::ProcessedSource] processed_source
+        def path_relative_to_source(processed_source)
+          source_filename = processed_source.buffer.name
+          rel_path = config.path_relative_to_config(source_filename)
+          path = Pathname.new(rel_path).expand_path
+          path.relative_path_from(source_path)
+        end
+
+        # @param [RuboCop::ProcessedSource] processed_source
+        def root_file?(processed_source)
+          filename = path_relative_to_source(processed_source)
+          filename.extname.downcase == '.rb' &&
+            filename.parent.to_s == '.'
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/inject.rb

@@ -0,0 +1,17 @@
+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 = 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_checker.rb

@@ -5,8 +5,6 @@ module RuboCop
     module Sketchup
       module NamespaceChecker
 
-        include OnMethodDef
-
         def on_class(node)
           check_namespace(node)
         end
@@ -15,9 +13,10 @@ module RuboCop
           check_namespace(node)
         end
 
-        def on_method_def(node, method_name, _args, _body)
+        def on_def(node)
           check_namespace(node)
         end
+        alias on_defs on_def
 
         # Constant assignment.
         def on_casgn(node)
@@ -25,7 +24,7 @@ module RuboCop
         end
 
         def check_namespace(node)
-          add_offense(node, :name, nil, :error) if in_namespace?(node)
+          add_offense(node, location:  :name, severity: :error) if in_namespace?(node)
         end
 
         def in_namespace?(node)

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupPerformance
+      # There are performance issue with the OpenSSL library that Ruby ship. In
+      # a clean SU session, default model there is a small delay observed in the
+      # Windows version of SU.
+      #
+      # But with a larger model loaded, or session that have had larger files
+      # loaded the lag will be minutes.
+      #
+      # `SecureRandom` is  also affected by this, as it uses OpenSSL to seed.
+      #
+      # It also affects Net::HTTP if making HTTPS connections.
+      class OpenSSL < Cop
+
+        MSG = 'Avoid use of OpenSSL within SketchUp due to severe performance issues.'.freeze
+
+        # http://www.rubydoc.info/gems/rubocop/RuboCop/NodePattern
+        # https://rubocop.readthedocs.io/en/latest/node_pattern/
+        def_node_matcher :require, <<-PATTERN
+          (send nil? :require
+            (str $_)
+          )
+        PATTERN
+
+        OPEN_SSL_USAGE = %w[openssl securerandom net/https net/http]
+
+        def on_send(node)
+          filename = require(node)
+          return if filename.nil?
+          return unless OPEN_SSL_USAGE.include?(filename.downcase)
+          add_offense(node, location: :expression)
+        end
+      end
+    end
+  end
+end

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

@@ -11,13 +11,13 @@ module RuboCop
           _, method_name, *args = *node
           return unless method_name == :start_operation
           if args.size < 2
-            add_offense(node, :expression)
+            add_offense(node, location: :expression)
             return
           end
           argument = args[1]
-          disable_ui = argument.children.first
+          disable_ui = argument.truthy_literal?
           return if disable_ui
-          add_offense(argument, :expression)
+          add_offense(argument, location: :expression)
         end
       end
     end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupPerformance
+      # Avoid modifying the selection set within loops. It's much faster to
+      # change the selection in bulk.
+      #
+      # @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 < Cop
+        MSG = 'Avoid modifying selecting 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: :expression)
+        end
+      end
+    end
+  end
+end

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

@@ -11,7 +11,7 @@ module RuboCop
           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)
+          add_offense(node, location: :expression)
         end
       end
     end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupRequirements
+      # Don't attempt to kill the Ruby interpreter by calling exit or exit!.
+      class Exit < Cop
+
+        include NoCommentDisable
+
+        MSG = 'Exit attempts to kill the Ruby interpreter.'.freeze
+
+        # Reference: http://rubocop.readthedocs.io/en/latest/development/
+        def_node_matcher :exit?, <<-PATTERN
+          (send nil? {:exit :exit!})
+        PATTERN
+
+        def on_send(node)
+          add_offense(node, location: :expression) if exit?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -42,7 +42,7 @@ module RuboCop
           top = namespace.first
           @@namespace ||= top
           return if @@namespace == top
-          add_offense(node, :name, nil, :error)
+          add_offense(node, location: :name, severity: :error)
         end
 
         def reserved?(namespace)

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupRequirements
+      # Check that the extension conform to expected file structure with a
+      # single root .rb file and a support folder with matching name.
+      class FileStructure < Cop
+
+        include Sketchup::ExtensionProject
+        include NoCommentDisable
+
+        IGNORED_DIRECTORIES = %w[
+          __MACOSX
+        ].freeze
+
+        def investigate(processed_source)
+          return if already_run?
+
+          # Using range similar to RuboCop::Cop::Naming::Filename (file_name.rb)
+          range = source_range(processed_source.buffer, 1, 0)
+
+          # Find all root Ruby files in the source directory.
+          pattern = "#{source_path}/*.rb"
+          root_ruby_files = Dir.glob(pattern)
+
+          # Ensure there is only one root Ruby file.
+          if root_ruby_files.size != 1
+            msg = "Extensions must have exactly one root Ruby (.rb) file. Found: %d"
+            add_offense(nil, location: range, message: format(msg, root_ruby_files.size))
+            return
+          end
+
+          # Find the root file and collect the sub-directories.
+          root_file = root_ruby_files.first
+          extension_basename = File.basename(root_file, '.*')
+          sub_folders = source_path.children.select { |c| c.directory? }
+          sub_folders.reject! { |folder|
+            IGNORED_DIRECTORIES.include?(folder.basename.to_s)
+          }
+
+          # Ensure there is only one sub-directory.
+          if sub_folders.size != 1
+            msg = "Extensions must have exactly one support directory. Found %d"
+            add_offense(nil, location: range, message: format(msg, sub_folders.size))
+            return
+          end
+
+          # Ensure support directory's name match the root Ruby file.
+          support_directory = sub_folders.first
+          unless support_directory.basename.to_s == extension_basename
+            msg = 'Extensions must have a support directory matching the name of the root Ruby file. Expected %s, found %s'
+            msg = format(msg, extension_basename, support_directory.basename)
+            add_offense(nil, location: range, message: msg)
+          end
+        end
+
+        private
+
+        @@already_run = false
+
+        def already_run?
+          return true if @@already_run
+          @@already_run = true
+          false
+        end
+
+        def self.reset
+          @@already_run = false
+        end
+
+      end
+    end
+  end
+end

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

@@ -10,10 +10,17 @@ module RuboCop
 
         MSG = 'Do not introduce global constants.'.freeze
 
+        def_node_matcher :namespaced_constant?, <<-PATTERN
+          (casgn
+            (const _ _) ...
+          )
+        PATTERN
+
         # Constant assignment.
         def on_casgn(node)
+          return if namespaced_constant?(node)
           namespace = Namespace.new(node.parent_module_name)
-          add_offense(node, :name, nil, :error) if namespace.top_level?
+          add_offense(node, location: :name, severity: :error) if namespace.top_level?
         end
 
       end

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

@@ -6,7 +6,6 @@ module RuboCop
       class GlobalMethods < Cop
 
         include NoCommentDisable
-        include OnMethodDef
         include SketchUp
 
         MSG = 'Do not introduce global methods.'.freeze
@@ -30,16 +29,16 @@ module RuboCop
         def_node_matcher :class_method, <<-PATTERN
           (defs
             {
-              (const nil $_)
-              (const (const nil $_) ...)
+              (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
+        def on_def(node)
+          if class_method?(node)
+            class_method_parent = class_method(node)
             namespace = Namespace.new(class_method_parent.to_s)
           else
             # If a method is defined inside a block then parent_module_name
@@ -47,8 +46,9 @@ module RuboCop
             return if node.parent_module_name.nil?
             namespace = Namespace.new(node.parent_module_name)
           end
-          add_offense(node, :name, nil, :error) if namespace.top_level?
+          add_offense(node, location: :name, severity: :error) if namespace.top_level?
         end
+        alias on_defs on_def
 
       end
     end

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

@@ -44,8 +44,15 @@ module RuboCop
           $CLASSPATH $JRUBY_VERSION $JRUBY_REVISION $ENV_JAVA
         ).map(&:to_sym)
 
+        # TODO: This should probably be read only.
+        SKETCHUP_VARS = %w(
+          $loaded_files
+        ).map(&:to_sym)
+
+        ALLOWED_VARS = BUILT_IN_VARS | SKETCHUP_VARS
+
         def allowed_var?(global_var)
-          BUILT_IN_VARS.include?(global_var)
+          ALLOWED_VARS.include?(global_var)
         end
 
         def on_gvar(node)
@@ -59,7 +66,7 @@ module RuboCop
         def check(node)
           global_var, = *node
 
-          add_offense(node, :name, nil, :error) unless allowed_var?(global_var)
+          add_offense(node, location: :name, severity: :error) unless allowed_var?(global_var)
         end
       end
     end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupRequirements
+      # Avoid using globals in general, but  especially these which are known to
+      # be in use by other extensions made by SketchUp.
+      # They are still in use due to compatibility reasons.
+      class LanguageHandlerGlobals < Cop
+
+        MSG = "Avoid globals in general, but especially these which are known to be in use.".freeze
+
+        LH_GLOBALS = %i[
+          $dc_strings
+          $devl_strings
+          $exStrings
+          $fs_strings
+          $make_pano_string
+          $oceanStrings
+          $sn_strings
+          $ssf_strings
+          $suStrings
+          $tStrings
+          $unitsStrings
+          $uStrings
+          $wt_strings
+        ]
+
+        def hl_global_var?(global_var)
+          LH_GLOBALS.include?(global_var)
+        end
+
+        def on_gvasgn(node)
+          global_var, = *node
+          return unless hl_global_var?(global_var)
+          add_offense(node, location: :name, severity: :error)
+        end
+
+      end
+    end
+  end
+end

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

@@ -64,14 +64,14 @@ module RuboCop
         def on_gvasgn(node)
           global_var, = *node
 
-          add_offense(node, :name, nil, :error) if load_path?(global_var)
+          add_offense(node, location: :name, severity: :error) if load_path?(global_var)
         end
 
         def on_send(node)
           method_name = load_path_mutator?(node)
           return unless method_name
 
-          add_offense(node, :expression, nil, :error)
+          add_offense(node, location: :expression, severity: :error)
         end
 
       end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module RuboCop
+  module Cop
+    module SketchupRequirements
+      # Don't load extension files in the root file registering the extension.
+      # Extensions should not load additional files when it's disabled.
+      class MinimalRegistration < Cop
+
+        include Sketchup::ExtensionProject
+        include NoCommentDisable
+
+        MSG = "Don't load extension files in the root file registering the extension.".freeze
+
+        # Reference: http://rubocop.readthedocs.io/en/latest/node_pattern/
+        def_node_matcher :require_filename, <<-PATTERN
+          (:send
+            {(const nil? :Sketchup) nil?} :require
+            (str $_))
+        PATTERN
+
+        def investigate(processed_source)
+          if root_file?(processed_source)
+            filename = processed_source.buffer.name
+            @extension_basename = File.basename(filename, '.*')
+          end
+        end
+
+        def extension_file?(filename)
+          return false unless filename.include?('/')
+          first_directory = filename.split('/').first
+          @extension_basename.casecmp(first_directory) == 0
+        end
+
+        def on_send(node)
+          return unless @extension_basename
+          filename = require_filename(node)
+          return if filename.nil?
+          return unless extension_file?(filename)
+          add_offense(node)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupRequirements
+      # Always register extensions to load by default. Otherwise it might
+      # confuse users to think the extension isn't working.
+      class RegisterExtension < Cop
+
+        include NoCommentDisable
+
+        MSG = 'Always register extensions to load by default.'.freeze
+
+        def_node_search :sketchup_register_extension, <<-PATTERN
+          (:send
+            (const nil? :Sketchup) :register_extension
+            $...)
+        PATTERN
+
+        def on_send(node)
+          sketchup_register_extension(node).each { |args|
+            if args.size < 2
+              add_offense(node)
+              next
+            end
+            load_arg = args[1]
+            next if load_arg.true_type?
+            add_offense(load_arg)
+          }
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupRequirements
+      # Don't modify SketchUp's shipped extensions.
+      class ShippedExtensionsNamespace < Cop
+
+        include NoCommentDisable
+        include Sketchup::NamespaceChecker
+
+        MSG = 'Do not modify shipped extensions.'.freeze
+
+        # We check only against the top level namespaces. The core define more
+        # objects, but they are under one of the top level namespaces listed.
+
+        NAMESPACES_ADVANCED_CAMERA_TOOLS = %w(
+          ACTUtil
+          CameraAppObserver
+          CameraEntityObserver
+          CameraFrameChangeObserver
+          CameraRep
+          CameraToolModelObserver
+          CameraToolPagesObserver
+          CameraToolViewObserver
+          FilmCameraTool
+          FSCameraData
+          FSGeomUtils
+          FSValidate
+          PageNameChangeObserver
+        ).freeze
+
+        NAMESPACES_DYNAMIC_COMPONENTS = %w(
+          DCConverter
+          DCDownloader
+          DCFunctionsV1
+          DCInteractTool
+          DCObservers
+          DCProgressBar
+          DynamicComponents
+          DynamicComponentsV1
+        ).freeze
+
+        NAMESPACES_TRIMBLE_CONNECT = %w(
+          Trimble
+        ).freeze
+
+        NAMESPACES = (
+          NAMESPACES_ADVANCED_CAMERA_TOOLS |
+          NAMESPACES_DYNAMIC_COMPONENTS |
+          NAMESPACES_TRIMBLE_CONNECT
+        ).freeze
+
+        def namespaces
+          NAMESPACES
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupRequirements
+      # Register a single instance of SketchupExtension per extension.
+      # This should be done by the root .rb file in the extension package.
+      class SketchupExtension < Cop
+
+        include Sketchup::ExtensionProject
+        include NoCommentDisable
+
+        MSG = 'Create and register one SketchupExtension instance per extension.'.freeze
+        MSG_CREATE_ONE = 'Create only SketchupExtension instance per extension.'.freeze
+        MSG_CREATE_MISSING = 'SketchupExtension.new not found.'.freeze
+        MSG_REGISTER_ONE = 'Only register one SketchupExtension instance per extension.'.freeze
+        MSG_REGISTER_MISSING = 'Registration of SketchupExtension not found. Expected %s'.freeze
+
+        # Reference: http://rubocop.readthedocs.io/en/latest/node_pattern/
+        def_node_search :sketchup_extension_new, <<-PATTERN
+          ({:lvasgn :ivasgn :cvasgn :gvasgn :casgn} ...
+            (:send
+              (:const nil? :SketchupExtension) :new
+              _
+              _))
+        PATTERN
+
+        def_node_search :sketchup_register_extension, <<-PATTERN
+          (:send
+            (const nil? :Sketchup) :register_extension
+            {({:lvar :ivar :cvar :gvar} $_)(const nil? $_)}
+            _)
+        PATTERN
+
+        def investigate(processed_source)
+          return unless root_file?(processed_source)
+
+          source_node = processed_source.ast
+          # Using range similar to RuboCop::Cop::Naming::Filename (file_name.rb)
+          range = source_range(processed_source.buffer, 1, 0)
+
+          # Look for SketchupExtension.new.
+          extension_nodes = sketchup_extension_new(source_node).to_a
+          if extension_nodes.size > 1
+            add_offense(nil, location: range, message: MSG_CREATE_ONE)
+            return
+          end
+          extension_node = extension_nodes.first
+          if extension_node.nil?
+            add_offense(nil, location: range, message: MSG_CREATE_MISSING)
+            return
+          end
+
+          # Find the name of the value SketchupExtension.new was assigned to.
+          if extension_node.casgn_type?
+            extension_var = extension_node.to_a[1]
+          else
+            extension_var = extension_node.to_a[0]
+          end
+
+          # Look for Sketchup.register and make sure it register the extension
+          # object detected earlier.
+          registered_vars = sketchup_register_extension(source_node).to_a
+          # TODO: The offences here should probably highlight the line where
+          #       Sketchup.register_extension is.
+          if registered_vars.size > 1
+            add_offense(nil, location: range, message: MSG_REGISTER_ONE)
+            return
+          end
+          registered_var = sketchup_register_extension(source_node).first
+          unless registered_var == extension_var
+            msg = MSG_REGISTER_MISSING % extension_var.to_s
+            add_offense(nil, location: range, message: msg)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/suggestions/dc_internals.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupSuggestions
+      # Tapping into the internals of Dynamic Components is risky. It could
+      # change at any time.
+      class DynamicComponentInternals < Cop
+
+        MSG = "Avoid relying on internal logic of Dynamic Components.".freeze
+
+        DC_GLOBALS = %i[
+          $dc_strings
+          $dc_extension
+          $dc_CONFIGURATOR_NAME
+          $dc_REPORTER_NAME
+          $dc_MANAGER_NAME
+          $dc_observers
+        ]
+
+        def dc_global_var?(global_var)
+          DC_GLOBALS.include?(global_var)
+        end
+
+        def on_gvar(node)
+          check(node)
+        end
+
+        def on_gvasgn(node)
+          check(node)
+        end
+
+        def check(node)
+          global_var, = *node
+          return unless dc_global_var?(global_var)
+          add_offense(node, location: :name, severity: :error)
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/suggestions/file_encoding.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupSuggestions
+      # When using __FILE__ and __dir__, beware that Ruby doesn't apply the
+      # correct encoding to the strings under Windows. When they contain
+      # non-english characters it will lead to exceptions being raised when the
+      # strings are used. Force encoding to work around this.
+      #
+      # @example Might fail
+      #   basename = File.basename(__FILE__, '.*')
+      #
+      # @example Workaround
+      #   file = __FILE__.dup
+      #   file.force_encoding('UTF-8') if file.respond_to?(:force_encoding)
+      #   basename = File.basename(file, '.*')
+      class FileEncoding < Cop
+
+        MSG = 'Beware encoding bug with __FILE__ and __dir__.'.freeze
+
+        def_node_matcher :file_loaded?, <<-PATTERN
+          (send nil? {:file_loaded? :file_loaded} ...)
+        PATTERN
+
+        def_node_matcher :magic_dir?, <<-PATTERN
+          (send nil? :__dir__)
+        PATTERN
+
+        def magic_file?(node)
+          node.respond_to?(:str_type?) &&
+            node.str_type? &&
+            node.source_range.is?('__FILE__')
+        end
+
+        def magic_file_or_dir?(node)
+          magic_file?(node) || magic_dir?(node)
+        end
+
+        def on_send(node)
+          return if file_loaded?(node)
+          return if node.arguments.none?(&method(:magic_file_or_dir?))
+          add_offense(node, location: :expression)
+        end
+
+
+        def_node_search :force_encoding, <<-PATTERN
+          (send
+            (_ $_)
+            :force_encoding ...)
+        PATTERN
+
+        def on_assign(node)
+          lhs, value = *node
+          return unless magic_file_or_dir?(value)
+          # After assigning __FILE__ or __dir_ to a variable, check the parent
+          # scope to whether .force_encoding is called on the variable.
+          return if node.parent.nil?
+          encoded = force_encoding(node.parent).to_a
+          return if encoded.include?(lhs)
+          add_offense(node)
+        end
+
+        # TODO: Review this list of aliases.
+        alias on_lvasgn   on_assign
+        alias on_masgn    on_assign
+        alias on_casgn    on_assign
+        alias on_ivasgn   on_assign
+        alias on_cvasgn   on_assign
+        alias on_gvasgn   on_assign
+        alias on_or_asgn  on_assign
+        alias on_and_asgn on_assign
+        alias on_op_asgn  on_assign
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/suggestions/model_entities.rb

@@ -18,14 +18,14 @@ module RuboCop
         def_node_matcher :model_entities?, <<-PATTERN
           (send
             {
-              (send (const nil :Sketchup) :active_model)
+              (send (const nil? :Sketchup) :active_model)
               (lvar {:model :mod})
             }
             :entities)
         PATTERN
 
         def on_send(node)
-          add_offense(node, :expression) if model_entities?(node)
+          add_offense(node, location: :expression) if model_entities?(node)
         end
       end
     end

data/lib/rubocop/sketchup/suggestions/operation_name.rb

@@ -4,28 +4,80 @@ module RuboCop
   module Cop
     module SketchupSuggestions
       class OperationName < Cop
+
         MSG = 'Operation name should be a short capitalized description.'.freeze
+        MSG_MAX = "Operation names should not be short and concise. [%d/%d]".freeze
 
         def on_send(node)
           _, method_name, *args = *node
           return unless method_name == :start_operation
-          operation_name = args.first.children.first
-          return if acceptable_operation_name?(operation_name)
-          add_offense(args.first, :expression)
+          return unless args.first.str_type?
+          operation_name = args.first.str_content
+          # We can only inspect string literals.
+          return unless operation_name.is_a?(String)
+          # Check the format of the operation name.
+          unless acceptable_operation_name?(operation_name)
+            msg = %[#{MSG} Expected: "#{titleize(operation_name)}"]
+            add_offense(args.first, location: :expression, message: msg)
+          end
+          # Check the length of the operation name.
+          unless operation_name.size <= max_operation_name_length
+            message = format(MSG_MAX, operation_name.size, max_operation_name_length)
+            add_offense(args.first,
+              location: excess_range(args.first, operation_name),
+              message: message)
+          end
+          # Ensure operation name is not empty.
+          if operation_name.empty?
+            msg = 'Operation names should not be empty.'
+            add_offense(args.first, location: :expression, message: msg)
+          end
+        end
+
+        private
+
+        def excess_range(node, operation_name)
+          string_start = node.source.index(operation_name)
+          range = node.loc.expression
+          if string_start
+            excess_start = range.begin_pos + string_start + max_operation_name_length
+            excess_end = range.begin_pos + string_start + operation_name.size
+            range_between(excess_start, excess_end)
+          else
+            range_between(range.begin_pos, range.end_pos)
+          end
         end
 
         def acceptable_operation_name?(name)
-          # Capitalization, no programmer name, no punctuation
-          return false if name.size > 25 # TODO: Separate Cop?
+          # Capitalization, no programmer name, no punctuation.
           return false if name.end_with?('.')
           return false if titleize(name) != name
           true
         end
 
-        # TODO(thomthom): Might need to ignore words like 'and/or'
+        def max_operation_name_length
+          length = cop_config['Max'] || 25
+          return length if length.is_a?(Integer) && length > 0
+
+          raise 'Max needs to be a positive integer!'
+        end
+
+        TITLEIZE_EXCLUDE = %w[
+          by for from in of to
+          and or if
+        ]
+
         def titleize(string)
-          string.split.map(&:capitalize).join(' ')
+          words = string.split.map { |word|
+            if TITLEIZE_EXCLUDE.include?(word)
+              word
+            else
+              word.capitalize
+            end
+          }
+          words.join(' ')
         end
+
       end
     end
   end

data/lib/rubocop/sketchup/suggestions/sketchup_find_support_file.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupSuggestions
+      # Avoid Sketchup.find_support_file to find your extension's files.
+      class SketchupFindSupportFile < Cop
+
+        MSG = "Don't hard code file extensions with Sketchup.require".freeze
+
+        # http://www.rubydoc.info/gems/rubocop/RuboCop/NodePattern
+        # https://rubocop.readthedocs.io/en/latest/node_pattern/
+        def_node_matcher :sketchup_find_support_file?, <<-PATTERN
+          (send
+            (const nil? :Sketchup) :find_support_file
+            ...
+          )
+        PATTERN
+
+        def on_send(node)
+          return unless sketchup_find_support_file?(node)
+          add_offense(node, location: :expression)
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/suggestions/sketchup_require.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupSuggestions
+      # Omit file extensions when using Sketchup.require to allow encrypted
+      # files to be loaded.
+      class SketchupRequire < Cop
+
+        MSG = "Don't hard code file extensions with Sketchup.require".freeze
+
+        # http://www.rubydoc.info/gems/rubocop/RuboCop/NodePattern
+        # https://rubocop.readthedocs.io/en/latest/node_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 on_send(node)
+          return unless sketchup_require?(node)
+          filename = sketchup_require(node)
+          add_offense(node, location: :expression) unless valid_filename?(filename)
+        end
+
+        private
+
+        def valid_filename?(filename)
+          File.extname(filename).empty?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/version.rb

@@ -1,5 +1,5 @@
 module RuboCop
   module SketchUp
-    VERSION = '0.0.2'
+    VERSION = '0.1.0'
   end
 end

data/rubocop-sketchup.gemspec

@@ -17,11 +17,12 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = ['lib']
   spec.files = Dir[
+    'config/**/*',
     'lib/**/*',
     '*.gemspec',
     'Gemfile'
   ]
 
-  spec.add_dependency 'rubocop', '~> 0.47.0'
+  spec.add_dependency 'rubocop', '~> 0.51.0'
   spec.add_development_dependency 'bundler', '~> 1.13'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-sketchup
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Trimble Inc, SketchUp Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-28 00:00:00.000000000 Z
+date: 2017-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.47.0
+        version: 0.51.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.47.0
+        version: 0.51.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -45,23 +45,40 @@ extensions: []
 extra_rdoc_files: []
 files:
 - Gemfile
+- config/default.yml
 - lib/rubocop-sketchup.rb
+- lib/rubocop/sketchup.rb
 - lib/rubocop/sketchup/deprecations/operation_next_transparent.rb
+- lib/rubocop/sketchup/extension_project.rb
+- lib/rubocop/sketchup/inject.rb
 - lib/rubocop/sketchup/namespace.rb
 - lib/rubocop/sketchup/namespace_checker.rb
 - lib/rubocop/sketchup/no_comment_disable.rb
+- lib/rubocop/sketchup/performance/openssl.rb
 - lib/rubocop/sketchup/performance/operation_disable_ui.rb
+- lib/rubocop/sketchup/performance/selection_bulk.rb
 - lib/rubocop/sketchup/performance/typename.rb
 - lib/rubocop/sketchup/requirements/api_namespace.rb
+- lib/rubocop/sketchup/requirements/exit.rb
 - lib/rubocop/sketchup/requirements/extension_namespace.rb
+- lib/rubocop/sketchup/requirements/file_structure.rb
 - lib/rubocop/sketchup/requirements/global_constants.rb
 - lib/rubocop/sketchup/requirements/global_methods.rb
 - lib/rubocop/sketchup/requirements/global_variables.rb
+- lib/rubocop/sketchup/requirements/language_handler_globals.rb
 - lib/rubocop/sketchup/requirements/load_path.rb
+- lib/rubocop/sketchup/requirements/minimal_registration.rb
+- lib/rubocop/sketchup/requirements/register_extension.rb
 - lib/rubocop/sketchup/requirements/ruby_core_namespace.rb
 - lib/rubocop/sketchup/requirements/ruby_stdlib_namespace.rb
+- lib/rubocop/sketchup/requirements/shipped_extensions_namespace.rb
+- lib/rubocop/sketchup/requirements/sketchup_extension.rb
+- lib/rubocop/sketchup/suggestions/dc_internals.rb
+- lib/rubocop/sketchup/suggestions/file_encoding.rb
 - lib/rubocop/sketchup/suggestions/model_entities.rb
 - lib/rubocop/sketchup/suggestions/operation_name.rb
+- lib/rubocop/sketchup/suggestions/sketchup_find_support_file.rb
+- lib/rubocop/sketchup/suggestions/sketchup_require.rb
 - lib/rubocop/sketchup/version.rb
 - rubocop-sketchup.gemspec
 homepage: http://github.com/sketchup/rubocop-sketchup