standard-mkv 1.3.0

data/config/ruby-1.8.yml

@@ -0,0 +1,7 @@
+inherit_from: ./ruby-1.9.yml
+
+Style/HashSyntax:
+  EnforcedStyle: hash_rockets
+
+Style/Lambda:
+  Enabled: false

data/config/ruby-1.9.yml

@@ -0,0 +1,7 @@
+inherit_from: ./ruby-2.2.yml
+
+Style/Encoding:
+  Enabled: false
+
+Style/HashConversion:
+  Enabled: false

data/config/ruby-2.2.yml

@@ -0,0 +1,5 @@
+inherit_from: ./ruby-2.3.yml
+
+Layout:
+  HeredocIndentation:
+    Enabled: false

data/config/ruby-2.3.yml

@@ -0,0 +1 @@
+inherit_from: ./ruby-2.4.yml

data/config/ruby-2.4.yml

@@ -0,0 +1,4 @@
+inherit_from: ./ruby-2.5.yml
+
+AllCops:
+  TargetRubyVersion: 2.5 # The oldest supported

data/config/ruby-2.5.yml

@@ -0,0 +1,7 @@
+inherit_from: ./ruby-2.7.yml
+
+AllCops:
+  TargetRubyVersion: 2.5
+
+Style/SlicingWithRange:
+  Enabled: false

data/config/ruby-2.7.yml

@@ -0,0 +1,7 @@
+inherit_from: ./base.yml
+
+AllCops:
+  TargetRubyVersion: 2.7
+
+Style/HashExcept:
+  Enabled: true

data/docs/RELEASE.md

