leftovers 0.5.5 → 0.8.0

data/lib/leftovers/matcher_builders/node_privacy.rb

@@ -0,0 +1,13 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module NodePrivacy
+      def self.build(privacy_settings)
+        ::Leftovers::MatcherBuilders::Or.each_or_self(privacy_settings) do |privacy|
+          ::Leftovers::Matchers::NodePrivacy.new(privacy)
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/node_type.rb

@@ -14,12 +14,12 @@ module Leftovers
           when 'Float' then ::Leftovers::Matchers::NodeType.new(:float)
           when 'Array' then ::Leftovers::Matchers::NodeType.new(:array)
           when 'Hash' then ::Leftovers::Matchers::NodeType.new(:hash)
-
           when 'Proc' then ::Leftovers::Matchers::Predicate.new(:proc?)
-          # when 'Method' then ::Leftovers::Matchers::NodeType.new(Set[:send, :csend, :def])
-          # when 'Constant' then ::Leftovers::Matchers::NodeType.new(Set[:const, :class, :module])
+          when 'Method' then ::Leftovers::Matchers::NodeType.new(Set[:send, :csend, :def, :defs])
+          when 'Constant'
+            ::Leftovers::Matchers::NodeType.new(Set[:const, :class, :module, :casgn])
           # :nocov:
-          else raise
+          else raise Leftovers::UnexpectedCase, "Unhandled value #{type.inspect}"
             # :nocov:
           end
         end

data/lib/leftovers/matcher_builders/node_value.rb

@@ -4,17 +4,15 @@ module Leftovers
   module MatcherBuilders
     module NodeValue
       class << self
-        def build(pattern) # rubocop:disable Metrics/MethodLength
-          ::Leftovers::MatcherBuilders::Or.each_or_self(pattern) do |pat|
-            case pat
-            when ::Integer, true, false, nil
-              ::Leftovers::Matchers::NodeScalarValue.new(pat)
-            when ::String
-              ::Leftovers::MatcherBuilders::NodeName.build(pat)
-            when ::Hash
-              build_from_hash(**pat)
+        def build(patterns)
+          ::Leftovers::MatcherBuilders::Or.each_or_self(patterns) do |pattern|
+            case pattern
+            when ::Integer, ::Float, true, false, nil
+              ::Leftovers::Matchers::NodeScalarValue.new(pattern)
+            when ::String then ::Leftovers::MatcherBuilders::NodeName.build(pattern)
+            when ::Hash then build_from_hash(**pattern)
             # :nocov:
-            else raise
+            else raise Leftovers::UnexpectedCase, "Unhandled value #{pattern.inspect}"
               # :nocov:
             end
           end
@@ -22,27 +20,34 @@ module Leftovers
 
         private
 
