leftovers 0.7.0 → 0.10.0

data/lib/leftovers/haml.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module Haml
-    module_function
-
-    def precompile(file, name)
-      return '' unless Leftovers.try_require('haml', message: <<~MESSAGE) # rubocop:disable Layout/EmptyLineAfterGuardClause
-        Skipped parsing #{name.relative_path}, because the haml gem was not available
-        `gem install haml`
-      MESSAGE
-
-      begin
-        ::Haml::Engine.new(file).precompiled
-      rescue ::Haml::SyntaxError => e
-        Leftovers.warn "#{e.class}: #{e.message} #{name.relative_path}:#{e.line}"
-        ''
-      end
-    end
-  end
-end

data/lib/leftovers/json.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module Leftovers
-  module JSON
-    class << self
-      def precompile(json, name)
-        "__leftovers_document(#{to_ruby_argument(::JSON.parse(json))})"
-      rescue ::JSON::ParserError => e
-        Leftovers.warn "#{e.class}: (#{name.relative_path}): #{e.message}"
-        ''
-      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

data/lib/leftovers/matcher_builders/node_pair_name.rb

@@ -1,18 +0,0 @@
-# frozen-string-literal: true
-
-module Leftovers
-  module MatcherBuilders
-    module NodePairName
-      def self.build(name_pattern)
-        matcher = ::Leftovers::MatcherBuilders::Name.build(name_pattern)
-
-        return unless matcher
-
-        ::Leftovers::MatcherBuilders::And.build([
-          ::Leftovers::Matchers::NodeType.new(:pair),
-          ::Leftovers::Matchers::NodeName.new(matcher)
-        ])
-      end
-    end
-  end
-end

data/lib/leftovers/matchers/predicate.rb

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

data/lib/leftovers/processor_builders/each_action.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ProcessorBuilders
-    module EachAction
-      def self.each_or_self(value, &block)
-        case value
-        when nil then nil
-        when Array then build(value.map(&block))
-        else build([yield(value)])
-        end
-      end
-
-      def self.build(processors)
-        processors = compact(processors)
-
-        case processors.length
-        # :nocov:
-        when 0 then raise
-        # :nocov:
-        when 1 then processors.first
-        else ::Leftovers::ValueProcessors::Each.new(processors)
-        end
-      end
-
-      def self.flatten(value) # rubocop:disable Metrics/MethodLength
-        case value
-        when ::Leftovers::ValueProcessors::Each
-          ret = value.processors.map { |v| flatten(v) }
-          ret.flatten!(1)
-          ret
-        when Array
-          ret = value.map { |v| flatten(v) }
-          ret.flatten!(1)
-          ret
-        else
-          value
-        end
-      end
-
-      def self.compact(processors)
-        return processors if processors.length <= 1
-
-        processors = flatten(processors)
-        processors.compact!
-
-        processors
-      end
-    end
-  end
-end

data/lib/leftovers/processor_builders/each_dynamic.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ProcessorBuilders
-    module EachDynamic
-      def self.each_or_self(value, &block)
-        case value
-        when nil then ::Leftovers::DynamicProcessors::Null
-        when Array then build(value.map(&block))
-        else build([yield(value)])
-        end
-      end
-
-      def self.build(processors)
-        processors = compact(processors)
-
-        case processors.length
-        # :nocov:
-        when 0 then raise
-        # :nocov:
-        when 1 then processors.first
-        else ::Leftovers::DynamicProcessors::Each.new(processors)
-        end
-      end
-
-      def self.flatten(value) # rubocop:disable Metrics/MethodLength
-        case value
-        when ::Leftovers::DynamicProcessors::Each
-          ret = value.processors.map { |v| flatten(v) }
-          ret.flatten!(1)
-          ret
-        when Array
-          ret = value.map { |v| flatten(v) }
-          ret.flatten!(1)
-          ret
-        else
-          value
-        end
-      end
-
-      def self.compact(processors)
-        return processors if processors.length <= 1
-
-        processors = flatten(processors)
-
-        processors.reject! do |p|
-          p == ::Leftovers::DynamicProcessors::Null
-        end
-
-        processors
-      end
-    end
-  end
-end