@@ -0,0 +1,42 @@
+# How to release Standard Ruby
+
+Because this gem was generated with the [bundler `gem`
+command](https://bundler.io/man/bundle-gem.1.html), [our Rakefile](/Rakefile)
+loads `bundler/gem_tasks`, which provides a lot of the commands one needs
+to manage a gem's release lifecycle:
+
+```
+$ rake -T
+rake build            # Build standard-x.x.x.gem into the pkg directory
+rake clean            # Remove any temporary products
+rake clobber          # Remove any generated files
+rake install          # Build and install standard-x.x.x.gem into system gems
+rake install:local    # Build and install standard-x.x.x.gem into system gems without network access
+rake release[remote]  # Create tag vx.x.x and build and push standard-0.5.2.gem to rubygems.org
+```
+
+Most of these commands are depended on (read: run by) `rake release`, which is
+really the only one we'll need for releasing the gem to
+[Rubygems.org](https://rubygems.org/gems/standard).
+
+## Release steps
+
+1. Make sure git is up to date and `bundle exec rake` exits cleanly
+2. If you upgraded a Rubocop dependency, be sure to lock it down in
+   `standard.gemspec`. To avoid being broken transitively, we stick to exact
+   release dependencies (e.g. "0.91.0" instead of "~> 0.91")
+3. Bump the appropriate version segment in `lib/standard/version.rb` (basic
+   semantic versioning rules apply; if the release updates Rubocop, follow its
+   version bump at a minimum—if rubocop saw minor bump, we'll also bump the
+   minor version)
+4. Run `bundle` so that Bundler writes this version to `Gemfile.lock`
+5. Update `CHANGELOG.md` as exhaustively as you are able and set the top header
+   to that of the new version
+6. Commit `lib/standard/version.rb`, `Gemfile.lock`, and `CHANGELOG.md` together
+   with the message equal to the new version (e.g. "0.42.1")
+7. Finally, run `bundle exec rake release`, which will hopefully succeed
+8. Provide your multi-factor-auth token when prompted to finish publishing the
+   gem
+9. [Tweet](https://twitter.com) about your awesome new release! (Shameless
+   self-promotion is the most important part of open source software)
+

data/exe/standardrb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift("#{__dir__}/../lib")
+
+require "standard"
+
+exit Standard::Cli.new(ARGV).run

data/lib/standard/builds_config.rb

@@ -0,0 +1,36 @@
+require_relative "loads_yaml_config"
+require_relative "merges_settings"
+require_relative "creates_config_store"
+
+module Standard
+  Config = Struct.new(:runner, :paths, :rubocop_options, :rubocop_config_store)
+
+  class BuildsConfig
+    def initialize
+      @parses_cli_option = ParsesCliOption.new
+      @loads_yaml_config = LoadsYamlConfig.new
+      @merges_settings = MergesSettings.new
+      @creates_config_store = CreatesConfigStore.new
+    end
+
+    def call(argv, search_path = Dir.pwd)
+      standard_yaml_path = determine_yaml_file(argv, search_path, "--config", ".standard.yml")
+      todo_yaml_path = determine_yaml_file(argv, search_path, "--todo", ".standard_todo.yml")
+      standard_config = @loads_yaml_config.call(standard_yaml_path, todo_yaml_path)
+
+      settings = @merges_settings.call(argv, standard_config)
+      Config.new(
+        settings.runner,
+        settings.paths,
+        settings.options,
+        @creates_config_store.call(standard_config)
+      )
+    end
+
+    private
+
+    def determine_yaml_file(argv, search_path, option_name, default_file)
+      @parses_cli_option.call(argv, option_name) || FileFinder.new.call(default_file, search_path)
+    end
+  end
+end

data/lib/standard/cli.rb

@@ -0,0 +1,17 @@
+require_relative "builds_config"
+require_relative "loads_runner"
+
+module Standard
+  class Cli
+    def initialize(argv)
+      @argv = argv
+      @builds_config = BuildsConfig.new
+      @loads_runner = LoadsRunner.new
+    end
+
+    def run
+      config = @builds_config.call(@argv)
+      @loads_runner.call(config.runner).call(config).to_i
+    end
+  end
+end

data/lib/standard/cop/block_single_line_braces.rb

@@ -0,0 +1,96 @@
+module RuboCop::Cop
+  module Standard
+    # Check for uses of braces around single line blocks, but allows either
+    # braces or do/end for multi-line blocks.
+    #
+    # @example
+    #   # bad - single line block
+    #   items.each do |item| item / 5 end
+    #
+    #   # good - single line block
+    #   items.each { |item| item / 5 }
+    #
+    class BlockSingleLineBraces < RuboCop::Cop::Base
+      extend RuboCop::Cop::AutoCorrector
+
+      def on_send(node)
+        return unless node.arguments?
+        return if node.parenthesized?
+        return if node.operator_method? || node.assignment_method?
+
+        node.arguments.each do |arg|
+          get_blocks(arg) do |block|
+            # If there are no parentheses around the arguments, then braces
+            # and do-end have different meaning due to how they bind, so we
+            # allow either.
+            ignore_node(block)
+          end
+        end
+      end
+
+      def on_block(node)
+        return if ignored_node?(node)
+        return if proper_block_style?(node)
+
+        message = message(node)
+        add_offense(node.loc.begin, message: message) do |corrector|
+          autocorrect(corrector, node)
+        end
+      end
+
+      private
+
+      def get_blocks(node, &block)
+        case node.type
+        when :block
+          yield node
+        when :send
+          get_blocks(node.receiver, &block) if node.receiver
+        when :hash
+          # A hash which is passed as method argument may have no braces
+          # In that case, one of the K/V pairs could contain a block node
+          # which could change in meaning if do...end replaced {...}
+          return if node.braces?
+
+          node.each_child_node { |child| get_blocks(child, &block) }
+        when :pair
+          node.each_child_node { |child| get_blocks(child, &block) }
+        end
+      end
+
+      def proper_block_style?(node)
+        node.multiline? || node.braces?
+      end
+
+      def message(node)
+        "Prefer `{...}` over `do...end` for single-line blocks."
+      end
+
+      def autocorrect(corrector, node)
+        return if correction_would_break_code?(node)
+
+        replace_do_end_with_braces(corrector, node.loc)
+      end
+
+      def correction_would_break_code?(node)
+        return unless node.keywords?
+
+        node.send_node.arguments? && !node.send_node.parenthesized?
+      end
+
+      def replace_do_end_with_braces(corrector, loc)
+        b = loc.begin
+        e = loc.end
+
+        corrector.insert_after(b, " ") unless whitespace_after?(b, 2)
+
+        corrector.replace(b, "{")
+        corrector.replace(e, "}")
+      end
+
+      def whitespace_after?(range, length = 1)
+        /\s/.match?(range.source_buffer.source[range.begin_pos + length, 1])
+      end
+    end
+  end
+end

data/lib/standard/creates_config_store/assigns_rubocop_yaml.rb

@@ -0,0 +1,34 @@
+require "pathname"
+
+class Standard::CreatesConfigStore
+  class AssignsRubocopYaml
+    def call(config_store, standard_config)
+      config_store.options_config = rubocop_yaml_path(standard_config[:ruby_version])
+      config_store.instance_variable_get("@options_config")
+    end
+
+    private
+
+    def rubocop_yaml_path(desired_version)
+      file_name = if desired_version < Gem::Version.new("1.9")
+        "ruby-1.8.yml"
+      elsif desired_version < Gem::Version.new("2.0")
+        "ruby-1.9.yml"
+      elsif desired_version < Gem::Version.new("2.3")
+        "ruby-2.2.yml"
+      elsif desired_version < Gem::Version.new("2.4")
+        "ruby-2.3.yml"
+      elsif desired_version < Gem::Version.new("2.5")
+        "ruby-2.4.yml"
+      elsif desired_version < Gem::Version.new("2.6")
+        "ruby-2.5.yml"
+      elsif desired_version < Gem::Version.new("3.0")
+        "ruby-2.7.yml"
+      else
+        "base.yml"
+      end
+
+      Pathname.new(__dir__).join("../../../config/#{file_name}")
+    end
+  end
+end

data/lib/standard/creates_config_store/configures_ignored_paths.rb

@@ -0,0 +1,45 @@
+class Standard::CreatesConfigStore
+  class ConfiguresIgnoredPaths
+    DEFAULT_IGNORES = [
+      # Match RuboCop's defaults: https://github.com/rubocop-hq/rubocop/blob/v0.61.1/config/default.yml#L60-L63
+      ".git/**/*",
+      "node_modules/**/*",
+      "vendor/**/*",
+      # Standard's own default ignores:
+      "bin/*",
+      "db/schema.rb",
+      "tmp/**/*"
+    ].map { |path| [path, ["AllCops"]] }.freeze
+
+    def call(options_config, standard_config)
+      ignored_patterns(standard_config).each do |(path, cops)|
+        cops.each do |cop|
+          options_config[cop] ||= {}
+          options_config[cop]["Exclude"] ||= []
+          options_config[cop]["Exclude"] |= [
+            absolutify(standard_config[:config_root], path)
+          ]
+        end
+      end
+    end
+
+    private
+
+    def ignored_patterns(standard_config)
+      (standard_config[:default_ignores] ? DEFAULT_IGNORES : []) +
+        standard_config[:ignore]
+    end
+
+    def absolutify(config_root, path)
+      if !absolute?(path)
+        File.expand_path(File.join(config_root || Dir.pwd, path))
+      else
+        path
+      end
+    end
+
+    def absolute?(path)
+      path =~ %r{\A([A-Z]:)?/}
+    end
+  end
+end

data/lib/standard/creates_config_store/sets_target_ruby_version.rb

@@ -0,0 +1,25 @@
+class Standard::CreatesConfigStore
+  class SetsTargetRubyVersion
+    def call(options_config, standard_config)
+      options_config["AllCops"]["TargetRubyVersion"] = floatify_version(
+        max_rubocop_supported_version(standard_config[:ruby_version])
+      )
+    end
+
+    private
+
+    def max_rubocop_supported_version(desired_version)
+      rubocop_supported_version = Gem::Version.new("2.5")
+      if desired_version < rubocop_supported_version
+        rubocop_supported_version
+      else
+        desired_version
+      end
+    end
+
+    def floatify_version(version)
+      major, minor = version.segments
+      "#{major}.#{minor}".to_f # lol
+    end
+  end
+end

data/lib/standard/creates_config_store.rb

@@ -0,0 +1,23 @@
+require "rubocop"
+
+require_relative "creates_config_store/assigns_rubocop_yaml"
+require_relative "creates_config_store/sets_target_ruby_version"
+require_relative "creates_config_store/configures_ignored_paths"
+
+module Standard
+  class CreatesConfigStore
+    def initialize
+      @assigns_rubocop_yaml = AssignsRubocopYaml.new
+      @sets_target_ruby_version = SetsTargetRubyVersion.new
+      @configures_ignored_paths = ConfiguresIgnoredPaths.new
+    end
+
+    def call(standard_config)
+      RuboCop::ConfigStore.new.tap do |config_store|
+        options_config = @assigns_rubocop_yaml.call(config_store, standard_config)
+        @sets_target_ruby_version.call(options_config, standard_config)
+        @configures_ignored_paths.call(options_config, standard_config)
+      end
+    end
+  end
+end

data/lib/standard/detects_fixability.rb

@@ -0,0 +1,16 @@
+module Standard
+  class DetectsFixability
+    def call(offenses)
+      offenses.any? { |offense|
+        cop = cop_instance(offense.cop_name)
+        cop.correctable? && cop.safe_autocorrect?
+      }
+    end
+
+    private
+
+    def cop_instance(cop_name)
+      RuboCop::Cop.const_get(cop_name.gsub("/", "::")).new
+    end
+  end
+end

data/lib/standard/file_finder.rb

@@ -0,0 +1,13 @@
+require "pathname"
+
+module Standard
+  class FileFinder
+    def call(name, search_path)
+      Pathname.new(search_path).expand_path.ascend do |path|
+        if (file = path + name).exist?
+          return file.to_s
+        end
+      end
+    end
+  end
+end

data/lib/standard/formatter.rb

@@ -0,0 +1,90 @@
+require "yaml"
+require "rubocop"
+require_relative "detects_fixability"
+
+module Standard
+  class Formatter < RuboCop::Formatter::BaseFormatter
+    STANDARD_GREETING = <<-MSG.gsub(/^ {6}/, "")
+      standard: Use Ruby Standard Style (https://github.com/testdouble/standard)
+    MSG
+
+    def self.fixable_error_message(command)
+      <<-MSG.gsub(/^ {8}/, "")
+        standard: Run `#{command}` to automatically fix some problems.
+      MSG
+    end
+
+    def initialize(*args)
+      super
+      @detects_fixability = DetectsFixability.new
+      @header_printed_already = false
+      @fix_suggestion_printed_already = false
+    end
+
+    def started(_target_files)
+      print_todo_warning
+    end
+
+    def file_finished(file, offenses)
+      return unless (uncorrected_offenses = offenses.reject(&:corrected?)).any?
+
+      print_header_once
+      print_fix_suggestion_once(uncorrected_offenses)
+
+      uncorrected_offenses.each do |o|
+        output.printf("  %s:%d:%d: %s\n", path_to(file), o.line, o.real_column, o.message.tr("\n", " "))
+      end
+    end
+
+    private
+
+    def print_header_once
+      return if @header_printed_already
+
+      output.print STANDARD_GREETING
+
+      @header_printed_already = true
+    end
+
+    def print_fix_suggestion_once(offenses)
+      if !@fix_suggestion_printed_already && should_suggest_fix?(offenses)
+        command = if File.split($PROGRAM_NAME).last == "rake"
+          "rake standard:fix"
+        else
+          "standardrb --fix"
+        end
+
+        output.print self.class.fixable_error_message(command)
+        @fix_suggestion_printed_already = true
+      end
+    end
+
+    def print_todo_warning
+      todo_file = options[:todo_file]
+      return unless todo_file
+
+      todo_ignore_files = options[:todo_ignore_files]
+      return unless todo_ignore_files
+
+      output.print <<-HEADER.gsub(/^ {8}/, "")
+        WARNING: this project is being migrated to standard gradually via `#{todo_file}` and is ignoring these files:
+      HEADER
+
+      todo_ignore_files.each do |f|
+        output.printf("  %s\n", f)
+      end
+    end
+
+    def path_to(file)
+      Pathname.new(file).relative_path_from(Pathname.new(Dir.pwd))
+    end
+
+    def auto_correct_option_provided?
+      options[:auto_correct] || options[:safe_auto_correct]
+    end
+
+    def should_suggest_fix?(offenses)
+      !auto_correct_option_provided? && @detects_fixability.call(offenses)
+    end
+  end
+end

data/lib/standard/loads_runner.rb

@@ -0,0 +1,9 @@
+module Standard
+  class LoadsRunner
+    # Warning: clever metaprogramming. 99% of the time this is Runners::Rubocop
+    def call(command)
+      require_relative "runners/#{command}"
+      ::Standard::Runners.const_get(command.to_s.capitalize).new
+    end
+  end
+end

data/lib/standard/loads_yaml_config.rb

@@ -0,0 +1,59 @@
+require "yaml"
+require "pathname"
+require_relative "file_finder"
+require_relative "parses_cli_option"
+
+module Standard
+  class LoadsYamlConfig
+    def call(standard_yaml_path, todo_yaml_path)
+      standard_yaml = load_standard_yaml(standard_yaml_path)
+      todo_yaml = load_standard_yaml(todo_yaml_path)
+
+      construct_config(standard_yaml_path, standard_yaml, todo_yaml_path, todo_yaml)
+    end
+
+    private
+
+    def load_standard_yaml(yaml_path)
+      if yaml_path
+        YAML.load_file(yaml_path) || {}
+      else
+        {}
+      end
+    end
+
+    def construct_config(yaml_path, standard_yaml, todo_path, todo_yaml)
+      {
+        ruby_version: Gem::Version.new((standard_yaml["ruby_version"] || RUBY_VERSION)),
+        fix: !!standard_yaml["fix"],
+        format: standard_yaml["format"],
+        parallel: !!standard_yaml["parallel"],
+        ignore: expand_ignore_config(standard_yaml["ignore"]) + expand_ignore_config(todo_yaml["ignore"]),
+        default_ignores: standard_yaml.key?("default_ignores") ? !!standard_yaml["default_ignores"] : true,
+        config_root: yaml_path ? Pathname.new(yaml_path).dirname.to_s : nil,
+        todo_file: todo_path,
+        todo_ignore_files: (todo_yaml["ignore"] || []).map { |f| Hash === f ? f.keys.first : f }
+      }
+    end
+
+    def expand_ignore_config(ignore_config)
+      arrayify(ignore_config).map { |rule|
+        if rule.is_a?(String)
+          [rule, ["AllCops"]]
+        elsif rule.is_a?(Hash)
+          rule.entries.first
+        end
+      }
+    end
+
+    def arrayify(object)
+      if object.nil?
+        []
+      elsif object.respond_to?(:to_ary)
+        object.to_ary || [object]
+      else
+        [object]
+      end
+    end
+  end
+end

data/lib/standard/merges_settings.rb

@@ -0,0 +1,68 @@
+require "rubocop"
+
+module Standard
+  class MergesSettings
+    Settings = Struct.new(:runner, :options, :paths)
+
+    def call(argv, standard_yaml)
+      standard_argv, rubocop_argv = separate_argv(argv)
+      standard_cli_flags = parse_standard_argv(standard_argv)
+      rubocop_cli_flags, lint_paths = RuboCop::Options.new.parse(rubocop_argv)
+
+      Settings.new(
+        determine_command(standard_argv),
+        merge(standard_yaml, standard_cli_flags, without_banned(rubocop_cli_flags)),
+        lint_paths
+      )
+    end
+
+    private
+
+    def separate_argv(argv)
+      argv.partition { |flag|
+        ["--generate-todo", "--fix", "--no-fix", "--version", "-v", "--help", "-h"].include?(flag)
+      }
+    end
+
+    def parse_standard_argv(argv)
+      argv.each_with_object({}) { |arg, cli_flags|
+        if arg == "--fix"
+          cli_flags[:auto_correct] = true
+          cli_flags[:safe_auto_correct] = true
+        elsif arg == "--no-fix"
+          cli_flags[:auto_correct] = false
+          cli_flags[:safe_auto_correct] = false
+        end
+      }
+    end
+
+    def determine_command(argv)
+      if (argv & ["--help", "-h"]).any?
+        :help
+      elsif (argv & ["--version", "-v"]).any?
+        :version
+      elsif (argv & ["--generate-todo"]).any?
+        :genignore
+      else
+        :rubocop
+      end
+    end
+
+    def merge(standard_yaml, standard_cli_flags, rubocop_cli_flags)
+      {
+        auto_correct: standard_yaml[:fix],
+        safe_auto_correct: standard_yaml[:fix],
+        formatters: [[standard_yaml[:format] || "Standard::Formatter", nil]],
+        parallel: standard_yaml[:parallel],
+        todo_file: standard_yaml[:todo_file],
+        todo_ignore_files: standard_yaml[:todo_ignore_files]
+      }.merge(standard_cli_flags).merge(rubocop_cli_flags)
+    end
+
+    def without_banned(rubocop_cli_flags)
+      rubocop_cli_flags.tap do |flags|
+        flags.delete(:config)
+      end
+    end
+  end
+end

data/lib/standard/parses_cli_option.rb

@@ -0,0 +1,21 @@
+require "pathname"
+
+module Standard
+  class ParsesCliOption
+    def call(argv, option_name)
+      return unless (config_file = argv_value_for(argv, option_name))
+
+      resolved_config = Pathname.new(config_file)
+      if resolved_config.exist?
+        resolved_config.expand_path
+      else
+        raise "Configuration file \"#{resolved_config.expand_path}\" not found."
+      end
+    end
+
+    def argv_value_for(argv, option_name)
+      return unless (index = argv.index(option_name))
+      argv[index + 1]
+    end
+  end
+end

data/lib/standard/railtie.rb

@@ -0,0 +1,11 @@
+require "pathname"
+
+module Standard
+  class Railtie < Rails::Railtie
+    railtie_name :standard
+
+    rake_tasks do
+      load Pathname.new(__dir__).join("rake.rb")
+    end
+  end
+end