-        def build_from_hash( # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+        def build_node_name(match, has_prefix, has_suffix)
+          ::Leftovers::MatcherBuilders::NodeName.build(
+            match: match, has_prefix: has_prefix, has_suffix: has_suffix
+          )
+        end
+
+        def build_unless(unless_arg)
+          return unless unless_arg
+
+          ::Leftovers::MatcherBuilders::Unless.build(
+            ::Leftovers::MatcherBuilders::NodeValue.build(unless_arg)
+          )
+        end
+
+        def build_from_hash( # rubocop:disable Metrics/ParameterLists
           at: nil, has_value: nil,
           match: nil, has_prefix: nil, has_suffix: nil,
           type: nil,
           has_receiver: nil,
           unless_arg: nil
         )
-          matcher = ::Leftovers::MatcherBuilders::And.build([
-            ::Leftovers::MatcherBuilders::NodeHasArgument.build(
-              at: at, has_value: has_value
-            ),
-            ::Leftovers::MatcherBuilders::NodeName.build(
-              match: match, has_prefix: has_prefix, has_suffix: has_suffix
-            ),
+          ::Leftovers::MatcherBuilders::And.build([
+            ::Leftovers::MatcherBuilders::NodeHasArgument.build(at: at, has_value: has_value),
+            build_node_name(match, has_prefix, has_suffix),
             ::Leftovers::MatcherBuilders::NodeType.build(type),
-            ::Leftovers::MatcherBuilders::NodeHasReceiver.build(has_receiver)
+            ::Leftovers::MatcherBuilders::NodeHasReceiver.build(has_receiver),
+            build_unless(unless_arg)
           ])
-
-          ::Leftovers::MatcherBuilders::AndNot.build(
-            matcher, ::Leftovers::MatcherBuilders::NodeValue.build(unless_arg)
-          )
         end
       end
     end

data/lib/leftovers/matcher_builders/or.rb

@@ -5,68 +5,68 @@ require 'set'
 module Leftovers
   module MatcherBuilders
     module Or
-      def self.each_or_self(value, &block)
-        case value
-        when nil then nil
-        when Array then build(value.map(&block))
-        else build([yield(value)])
+      class << self
+        def each_or_self(value, &block)
+          case value
+          when nil then nil
+          when Array then build(value.map(&block))
+          else build([yield(value)])
+          end
         end
-      end
 
-      def self.build(matchers)
-        matchers = compact(matchers)
-        case matchers.length
-          # :nocov:
-        when 0 then nil
-          # :nocov:
-        when 1 then matchers.first
-        when 2 then ::Leftovers::Matchers::Or.new(matchers.first, matchers[1])
-        else ::Leftovers::Matchers::Any.new(matchers.dup)
+        def build(matchers)
+          matchers = compact(matchers)
+          case matchers.length
+            # :nocov:
+          when 0 then nil
+            # :nocov:
+          when 1 then matchers.first
+          when 2 then ::Leftovers::Matchers::Or.new(matchers.first, matchers[1])
+          else ::Leftovers::Matchers::Any.new(matchers.dup)
+          end
         end
-      end
 
-      def self.flatten(value) # rubocop:disable Metrics/MethodLength
-        case value
-        when ::Leftovers::Matchers::Or
-          [*flatten(value.lhs), *flatten(value.rhs)]
-        when ::Leftovers::Matchers::Any
-          flatten(value.matchers)
-        when Array
-          ret = value.map { |v| flatten(v) }
-          ret.flatten!(1)
-          ret
-        else
-          value
+        private
+
+        def flatten(value)
+          case value
+          when ::Leftovers::Matchers::Or
+            [*flatten(value.lhs), *flatten(value.rhs)]
+          when ::Leftovers::Matchers::Any
+            flatten(value.matchers)
+          when Array
+            value.flat_map { |v| flatten(v) }
+          else
+            value
+          end
         end
-      end
 
-      def self.compact(matchers) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize,
-        return matchers if matchers.length <= 1
+        def group_by_compactable(matchers)
+          groups = matchers.group_by do |matcher|
+            case matcher
+            when ::Integer, ::Symbol then :set
+            when ::Regexp then :regexp
+            else :uncompactable
+            end
+          end
 
-        set = Set.new
-        regexps = []
-        uncompactable = []
+          groups.transform_values { |v| Leftovers.unwrap_array(v) }
+        end
 
-        matchers = flatten(matchers)
+        def build_grouped(set: nil, regexp: nil, uncompactable: nil)
+          set = set.to_set if set.is_a?(Array)
+          regexp = Regexp.union(regexp) if regexp.is_a?(Array)
 
-        matchers.each do |matcher|
-          case matcher
-          when nil then nil
-          when ::Integer, ::Symbol then set << matcher
-          # when ::Set then set.merge(matcher) # may not be necessary
-          when ::Regexp then regexps << matcher
-          else uncompactable << matcher
-          end
+          [set, regexp].concat(Array(uncompactable)).compact
         end
 
-        set = set.first if set.length <= 1
-        regexps = if regexps.length <= 1
-          regexps.first
-        else
-          Regexp.union(regexps)
-        end
+        def compact(matchers)
+          matchers = flatten(matchers)
+
+          return matchers if matchers.length <= 1
 
-        [set, regexps].compact.concat(uncompactable)
+          build_grouped(**group_by_compactable(matchers))
+        end
       end
     end
   end

data/lib/leftovers/matcher_builders/string_pattern.rb

@@ -3,15 +3,24 @@
 module Leftovers
   module MatcherBuilders
     module StringPattern
-      def self.build(match: nil, has_prefix: nil, has_suffix: nil)
-        if match
+      def self.build(match: nil, has_prefix: nil, has_suffix: nil) # rubocop:disable Metrics
+        has_prefix = ::Regexp.escape(has_prefix) if has_prefix
+        has_suffix = ::Regexp.escape(has_suffix) if has_suffix
+
+        if match && has_prefix && has_suffix
+          /\A(?=#{match}\z)(?=#{has_prefix}).*#{has_suffix}\z/
+        elsif match && has_prefix
+          /\A(?=#{match}\z)#{has_prefix}/
+        elsif match && has_suffix
+          /\A(?=#{match}\z).*#{has_suffix}\z/
+        elsif match
           /\A#{match}\z/
         elsif has_prefix && has_suffix
-          /\A#{::Regexp.escape(has_prefix)}.*#{::Regexp.escape(has_suffix)}\z/
+          /\A(?=#{has_prefix}).*#{has_suffix}\z/
         elsif has_prefix
-          /\A#{::Regexp.escape(has_prefix)}/
+          /\A#{has_prefix}/
         elsif has_suffix
-          /#{::Regexp.escape(has_suffix)}\z/
+          /#{has_suffix}\z/
         end
       end
     end

data/lib/leftovers/matcher_builders.rb

@@ -4,6 +4,7 @@ module Leftovers
   module MatcherBuilders
     autoload(:AndNot, "#{__dir__}/matcher_builders/and_not")
     autoload(:And, "#{__dir__}/matcher_builders/and")
+    autoload(:Document, "#{__dir__}/matcher_builders/document")
     autoload(:Name, "#{__dir__}/matcher_builders/name")
     autoload(:Node, "#{__dir__}/matcher_builders/node")
     autoload(:NodeHasArgument, "#{__dir__}/matcher_builders/node_has_argument")
@@ -14,6 +15,7 @@ module Leftovers
     autoload(:NodePairName, "#{__dir__}/matcher_builders/node_pair_name")
     autoload(:NodePairValue, "#{__dir__}/matcher_builders/node_pair_value")
     autoload(:NodePath, "#{__dir__}/matcher_builders/node_path")
+    autoload(:NodePrivacy, "#{__dir__}/matcher_builders/node_privacy")
     autoload(:NodeType, "#{__dir__}/matcher_builders/node_type")
     autoload(:NodeValue, "#{__dir__}/matcher_builders/node_value")
     autoload(:Or, "#{__dir__}/matcher_builders/or")

data/lib/leftovers/matchers/all.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class All
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(matchers)
         @matchers = matchers
 

data/lib/leftovers/matchers/and.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class And
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(lhs, rhs)
         @lhs = lhs
         @rhs = rhs

data/lib/leftovers/matchers/any.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class Any
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       attr_reader :matchers
 
       def initialize(matchers)

data/lib/leftovers/matchers/node_has_any_keyword_argument.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class NodeHasAnyKeywordArgument
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(pair_matcher)
         @pair_matcher = pair_matcher
 
@@ -17,9 +13,7 @@ module Leftovers
         kwargs = node.kwargs
         return false unless kwargs
 
-        kwargs.children.any? do |pair|
-          @pair_matcher === pair
-        end
+        kwargs.children.any?(@pair_matcher)
       end
 
       freeze

data/lib/leftovers/matchers/node_has_any_positional_argument_with_value.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class NodeHasAnyPositionalArgumentWithValue
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(matcher)
         @matcher = matcher
 
@@ -17,9 +13,7 @@ module Leftovers
         args = node.positional_arguments
         return false unless args
 
-        args.any? do |value|
-          @matcher === value
-        end
+        args.any?(@matcher)
       end
 
       freeze

data/lib/leftovers/matchers/node_has_positional_argument_with_value.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class NodeHasPositionalArgumentWithValue
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(position, matcher)
         @position = position
         @matcher = matcher

data/lib/leftovers/matchers/node_name.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class NodeName
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(name_matcher)
         @name_matcher = name_matcher
 

data/lib/leftovers/matchers/node_pair_value.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class NodePairValue
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(value_matcher)
         @value_matcher = value_matcher
 

data/lib/leftovers/matchers/node_path.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class NodePath
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(path_matcher)
         @path_matcher = path_matcher
 

data/lib/leftovers/matchers/node_privacy.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class NodePrivacy
+      def initialize(privacy_matcher)
+        @privacy_matcher = privacy_matcher
+
+        freeze
+      end
+
+      def ===(node)
+        @privacy_matcher === node.privacy
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/node_scalar_value.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class NodeScalarValue
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(matcher)
         @matcher = matcher
 

data/lib/leftovers/matchers/node_type.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class NodeType
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(type_matcher)
         @type_matcher = type_matcher
 

data/lib/leftovers/matchers/not.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class Not
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(matcher)
         @matcher = matcher
 

data/lib/leftovers/matchers/or.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class Or
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       attr_reader :lhs, :rhs
 
       def initialize(lhs, rhs)

data/lib/leftovers/matchers.rb

@@ -19,6 +19,7 @@ module Leftovers
     autoload(:NodeName, "#{__dir__}/matchers/node_name")
     autoload(:NodePairValue, "#{__dir__}/matchers/node_pair_value")
     autoload(:NodePath, "#{__dir__}/matchers/node_path")
+    autoload(:NodePrivacy, "#{__dir__}/matchers/node_privacy")
     autoload(:NodeScalarValue, "#{__dir__}/matchers/node_scalar_value")
     autoload(:NodeType, "#{__dir__}/matchers/node_type")
     autoload(:Not, "#{__dir__}/matchers/not")

data/lib/leftovers/merged_config.rb

@@ -24,9 +24,7 @@ module Leftovers
       @configs << config
       @loaded_configs << config.name
       config.gems.each { |gem| self << gem }
-      config.requires.each do |req|
-        Leftovers.try_require(req, message: "cannot require '#{req}' from #{config.name}.yml")
-      end
+      require_requires(config)
     end
 
     def project_config
@@ -41,9 +39,7 @@ module Leftovers
       @exclude_paths
       @include_paths
       @test_paths
-      @haml_paths
-      @slim_paths
-      @erb_paths
+      @precompilers
       @dynamic
       @keep
       @test_only
@@ -64,35 +60,11 @@ module Leftovers
     end
 
     def test_paths
-      @test_paths ||= FastIgnore.new(
-        include_rules: @configs.flat_map(&:test_paths),
-        gitignore: false,
-        root: Leftovers.pwd
-      )
-    end
-
-    def haml_paths
-      @haml_paths ||= FastIgnore.new(
-        include_rules: @configs.flat_map(&:haml_paths),
-        gitignore: false,
-        root: Leftovers.pwd
-      )
-    end
-
-    def slim_paths
-      @slim_paths ||= FastIgnore.new(
-        include_rules: @configs.flat_map(&:slim_paths),
-        gitignore: false,
-        root: Leftovers.pwd
-      )
+      @test_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:test_paths))
     end
 
-    def erb_paths
-      @erb_paths ||= FastIgnore.new(
-        include_rules: @configs.flat_map(&:erb_paths),
-        gitignore: false,
-        root: Leftovers.pwd
-      )
+    def precompilers
+      @precompilers ||= Leftovers::Precompilers.build(@configs.flat_map(&:precompile))
     end
 
     def dynamic
@@ -109,6 +81,16 @@ module Leftovers
 
     private
 
+    def require_requires(config)
+      config.requires.each do |req|
+        if req.is_a?(Hash) && req[:quiet]
+          Leftovers.try_require(req[:quiet])
+        else
+          Leftovers.try_require(req, message: "cannot require '#{req}' from #{config.name}.yml")
+        end
+      end
+    end
+
     def load_bundled_gem_config
       return unless Leftovers.try_require('bundler')
 

data/lib/leftovers/precompilers/erb.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module Leftovers
+  module Precompilers
+    class ERB < ::ERB::Compiler
+      def self.precompile(erb)
+        @compiler ||= new('-')
+        @compiler.compile(erb).first
+      end
+
+      def add_insert_cmd(out, content) # leftovers:keep
+        out.push("\n#{content}\n")
+      end
+
+      def add_put_cmd(out, _content) # leftovers:keep
+        out.push("\n")
+      end
+    end
+  end
+end

data/lib/leftovers/precompilers/haml.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'haml'
+
+module Leftovers
+  module Precompilers
+    module Haml
+      def self.precompile(haml)
+        ::Haml::Engine.new(haml).precompiled
+      rescue ::Haml::SyntaxError => e
+        raise Leftovers::PrecompileError.new(e.message, line: e.line)
+      end
+    end
+  end
+end

data/lib/leftovers/precompilers/json.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Leftovers
+  module Precompilers
+    module JSON
+      class << self
+        def precompile(json)
+          "__leftovers_document(#{to_ruby_argument(::JSON.parse(json))})"
+        end
+
+        private
+
+        def to_ruby_argument(value)
+          ruby = value.inspect
+          return ruby unless value.is_a?(Array)
+
+          ruby.delete_prefix!('[')
+          ruby.delete_suffix!(']')
+
+          ruby
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/precompilers/precompiler.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Leftovers
+  module Precompilers
+    class Precompiler
+      def initialize(precompiler, matcher)
+        @precompiler = precompiler
+        @matcher = matcher
+      end
+
+      def precompile(content, file)
+        return unless @matcher === file.relative_path
+
+        begin
+          @precompiler.precompile(content)
+        rescue Leftovers::PrecompileError => e
+          e.warn(path: file.relative_path)
+          ''
+        rescue StandardError => e
+          Leftovers.warn "#{e.class}: #{file.relative_path} #{e.message}"
+          ''
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/precompilers/slim.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'slim'
+
+module Leftovers
+  module Precompilers
+    module Slim
+      def self.precompile(file)
+        ::Slim::Engine.new(file: file).call(file)
+      rescue ::Slim::Parser::SyntaxError => e
+        raise Leftovers::PrecompileError.new(e.error, line: e.lineno, column: e.column)
+      end
+    end
+  end
+end