yalphabetize 0.0.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e77cd0148a5d6e1d6c31b90a12d9d7cf85fbccea7e5efa6f4240c6f60759e69e
-  data.tar.gz: d1c1b0c394f0c35a23b41fb05d1ebd39cfcf53f1bbc8c316a7dac4ee3d6fc046
+  metadata.gz: 7233124faca7d704c5fc49708d03df7bf821863a7ef1470d2525b00dadc13c80
+  data.tar.gz: 904ee4fb5f329b2b9be7fb33a1e7d4bebb3e15dddfee3b6928756e47aab4cf61
 SHA512:
-  metadata.gz: 3478dcee26fe4f22d25bc81cc6f9bc874c8af9599c76971ae6c51b619c5ee6215600c161d34b36714f27e5a1b579c643f8679a770ce5e2470bf89d17203be085
-  data.tar.gz: a1bdafe93d32883ebbd8ed601a83f5521ec7519597a02e8f0f6f325c17bb502b291350529c94dfd5b709e6eb83d8ace98a48c12a88a3c2e327e92b5b62341078
+  metadata.gz: 1021062eedb1e2f0a7ceefd6fa7783f55079d415097476b94cea6c399223a8af5a0e8311d560e423744ad35292707280641c81c3c8ebc0ff97baad2b1ec3f9fd
+  data.tar.gz: e633c877d5350bc007c0beb931c5eb7a322603b7cd0e4742c48ddc964b44d8da185cb444294c7d7e27e1ece707854948d94e9a534d03c5579eab770a1a6f97ef

data/bin/yalphabetize

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/yalphabetize'
+
+exit Yalphabetize::CLI.call(ARGV)

data/lib/yalphabetize/aliaser.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Yalphabetize
+  class Aliaser
+    def initialize(stream_node)
+      @stream_node = stream_node
+      @aliases = {}
+    end
+
+    def call
+      nodes.each do |node|
+        next unless node.respond_to?(:anchor) && node.anchor
+
+        ensure_anchor_then_alias(node)
+      end
+      stream_node
+    end
+
+    private
+
+    attr_reader :stream_node, :aliases
+
+    def ensure_anchor_then_alias(node)
+      if node.alias?
+        aliases[node.anchor] ||= node
+      elsif aliases[node.anchor]
+        swap(node, aliases[node.anchor])
+      end
+    end
+
+    def swap(anchor_node, alias_node)
+      stream_node.each do |node|
+        node.children&.map! do |child_node|
+          convert_node(child_node, anchor_node, alias_node)
+        end
+      end
+    end
+
+    def nodes
+      stream_node.select do |node|
+        node.respond_to?(:anchor) && node.anchor
+      end
+    end
+
+    def convert_node(child_node, anchor_node, alias_node)
+      if child_node == anchor_node
+        alias_node
+      elsif child_node == alias_node
+        anchor_node
+      else
+        child_node
+      end
+    end
+  end
+end

data/lib/yalphabetize/alphabetizer.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Yalphabetize
+  class Alphabetizer
+    def initialize(stream_node, order_checker_class:)
+      @stream_node = stream_node
+      @order_checker_class = order_checker_class
+    end
+
+    def call
+      transform(stream_node)
+      alphabetize(stream_node)
+      stream_node
+    end
+
+    private
+
+    attr_reader :stream_node, :order_checker_class
+
+    def alphabetize(node)
+      if node.mapping?
+        alphabetize_children(node)
+        unpair_children(node)
+      end
+
+      node.children&.each { |child_node| alphabetize(child_node) }
+    end
+
+    def alphabetize_children(node)
+      node.children.sort! do |a, b|
+        order_checker_class.compare(a.first.value, b.first.value)
+      end
+    end
+
+    def unpair_children(node)
+      children_clone = node.children.dup
+
+      children_clone.each do |slice|
+        node.children.push(*slice)
+        node.children.shift
+      end
+    end
+
+    def transform(node)
+      node.children&.each(&method(:transform))
+
+      return unless node.mapping?
+
+      pair_up_children(node)
+    end
+
+    def pair_up_children(node)
+      children_clone = node.children.dup
+
+      children_clone.each_slice(2) do |slice|
+        node.children.push(slice)
+        node.children.shift
+        node.children.shift
+      end
+    end
+  end
+end