data/lib/leftovers/processor_builders/each_for_definition_set.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ProcessorBuilders
-    module EachForDefinitionSet
-      def self.each_or_self(value, &block)
-        case value
-        # :nocov:
-        when nil then raise
-        # :nocov:
-        when Array then build(value.map(&block))
-        else build([yield(value)])
-        end
-      end
-
-      def self.build(processors)
-        processors = compact(processors)
-
-        case processors.length
-        # :nocov:
-        when 0 then raise
-        # :nocov:
-        when 1 then processors.first
-        else ::Leftovers::ValueProcessors::EachForDefinitionSet.new(processors)
-        end
-      end
-
-      def self.compact(processors)
-        processors.flatten!
-        processors.compact!
-
-        processors
-      end
-    end
-  end
-end

data/lib/leftovers/slim.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module Slim
-    module_function
-
-    def precompile(file, name)
-      return '' unless Leftovers.try_require('slim', message: <<~MESSAGE) # rubocop:disable Layout/EmptyLineAfterGuardClause
-        Skipped parsing #{name.relative_path}, because the slim gem was not available
-        `gem install slim`
-      MESSAGE
-
-      begin
-        ::Slim::Engine.new(file: file).call(file)
-      rescue ::Slim::Parser::SyntaxError => e
-        Leftovers.warn "#{e.class}: \"#{e.error}\" #{name.relative_path}:#{e.lineno}:#{e.column}"
-        ''
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/add_dynamic_prefix.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    class AddDynamicPrefix
-      def initialize(prefix_processor, then_processor)
-        @prefix_processor = prefix_processor
-        @then_processor = then_processor
-
-        freeze
-      end
-
-      def process(str, node, method_node) # rubocop:disable Metrics/MethodLength
-        return unless str
-
-        prefixes = @prefix_processor.process(nil, method_node, method_node)
-        if prefixes.is_a?(Array)
-          prefixes.flatten!
-          prefixes.compact!
-          prefixes.uniq!
-
-          prefixes.map do |prefix|
-            @then_processor.process("#{prefix}#{str}", node, method_node)
-          end
-        else
-          @then_processor.process("#{prefixes}#{str}", node, method_node)
-        end
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/add_dynamic_suffix.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    class AddDynamicSuffix
-      def initialize(suffix_processor, then_processor)
-        @suffix_processor = suffix_processor
-        @then_processor = then_processor
-
-        freeze
-      end
-
-      def process(str, node, method_node) # rubocop:disable Metrics/MethodLength
-        return unless str
-
-        suffixes = @suffix_processor.process(nil, method_node, method_node)
-        if suffixes.is_a?(Array)
-          suffixes.flatten!
-          suffixes.compact!
-          suffixes.uniq!
-
-          suffixes.map do |suffix|
-            @then_processor.process("#{str}#{suffix}", node, method_node)
-          end
-        else
-          @then_processor.process("#{str}#{suffixes}", node, method_node)
-        end
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/delete_before.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    class DeleteBefore
-      def initialize(delete_before, then_processor)
-        @delete_before = delete_before
-        @then_processor = then_processor
-
-        freeze
-      end
-
-      def process(str, node, method_node)
-        return unless str
-
-        # TODO: investigate index
-        str = str.split(@delete_before, 2)[1] || str
-        @then_processor.process(str, node, method_node)
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/each.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    class Each
-      attr_reader :processors
-
-      def initialize(processors)
-        @processors = processors
-
-        freeze
-      end
-
-      def process(str, node, method_node)
-        @processors.flat_map do |processor|
-          processor.process(str, node, method_node)
-        end
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/each_for_definition_set.rb

