rubocop-sketchup 0.5.0 → 0.6.0

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

@@ -1,34 +1,34 @@
-# 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. If you create an extension that depend on the
-      # internal logic of another extension you are at the mercy of change and
-      # luck!
-      class DynamicComponentInternals < SketchUp::Cop
-
-        include SketchUp::DynamicComponentGlobals
-
-        MSG = 'Avoid relying on internal logic of Dynamic Components.'.freeze
-
-        def on_gvar(node)
-          check_global(node)
-        end
-
-        def on_gvasgn(node)
-          check_global(node)
-        end
-
-        def check_global(node)
-          global_var, = *node
-          return unless dc_global_var?(global_var)
-
-          add_offense(node, location: :name, severity: :warning)
-        end
-
-      end
-    end
-  end
-end
+# 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. If you create an extension that depend on the
+      # internal logic of another extension you are at the mercy of change and
+      # luck!
+      class DynamicComponentInternals < SketchUp::Cop
+
+        include SketchUp::DynamicComponentGlobals
+
+        MSG = 'Avoid relying on internal logic of Dynamic Components.'.freeze
+
+        def on_gvar(node)
+          check_global(node)
+        end
+
+        def on_gvasgn(node)
+          check_global(node)
+        end
+
+        def check_global(node)
+          global_var, = *node
+          return unless dc_global_var?(global_var)
+
+          add_offense(node, location: :name, severity: :warning)
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,78 +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 < SketchUp::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 ({lvar ivar cvar} $_) :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
-
-        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
+# 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 < SketchUp::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 ({lvar ivar cvar} $_) :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
+
+        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/cop/suggestions/model_entities.rb

@@ -1,58 +1,58 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupSuggestions
-      # Prefer `model.active_entities` over `model.entities`.
-      #
-      # Most tools/actions act upon the active entities context. This could be
-      # an opened group or component instance. Because of this, prefer
-      # `model.active_entities` by default over `model.entities` unless you
-      # have an explicit reason to work in the root model context.
-      class ModelEntities < SketchUp::Cop
-
-        MSG = 'Prefer `model.active_entities` over `model.entities`.'.freeze
-
-        # Reference: http://www.rubydoc.info/gems/rubocop/RuboCop/NodePattern
-        def_node_matcher :active_model_entities?, <<-PATTERN
-          (send
-            (send (const nil? :Sketchup) :active_model) :entities)
-        PATTERN
-
-        def_node_matcher :entities_receiver, <<-PATTERN
-          (send
-            ({lvar ivar cvar} $_) :entities)
-        PATTERN
-
-        MODEL_VARIABLE_NAMES = %w[model mod].freeze
-
-        def model_entities?(node)
-          return true if active_model_entities?(node)
-
-          name = entities_receiver(node)
-          name && model_variable?(name)
-        end
-
-        def on_send(node)
-          add_offense(node, location: :expression) if model_entities?(node)
-        end
-
-        private
-
-        def model_variable?(name)
-          basename = variable_basename(name)
-          MODEL_VARIABLE_NAMES.include?(basename)
-        end
-
-        def variable_basename(name)
-          # Extract the basename from variables:
-          #  model => model
-          #  @model => model
-          #  @@model => model
-          name.to_s.tr('@', '')
-        end
-
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupSuggestions
+      # Prefer `model.active_entities` over `model.entities`.
+      #
+      # Most tools/actions act upon the active entities context. This could be
+      # an opened group or component instance. Because of this, prefer
+      # `model.active_entities` by default over `model.entities` unless you
+      # have an explicit reason to work in the root model context.
+      class ModelEntities < SketchUp::Cop
+
+        MSG = 'Prefer `model.active_entities` over `model.entities`.'.freeze
+
+        # Reference: http://www.rubydoc.info/gems/rubocop/RuboCop/NodePattern
+        def_node_matcher :active_model_entities?, <<-PATTERN
+          (send
+            (send (const nil? :Sketchup) :active_model) :entities)
+        PATTERN
+
+        def_node_matcher :entities_receiver, <<-PATTERN
+          (send
+            ({lvar ivar cvar} $_) :entities)
+        PATTERN
+
+        MODEL_VARIABLE_NAMES = %w[model mod].freeze
+
+        def model_entities?(node)
+          return true if active_model_entities?(node)
+
+          name = entities_receiver(node)
+          name && model_variable?(name)
+        end
+
+        def on_send(node)
+          add_offense(node, location: :expression) if model_entities?(node)
+        end
+
+        private
+
+        def model_variable?(name)
+          basename = variable_basename(name)
+          MODEL_VARIABLE_NAMES.include?(basename)
+        end
+
+        def variable_basename(name)
+          # Extract the basename from variables:
+          #  model => model
+          #  @model => model
+          #  @@model => model
+          name.to_s.tr('@', '')
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/sketchup/cop/suggestions/monkey_patched_api.rb