data/lib/yalphabetize/cli.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Yalphabetize
+  class CLI
+    def self.call(argv)
+      new(argv).call
+    end
+
+    def initialize(argv)
+      @argv = argv
+    end
+
+    def call
+      Yalphabetizer.call argv, options
+    end
+
+    private
+
+    attr_reader :argv
+
+    def options
+      OptionParser.parse!(argv)
+    end
+  end
+end

data/lib/yalphabetize/erb_compiler.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# Inspired by ERB::Compiler (https://github.com/ruby/erb/blob/b58b188028fbb403f75d48d62717373fc0908f7a/lib/erb.rb)
+
+module Yalphabetize
+  class ErbCompiler
+    DEFAULT_STAGS = ['<%%', '<%=', '<%#', '<%', '%{', '{{'].freeze
+    DEFAULT_ETAGS = ['%%>', '%>', '}}', '}'].freeze
+
+    class Scanner
+      STAG_REG = /(.*?)(#{DEFAULT_STAGS.join('|')}|\z)/m.freeze
+      ETAG_REG = /(.*?)(#{DEFAULT_ETAGS.join('|')}|\z)/m.freeze
+
+      def initialize(src)
+        @src = src
+        @stag = nil
+      end
+
+      def scan
+        until scanner.eos?
+          scanner.scan(stag ? ETAG_REG : STAG_REG)
+          yield(scanner[1])
+          yield(scanner[2])
+        end
+      end
+
+      attr_accessor :stag
+
+      private
+
+      attr_reader :src
+
+      def scanner
+        @_scanner ||= StringScanner.new(src)
+      end
+    end
+
+    def initialize
+      @buffer = []
+      @content = []
+    end
+
+    def compile(string)
+      scanner = Scanner.new(string)
+      scanner.scan do |token|
+        next if token.nil?
+        next if token == ''
+
+        if scanner.stag.nil?
+          compile_stag(token, scanner)
+        else
+          compile_etag(token, scanner)
+        end
+      end
+    end
+
+    def compile_stag(stag, scanner)
+      case stag
+      when *DEFAULT_STAGS
+        scanner.stag = stag
+        buffer << stag
+      end
+    end
+
+    def compile_etag(etag, scanner)
+      buffer << etag
+
+      case etag
+      when *DEFAULT_ETAGS
+        content << buffer.join
+        self.buffer = []
+        scanner.stag = nil
+      end
+    end
+
+    attr_reader :content
+
+    private
+
+    attr_accessor :buffer
+  end
+end

data/lib/yalphabetize/file_yalphabetizer.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Yalphabetize
+  class FileYalphabetizer
+    def initialize(file_path, **options)
+      @file_path = file_path
+      @reader_class = options[:reader_class]
+      @offence_detector_class = options[:offence_detector_class]
+      @logger = options[:logger]
+      @autocorrect = options[:autocorrect]
+      @alphabetizer_class = options[:alphabetizer_class]
+      @writer_class = options[:writer_class]
+      @order_checker_class = options[:order_checker_class]
+    end
+
+    def call
+      if offences?
+        logger.log_offence(file_path)
+        autocorrect_file if autocorrect
+      else
+        logger.log_no_offence
+      end
+    end
+
+    private
+
+    attr_reader :file_path, :reader_class, :offence_detector_class, :logger, :autocorrect,
+                :alphabetizer_class, :writer_class, :order_checker_class
+
+    def autocorrect_file
+      alphabetize
+      handle_aliases
+      rewrite_yml_file
+      print_to_log
+    end
+
+    def offences?
+      offence_detector_class.new(stream_node, order_checker_class: order_checker_class).offences?
+    end
+
+    def alphabetize
+      alphabetizer_class.new(stream_node, order_checker_class: order_checker_class).call
+    end
+
+    def handle_aliases
+      Aliaser.new(stream_node).call
+    end
+
+    def rewrite_yml_file
+      writer_class.new(stream_node, file_path, interpolations_mapping).call
+    end
+
+    def print_to_log
+      logger.log_correction(file_path)
+    end
+
+    def reader
+      @_reader ||= reader_class.new(file_path)
+    end
+
+    def stream_node
+      @_stream_node ||= reader.to_ast
+    end
+
+    def interpolations_mapping
+      reader.interpolations_mapping
+    end
+  end
+end

data/lib/yalphabetize/logger.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Yalphabetize
+  class Logger
+    DEFAULT_OUTPUT = $stdout
+
+    def initialize(output = DEFAULT_OUTPUT)
+      @output = output
+      @inspected_count = 0
+      @offences = {}
+    end
+
+    def initial_summary(file_paths)
+      output.puts "Inspecting #{file_paths.size} YAML files"
+    end
+
+    def log_offence(file_path)
+      @inspected_count += 1
+      offences[file_path] = :detected
+      output.print red 'O'
+    end
+
+    def log_no_offence
+      @inspected_count += 1
+      output.print green '.'
+    end
+
+    def final_summary
+      output.puts "\nInspected: #{inspected_count}"
+      output.puts send(list_offences_color, "Offences: #{offences.size}")
+
+      offences.each { |file_path, status| puts_offence(file_path, status) }
+    end
+
+    def offences?
+      @offences.any?
+    end
+
+    def log_correction(file_path)
+      offences[file_path] = :corrected
+    end
+
+    private
+
+    attr_reader :offences, :inspected_count, :output
+
+    def puts_offence(file_path, status)
+      case status
+      when :detected
+        output.puts yellow file_path
+      when :corrected
+        output.puts("#{yellow(file_path)} #{green('CORRECTED')}")
+      end
+    end
+
+    def list_offences_color
+      if offences?
+        :red
+      else
+        :green
+      end
+    end
+
+    def red(string)
+      with_color(31, string)
+    end
+
+    def yellow(string)
+      with_color(33, string)
+    end
+
+    def green(string)
+      with_color(32, string)
+    end
+
+    def with_color(color, string)
+      "\e[#{color}m#{string}\e[0m"
+    end
+  end
+end

data/lib/yalphabetize/offence_detector.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Yalphabetize
+  class OffenceDetector
+    def initialize(stream_node, order_checker_class:)
+      @stream_node = stream_node
+      @order_checker_class = order_checker_class
+    end
+
+    def offences?
+      !alphabetized?(stream_node)
+    end
+
+    private
+
+    attr_reader :stream_node, :order_checker_class
+
+    def alphabetized?(node)
+      return false if node.mapping? && !alphabetized_children?(node)
+
+      if node.children
+        each_child_also_alphabetized?(node.children)
+      else
+        true
+      end
+    end
+
+    def alphabetized_children?(node)
+      node.children.each_slice(2).each_cons(2).all? do |a, b|
+        order_checker_class.ordered?(a.first.value, b.first.value)
+      end
+    end
+
+    def each_child_also_alphabetized?(children)
+      children.flatten&.inject(true) { |bool, child_node| bool && alphabetized?(child_node) }
+    end
+  end
+end

data/lib/yalphabetize/option_parser.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Yalphabetize
+  class OptionParser
+    PARSER = ::OptionParser.new do |o|
+      o.banner = 'Usage: yalphabetize [options] [file1, file2, ...]'
+
+      o.on('-a', '--autocorrect', 'Automatically alphabetize inspected yaml files')
+      o.on('-h', '--help', 'Prints this help') do
+        puts o
+        Kernel.exit
+      end
+    end
+
+    def self.parse!(argv)
+      {}.tap { |options| PARSER.parse!(argv, into: options) }
+    end
+  end
+end

data/lib/yalphabetize/order_checkers/alphabetical_then_capitalized_first.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# AaBb
+module Yalphabetize
+  module OrderCheckers
+    class AlphabeticalThenCapitalizedFirst < Base
+      def self.compare(string, other_string)
+        alphabetical_comparison(string, other_string).nonzero? || string <=> other_string
+      end
+    end
+  end
+end

data/lib/yalphabetize/order_checkers/alphabetical_then_capitalized_last.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# aAbB
+module Yalphabetize
+  module OrderCheckers
+    class AlphabeticalThenCapitalizedLast < Base
+      def self.compare(string, other_string)
+        alphabetical_comparison(string, other_string).nonzero? || string.swapcase <=> other_string.swapcase
+      end
+    end
+  end
+end

data/lib/yalphabetize/order_checkers/base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Yalphabetize
+  module OrderCheckers
+    class Base
+      def self.ordered?(string, other_string)
+        !compare(string, other_string).positive?
+      end
+
+      private_class_method def self.alphabetical_comparison(string, other_string)
+        string.downcase <=> other_string.downcase
+      end
+    end
+  end
+end

data/lib/yalphabetize/order_checkers/capitalized_first_then_alphabetical.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Yalphabetize
+  module OrderCheckers
+    class CapitalizedFirstThenAlphabetical < Base
+      def self.compare(string, other_string)
+        (string <=> other_string)
+      end
+    end
+  end
+end

data/lib/yalphabetize/order_checkers/capitalized_last_then_alphabetical.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Yalphabetize
+  module OrderCheckers
+    class CapitalizedLastThenAlphabetical < Base
+      def self.compare(string, other_string)
+        (string.swapcase <=> other_string.swapcase)
+      end
+    end
+  end
+end

data/lib/yalphabetize/order_checkers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Yalphabetize
+  module OrderCheckers
+    DEFAULT = CapitalizedFirstThenAlphabetical
+
+    TOKEN_MAPPING = {
+      'abAB' => CapitalizedLastThenAlphabetical,
+      'aAbB' => AlphabeticalThenCapitalizedLast,
+      'AaBb' => AlphabeticalThenCapitalizedFirst,
+      'ABab' => CapitalizedFirstThenAlphabetical
+    }.freeze
+  end
+end

data/lib/yalphabetize/parsing_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'psych'
+
+module Yalphabetize
+  class ParsingError < Psych::SyntaxError; end
+end

data/lib/yalphabetize/reader.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'psych'
+require 'securerandom'
+
+module Yalphabetize
+  class Reader
+    def initialize(path)
+      @path = path
+      @interpolations_mapping = {}
+    end
+
+    def to_ast
+      substitute_interpolations
+      stream_node
+    end
+
+    attr_reader :interpolations_mapping
+
+    private
+
+    attr_reader :path
+
+    def substitute_interpolations
+      erb_compiler = Yalphabetize::ErbCompiler.new
+      erb_compiler.compile(file)
+
+      erb_compiler.content.each do |interpolation|
+        uuid = SecureRandom.uuid
+        file.sub!(interpolation, uuid)
+        interpolations_mapping[uuid] = interpolation
+      end
+    end
+
+    def file
+      @_file ||= File.read(path)
+    end
+
+    def stream_node
+      @_stream_node ||= Psych.parse_stream file
+    rescue Psych::SyntaxError => e
+      raise Yalphabetize::ParsingError.new(
+        path,
+        e.line,
+        e.column,
+        e.offset,
+        e.problem,
+        e.context
+      )
+    end
+  end
+end

data/lib/yalphabetize/sequence_indenter.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'psych'
+
+module Yalphabetize
+  class SequenceIndenter
+    def self.call(content)
+      new(content).call
+    end
+
+    def initialize(content)
+      @content = content
+    end
+
+    def call
+      return unless Yalphabetize.config['indent_sequences']
+
+      find_lines_to_indent
+      indent!
+      file_lines.join
+    end
+
+    private
+
+    attr_reader :content
+
+    def find_lines_to_indent
+      @nodes_to_indent = []
+
+      stream_node.each do |node|
+        next if node.document?
+
+        block_sequence_nodes(node)&.each do |sequence_node|
+          @nodes_to_indent.push(*sequence_node.children)
+        end
+      end
+    end
+
+    def block_sequence_nodes(node)
+      node.children&.select { |child_node| child_node.sequence? && child_node.style == 1 }
+    end
+
+    def stream_node
+      Psych.parse_stream content
+    end
+
+    def indent!
+      @nodes_to_indent.each do |node|
+        file_lines[node.start_line..node.end_line].each do |line|
+          line.gsub!(line, "  #{line}")
+        end
+      end
+    end
+
+    def file_lines
+      @_file_lines ||= content.each_line.to_a
+    end
+  end
+end

data/lib/yalphabetize/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Yalphabetize
+  class Version
+    STRING = '0.4.0'
+  end
+end

data/lib/yalphabetize/writer.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Yalphabetize
+  class Writer
+    MAX_LINE_WIDTH = -1
+
+    def initialize(stream_node, path, interpolations_mapping)
+      @stream_node = stream_node
+      @path = path
+      @interpolations_mapping = interpolations_mapping
+    end
+
+    def call
+      indent_sequences
+      replace_interpolations
+
+      File.open(path, 'w') do |file|
+        file.write new_file_content
+      end
+    end
+
+    private
+
+    attr_reader :stream_node, :path, :interpolations_mapping
+
+    def new_file_content
+      @_new_file_content ||= stream_node.to_yaml(nil, line_width: MAX_LINE_WIDTH)
+    end
+
+    def replace_interpolations
+      interpolations_mapping.each do |uuid, interpolation|
+        new_file_content.sub!(uuid, interpolation)
+      end
+    end
+
+    def indent_sequences
+      @_new_file_content = SequenceIndenter.call(new_file_content)
+    end
+  end
+end

data/lib/yalphabetize/yalphabetizer.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Yalphabetize
+  class Yalphabetizer
+    def self.call(args = [], options = {})
+      new(args, options).call
+    end
+
+    def initialize(args, options)
+      @args = args
+      @options = options
+    end
+
+    def call
+      initial_log
+      process_files
+      final_log
+    end
+
+    private
+
+    attr_reader :args, :options
+
+    def initial_log
+      logger.initial_summary(file_paths)
+    end
+
+    def process_files
+      file_paths.each(&method(:process_file))
+    end
+
+    def process_file(file_path)
+      file_yalphabetizer_class.new(
+        file_path,
+        reader_class: reader_class,
+        offence_detector_class: offence_detector_class,
+        logger: logger,
+        autocorrect: options[:autocorrect],
+        alphabetizer_class: alphabetizer_class,
+        writer_class: writer_class,
+        order_checker_class: order_checker_class
+      ).call
+    end
+
+    def file_paths
+      @_file_paths ||= finder.paths(only: only_paths, exclude: Yalphabetize.config['exclude'])
+    end
+
+    def only_paths
+      if args.any?
+        args
+      else
+        Yalphabetize.config['only']
+      end
+    end
+
+    def final_log
+      logger.final_summary
+      logger.offences? ? 1 : 0
+    end
+
+    def reader_class
+      Yalphabetize::Reader
+    end
+
+    def finder
+      Yalphabetize::YamlFinder
+    end
+
+    def alphabetizer_class
+      Yalphabetize::Alphabetizer
+    end
+
+    def writer_class
+      Yalphabetize::Writer
+    end
+
+    def offence_detector_class
+      Yalphabetize::OffenceDetector
+    end
+
+    def logger
+      @_logger ||= Yalphabetize::Logger.new
+    end
+
+    def file_yalphabetizer_class
+      Yalphabetize::FileYalphabetizer
+    end
+
+    def order_checker_class
+      OrderCheckers::TOKEN_MAPPING[Yalphabetize.config['sort_by']]
+    end
+  end
+end

data/lib/yalphabetize/yaml_finder.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Yalphabetize
+  class YamlFinder
+    YAML_EXTENSIONS = %w[.yml .yaml].freeze
+
+    def self.paths(only:, exclude:)
+      if exclude.any?
+        new.paths(only) - new.paths(exclude)
+      else
+        new.paths(only)
+      end
+    end
+
+    def initialize
+      @files = []
+    end
+
+    def paths(paths)
+      if paths.empty?
+        files << files_in_dir
+      else
+        process_paths(paths)
+      end
+
+      files.flatten.select(&method(:valid?)).map { |f| File.expand_path(f) }.uniq
+    end
+
+    private
+
+    attr_reader :files
+
+    def process_paths(paths)
+      paths.uniq.each do |path|
+        files << if glob?(path)
+                   files_in_glob(path)
+                 elsif File.directory?(path)
+                   files_in_dir(path)
+                 else
+                   path
+                 end
+      end
+    end
+
+    def files_in_glob(glob)
+      files_in_dir([glob, glob.gsub('**/', '').gsub('**', '')].uniq)
+    end
+
+    def files_in_dir(dir = Dir.pwd)
+      return if `sh -c 'command -v git'`.empty?
+
+      output, _error, status = Open3.capture3(
+        'git', 'ls-files', '-z', *Array(dir),
+        '--exclude-standard', '--others', '--cached', '--modified'
+      )
+
+      output.split("\0").uniq.map { |git_file| "#{Dir.pwd}/#{git_file}" } if status.success?
+    end
+
+    def valid?(path)
+      exists?(path) && yml?(path)
+    end
+
+    def exists?(path)
+      File.exist?(path)
+    end
+
+    def yml?(path)
+      YAML_EXTENSIONS.include? File.extname(path)
+    end
+
+    def glob?(path)
+      path.include?('*')
+    end
+  end
+end

data/lib/yalphabetize.rb

@@ -1,8 +1,46 @@
-class Yalphabetize
-  def self.call
-    {
-      a: :b,
-      c: :d
-    }
+# frozen_string_literal: true
+
+require_relative 'yalphabetize/aliaser'
+require_relative 'yalphabetize/alphabetizer'
+require_relative 'yalphabetize/cli'
+require_relative 'yalphabetize/erb_compiler'
+require_relative 'yalphabetize/file_yalphabetizer'
+require_relative 'yalphabetize/logger'
+require_relative 'yalphabetize/offence_detector'
+require_relative 'yalphabetize/option_parser'
+require_relative 'yalphabetize/order_checkers/base'
+require_relative 'yalphabetize/order_checkers/alphabetical_then_capitalized_first'
+require_relative 'yalphabetize/order_checkers/alphabetical_then_capitalized_last'
+require_relative 'yalphabetize/order_checkers/capitalized_last_then_alphabetical'
+require_relative 'yalphabetize/order_checkers/capitalized_first_then_alphabetical'
+require_relative 'yalphabetize/order_checkers'
+require_relative 'yalphabetize/parsing_error'
+require_relative 'yalphabetize/reader'
+require_relative 'yalphabetize/sequence_indenter'
+require_relative 'yalphabetize/version'
+require_relative 'yalphabetize/writer'
+require_relative 'yalphabetize/yalphabetizer'
+require_relative 'yalphabetize/yaml_finder'
+
+module Yalphabetize
+  class << self
+    DEFAULT_CONFIG = {
+      'indent_sequences' => true,
+      'exclude' => [],
+      'only' => [],
+      'sort_by' => 'ABab'
+    }.freeze
+
+    def config
+      @_config ||= begin
+        specified = if File.exist?('.yalphabetize.yml')
+                      Psych.load_file('.yalphabetize.yml') || {}
+                    else
+                      {}
+                    end
+
+        DEFAULT_CONFIG.merge(specified)
+      end
+    end
   end
 end

metadata

@@ -1,26 +1,134 @@
 --- !ruby/object:Gem::Specification
 name: yalphabetize
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Sam Jenkins
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-21 00:00:00.000000000 Z
-dependencies: []
-description: 
-email: 
-executables: []
+date: 2022-01-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: psych
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+executables:
+- yalphabetize
 extensions: []
 extra_rdoc_files: []
 files:
+- bin/yalphabetize
 - lib/yalphabetize.rb
-homepage: 
+- lib/yalphabetize/aliaser.rb
+- lib/yalphabetize/alphabetizer.rb
+- lib/yalphabetize/cli.rb
+- lib/yalphabetize/erb_compiler.rb
+- lib/yalphabetize/file_yalphabetizer.rb
+- lib/yalphabetize/logger.rb
+- lib/yalphabetize/offence_detector.rb
+- lib/yalphabetize/option_parser.rb
+- lib/yalphabetize/order_checkers.rb
+- lib/yalphabetize/order_checkers/alphabetical_then_capitalized_first.rb
+- lib/yalphabetize/order_checkers/alphabetical_then_capitalized_last.rb
+- lib/yalphabetize/order_checkers/base.rb
+- lib/yalphabetize/order_checkers/capitalized_first_then_alphabetical.rb
+- lib/yalphabetize/order_checkers/capitalized_last_then_alphabetical.rb
+- lib/yalphabetize/parsing_error.rb
+- lib/yalphabetize/reader.rb
+- lib/yalphabetize/sequence_indenter.rb
+- lib/yalphabetize/version.rb
+- lib/yalphabetize/writer.rb
+- lib/yalphabetize/yalphabetizer.rb
+- lib/yalphabetize/yaml_finder.rb
+homepage:
 licenses: []
-metadata: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -35,8 +143,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.0.3.1
+signing_key:
 specification_version: 4
 summary: Alphabetize your YAML files
 test_files: []