@@ -1,26 +0,0 @@
-# frozen-string-literal: true
-
-module Leftovers
-  module ValueProcessors
-    class EachForDefinitionSet
-      def initialize(then_processors)
-        @then_processors = then_processors
-
-        freeze
-      end
-
-      def process(str, node, method_node)
-        definitions = @then_processors.map do |then_processor|
-          then_processor.process(str, node, method_node)
-        end
-
-        definitions.flatten!
-        definitions.compact!
-
-        return definitions.first if definitions.length <= 1
-
-        ::Leftovers::DefinitionNodeSet.new(definitions)
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/each_keyword.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    class EachKeyword
-      def initialize(then_processor)
-        @then_processor = then_processor
-
-        freeze
-      end
-
-      def process(_str, node, method_node)
-        kwargs = node.kwargs
-        return unless kwargs
-
-        kwargs.children.map do |pair|
-          next unless pair.type == :pair
-
-          argument_node = pair.first
-          str = argument_node.to_s if argument_node.string_or_symbol?
-
-          @then_processor.process(str, argument_node, method_node)
-        end
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/each_keyword_argument.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    class EachKeywordArgument
-      def initialize(then_processor)
-        @then_processor = then_processor
-
-        freeze
-      end
-
-      def process(_str, node, method_node)
-        kwargs = node.kwargs
-        return unless kwargs
-
-        kwargs.children.map do |pair|
-          next unless pair.type == :pair
-
-          argument_node = pair.second
-          str = argument_node.to_s if argument_node.string_or_symbol?
-
-          @then_processor.process(str, argument_node, method_node)
-        end
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/each_positional_argument.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    class EachPositionalArgument
-      def initialize(then_processor)
-        @then_processor = then_processor
-
-        freeze
-      end
-
-      def process(_str, node, method_node)
-        positional_arguments = node.positional_arguments
-        return unless positional_arguments
-
-        positional_arguments.map do |argument_node|
-          str = argument_node.to_s if argument_node.string_or_symbol_or_def?
-
-          @then_processor.process(str, argument_node, method_node)
-        end
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/itself.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    class Itself
-      def initialize(then_processor)
-        @then_processor = then_processor
-
-        freeze
-      end
-
-      def process(_str, node, method_node)
-        @then_processor.process(method_node.to_s, node, method_node)
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/keyword.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    class Keyword
-      def initialize(matcher, then_processor)
-        @matcher = matcher
-        @then_processor = then_processor
-
-        freeze
-      end
-
-      def process(_str, node, method_node)
-        kwargs = node.kwargs
-        return unless kwargs
-
-        result = []
-
-        kwargs.children.each do |pair|
-          next unless @matcher === pair
-
-          argument_node = pair.first
-          str = argument_node.to_s
-
-          result << @then_processor.process(str, argument_node, method_node)
-        end
-
-        result
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/return_definition_node.rb

@@ -1,14 +0,0 @@
-# frozen-string-literal: true
-
-module Leftovers
-  module ValueProcessors
-    module ReturnDefinitionNode
-      def self.process(str, node, _method_node)
-        return unless str
-        return if str.empty?
-
-        Leftovers::DefinitionNode.new(node, name: str.to_sym)
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/return_sym.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    module ReturnSym
-      def self.process(str, _node, _method_node)
-        return unless str
-        return if str.empty?
-
-        str.to_sym
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors.rb