@@ -1,45 +1,45 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupSuggestions
-      # Some of the shipped extensions in SketchUp monkey-patch the API
-      # namespace. This is an unfortunate no-no that was done a long time ago
-      # before the extension best-practices were established. These functions
-      # might change or be removed at any time. They will also not work when
-      # the extensions are disabled. Avoid using these methods.
-      class MonkeyPatchedApi < SketchUp::Cop
-
-        include SketchUp::DynamicComponentMethods
-
-        def on_send(node)
-          # Only check instance methods.
-          return if node.receiver && node.receiver.const_type?
-
-          name = node.method_name
-
-          dc_method = DC_METHODS.find { |m| m[:name] == name }
-          return unless dc_method
-
-          if dc_method.key?(:variables)
-            return unless node.receiver && node.receiver.variable?
-
-            receiver_name = node.receiver.children.first
-            # Account for instance and class variables.
-            receiver_name = receiver_name.to_s.tr('@', '').to_sym
-            return unless dc_method[:variables].include?(receiver_name)
-          end
-
-          path = dc_method[:path]
-          message = "#{path}##{name} is not part of the official API. "\
-                    "It's a monkey-patched addition by Dynamic Components."
-          add_offense(node,
-              location: :selector,
-              severity: :warning,
-              message: message)
-        end
-
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupSuggestions
+      # Some of the shipped extensions in SketchUp monkey-patch the API
+      # namespace. This is an unfortunate no-no that was done a long time ago
+      # before the extension best-practices were established. These functions
+      # might change or be removed at any time. They will also not work when
+      # the extensions are disabled. Avoid using these methods.
+      class MonkeyPatchedApi < SketchUp::Cop
+
+        include SketchUp::DynamicComponentMethods
+
+        def on_send(node)
+          # Only check instance methods.
+          return if node.receiver && node.receiver.const_type?
+
+          name = node.method_name
+
+          dc_method = DC_METHODS.find { |m| m[:name] == name }
+          return unless dc_method
+
+          if dc_method.key?(:variables)
+            return unless node.receiver && node.receiver.variable?
+
+            receiver_name = node.receiver.children.first
+            # Account for instance and class variables.
+            receiver_name = receiver_name.to_s.tr('@', '').to_sym
+            return unless dc_method[:variables].include?(receiver_name)
+          end
+
+          path = dc_method[:path]
+          message = "#{path}##{name} is not part of the official API. "\
+                    "It's a monkey-patched addition by Dynamic Components."
+          add_offense(node,
+              location: :selector,
+              severity: :warning,
+              message: message)
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,103 +1,103 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module SketchupSuggestions
-      # Operation name should be a short capitalized description. It will be
-      # visible to the user in the Edit > Undo menu. Make sure to give it a
-      # short human readable name, similar to SketchUp's own operation names.
-      #
-      # This cop make some very naive assumptions and will have more false
-      # positives than most of the other cops. It's purpose is mainly to enable
-      # awareness.
-      class OperationName < SketchUp::Cop
-
-        include RangeHelp
-
-        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
-          return if args.empty? || !args.first.str_type?
-
-          # Ignore transparent operations.
-          return if args.size == 4 && args.last.true_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.end_with?('.')
-          return false if titleize(name) != name
-
-          true
-        end
-
-        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
-        ].freeze
-
-        def titleize(string)
-          string = string.gsub(/[_.]/, ' ')
-          words = string.split.map { |word|
-            unless TITLEIZE_EXCLUDE.include?(word)
-              # word.capitalize won't work here, as we want to allow words like:
-              # "HTML", "SketchUp". So instead only the first character in each
-              # word is modified.
-              char = word[0].upcase
-              word[0, 1] = char
-            end
-            word
-          }
-          words.join(' ')
-        end
-
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SketchupSuggestions
+      # Operation name should be a short capitalized description. It will be
+      # visible to the user in the Edit > Undo menu. Make sure to give it a
+      # short human readable name, similar to SketchUp's own operation names.
+      #
+      # This cop make some very naive assumptions and will have more false
+      # positives than most of the other cops. It's purpose is mainly to enable
+      # awareness.
+      class OperationName < SketchUp::Cop
+
+        include RangeHelp
+
+        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
+          return if args.empty? || !args.first.str_type?
+
+          # Ignore transparent operations.
+          return if args.size == 4 && args.last.true_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.end_with?('.')
+          return false if titleize(name) != name
+
+          true
+        end
+
+        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
+        ].freeze
+
+        def titleize(string)
+          string = string.gsub(/[_.]/, ' ')
+          words = string.split.map { |word|
+            unless TITLEIZE_EXCLUDE.include?(word)
+              # word.capitalize won't work here, as we want to allow words like:
+              # "HTML", "SketchUp". So instead only the first character in each
+              # word is modified.
+              char = word[0].upcase
+              word[0, 1] = char
+            end
+            word
+          }
+          words.join(' ')
+        end
+
+      end
+    end
+  end
+end