@@ -1,40 +0,0 @@
-# frozen-string-literal: true
-
-module Leftovers
-  module ValueProcessors
-    autoload(:AddDynamicPrefix, "#{__dir__}/value_processors/add_dynamic_prefix")
-    autoload(:AddDynamicSuffix, "#{__dir__}/value_processors/add_dynamic_suffix")
-    autoload(:AddPrefix, "#{__dir__}/value_processors/add_prefix")
-    autoload(:AddSuffix, "#{__dir__}/value_processors/add_suffix")
-    autoload(:Camelize, "#{__dir__}/value_processors/camelize")
-    autoload(:Capitalize, "#{__dir__}/value_processors/capitalize")
-    autoload(:Deconstantize, "#{__dir__}/value_processors/deconstantize")
-    autoload(:DeleteAfter, "#{__dir__}/value_processors/delete_after")
-    autoload(:DeleteBefore, "#{__dir__}/value_processors/delete_before")
-    autoload(:DeletePrefix, "#{__dir__}/value_processors/delete_prefix")
-    autoload(:DeleteSuffix, "#{__dir__}/value_processors/delete_suffix")
-    autoload(:Demodulize, "#{__dir__}/value_processors/demodulize")
-    autoload(:Downcase, "#{__dir__}/value_processors/downcase")
-    autoload(:EachForDefinitionSet, "#{__dir__}/value_processors/each_for_definition_set")
-    autoload(:EachKeyword, "#{__dir__}/value_processors/each_keyword")
-    autoload(:EachKeywordArgument, "#{__dir__}/value_processors/each_keyword_argument")
-    autoload(:EachPositionalArgument, "#{__dir__}/value_processors/each_positional_argument")
-    autoload(:Each, "#{__dir__}/value_processors/each")
-    autoload(:Itself, "#{__dir__}/value_processors/itself")
-    autoload(:Keyword, "#{__dir__}/value_processors/keyword")
-    autoload(:KeywordArgument, "#{__dir__}/value_processors/keyword_argument")
-    autoload(:Parameterize, "#{__dir__}/value_processors/parameterize")
-    autoload(:Placeholder, "#{__dir__}/value_processors/placeholder")
-    autoload(:Pluralize, "#{__dir__}/value_processors/pluralize")
-    autoload(:PositionalArgument, "#{__dir__}/value_processors/positional_argument")
-    autoload(:ReplaceValue, "#{__dir__}/value_processors/replace_value")
-    autoload(:ReturnDefinitionNode, "#{__dir__}/value_processors/return_definition_node")
-    autoload(:ReturnSym, "#{__dir__}/value_processors/return_sym")
-    autoload(:Singularize, "#{__dir__}/value_processors/singularize")
-    autoload(:Split, "#{__dir__}/value_processors/split")
-    autoload(:Swapcase, "#{__dir__}/value_processors/swapcase")
-    autoload(:Titleize, "#{__dir__}/value_processors/titleize")
-    autoload(:Underscore, "#{__dir__}/value_processors/underscore")
-    autoload(:Upcase, "#{__dir__}/value_processors/upcase")
-  end
-end

data/lib/leftovers/yaml.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-
-module Leftovers
-  module YAML
-    class Builder < ::Psych::TreeBuilder
-      def initialize
-        @constants = []
-
-        super
-      end
-
-      def add_constant_for_tag(tag, value = nil)
-        match = %r{\A!ruby/[^:]*(?::(.*))?\z}.match(tag)
-        return unless match
-
-        @constants << (match[1] || value)
-      end
-
-      def start_mapping(_anchor, tag, *rest) # leftovers:keep
-        add_constant_for_tag(tag)
-        tag = nil
-
-        super
-      end
-
-      def start_sequence(_anchor, tag, *rest) # leftovers:keep
-        add_constant_for_tag(tag)
-        tag = nil
-
-        super
-      end
-
-      def scalar(value, _anchor, tag, *rest) # leftovers:keep
-        add_constant_for_tag(tag, value)
-        tag = nil
-
-        super
-      end
-
-      def to_ruby_file
-        <<~RUBY
-          __leftovers_document(#{to_ruby_argument(root.to_ruby.first)})
-          #{@constants.join("\n")}
-        RUBY
-      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
-
-    def self.precompile(yaml, name)
-      builder = ::Leftovers::YAML::Builder.new
-      parser = ::Psych::Parser.new(builder)
-      parser.parse(yaml, name.relative_path)
-
-      builder.to_ruby_file
-    rescue ::Psych::SyntaxError => e
-      Leftovers.warn "#{e.class}: #{e.message}"
-      ''
-    end
-  end
-end