standard 0.0.18

data/config/ruby-1.8.yml

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

data/config/ruby-1.9.yml

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

data/config/ruby-2.2.yml

@@ -0,0 +1,8 @@
+inherit_from: ./base.yml
+
+AllCops:
+  TargetRubyVersion: 2.2
+
+Layout:
+  IndentHeredoc:
+    Enabled: false

data/exe/standard

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift("#{__dir__}/../lib")
+
+require "standard"
+
+warn <<-WARNING.gsub(/^ {2}/, "")
+  Error: Run 'standardrb' instead of 'standard'. We have renamed the gem's binary
+  to avoid naming conflicts with the StandardJS 'standard' bin in the event both
+  are on a user's PATH.
+
+  The 'standard' bin and this notice will be removed in an upcoming release.
+WARNING
+exit 1

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,26 @@
+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
+      @loads_yaml_config = LoadsYamlConfig.new
+      @merges_settings = MergesSettings.new
+      @creates_config_store = CreatesConfigStore.new
+    end
+
+    def call(argv, search_path = Dir.pwd)
+      standard_config = @loads_yaml_config.call(argv, search_path)
+      settings = @merges_settings.call(argv, standard_config)
+      Config.new(
+        settings.runner,
+        settings.paths,
+        settings.options,
+        @creates_config_store.call(standard_config)
+      )
+    end
+  end
+end

data/lib/standard/cli.rb

@@ -0,0 +1,23 @@
+require_relative "builds_config"
+require_relative "loads_runner"
+
+module Standard
+  class Cli
+    SUCCESS_STATUS_CODE = 0
+    FAILURE_STATUS_CODE = 1
+
+    def initialize(argv)
+      @argv = argv
+      @builds_config = BuildsConfig.new
+      @loads_runner = LoadsRunner.new
+    end
+
+    def run
+      config = @builds_config.call(@argv)
+
+      success = @loads_runner.call(config.runner).call(config)
+
+      success ? SUCCESS_STATUS_CODE : FAILURE_STATUS_CODE
+    end
+  end
+end

data/lib/standard/cop/semantic_blocks.rb

@@ -0,0 +1,162 @@
+module RuboCop::Cop
+  module Standard
+    class SemanticBlocks < RuboCop::Cop::Cop
+      include RuboCop::Cop::IgnoredMethods
+
+      def on_send(node)
+        return unless node.arguments?
+        return if node.parenthesized? || node.operator_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) || proper_block_style?(node)
+
+        add_offense(node, location: :begin)
+      end
+
+      def autocorrect(node)
+        return if correction_would_break_code?(node)
+
+        if node.single_line?
+          replace_do_end_with_braces(node.loc)
+        elsif node.braces?
+          replace_braces_with_do_end(node.loc)
+        else
+          replace_do_end_with_braces(node.loc)
+        end
+      end
+
+      private
+
+      def message(node)
+        if node.single_line?
+          "Prefer `{...}` over `do...end` for single-line blocks."
+        elsif node.loc.begin.source == "{"
+          "Prefer `do...end` over `{...}` for procedural blocks."
+        else
+          "Prefer `{...}` over `do...end` for functional blocks."
+        end
+      end
+
+      def replace_braces_with_do_end(loc)
+        b = loc.begin
+        e = loc.end
+
+        lambda do |corrector|
+          corrector.insert_before(b, " ") unless whitespace_before?(b)
+          corrector.insert_before(e, " ") unless whitespace_before?(e)
+          corrector.insert_after(b, " ") unless whitespace_after?(b)
+          corrector.replace(b, "do")
+          corrector.replace(e, "end")
+        end
+      end
+
+      def replace_do_end_with_braces(loc)
+        b = loc.begin
+        e = loc.end
+
+        lambda do |corrector|
+          corrector.insert_after(b, " ") unless whitespace_after?(b, 2)
+
+          corrector.replace(b, "{")
+          corrector.replace(e, "}")
+        end
+      end
+
+      def whitespace_before?(range)
+        range.source_buffer.source[range.begin_pos - 1, 1] =~ /\s/
+      end
+
+      def whitespace_after?(range, length = 1)
+        range.source_buffer.source[range.begin_pos + length, 1] =~ /\s/
+      end
+
+      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)
+        method_name = node.method_name
+
+        if ignored_method?(method_name)
+          true
+        elsif node.single_line?
+          node.braces?
+        elsif node.braces?
+          !procedural_method?(method_name) &&
+            (functional_method?(method_name) || functional_block?(node))
+        else
+          procedural_method?(method_name) || !return_value_used?(node)
+        end
+      end
+
+      def correction_would_break_code?(node)
+        return unless node.keywords?
+
+        node.send_node.arguments? && !node.send_node.parenthesized?
+      end
+
+      def functional_method?(method_name)
+        cop_config["FunctionalMethods"].map(&:to_sym).include?(method_name)
+      end
+
+      def functional_block?(node)
+        return_value_used?(node) || return_value_of_scope?(node)
+      end
+
+      def procedural_method?(method_name)
+        cop_config["ProceduralMethods"].map(&:to_sym).include?(method_name)
+      end
+
+      def return_value_used?(node)
+        return unless node.parent
+
+        # If there are parentheses around the block, check if that
+        # is being used.
+        if node.parent.begin_type?
+          return_value_used?(node.parent)
+        else
+          node.parent.assignment? || node.parent.send_type?
+        end
+      end
+
+      def return_value_of_scope?(node)
+        return unless node.parent
+
+        conditional?(node.parent) || array_or_range?(node.parent) ||
+          node.parent.children.last == node
+      end
+
+      def conditional?(node)
+        node.if_type? || node.or_type? || node.and_type?
+      end
+
+      def array_or_range?(node)
+        node.array_type? || node.irange_type? || node.erange_type?
+      end
+    end
+  end
+end

data/lib/standard/creates_config_store/assigns_rubocop_yaml.rb

@@ -0,0 +1,26 @@
+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"
+      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
+      "node_modules/**/*",
+      "vendor/**/*",
+      ".git/**/*",
+      "vendor/**/*",
+      # Standard's own default ignores:
+      "bin/*",
+      "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.2")
+      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/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,34 @@
+require "rubocop"
+
+module Standard
+  class Formatter < RuboCop::Formatter::BaseFormatter
+    def file_finished(file, offenses)
+      uncorrected_offenses = offenses.reject(&:corrected?)
+      print_header_once unless uncorrected_offenses.empty?
+      working_directory = Pathname.new(Dir.pwd)
+
+      uncorrected_offenses.each do |o|
+        absolute_path = Pathname.new(file)
+        relative_path = absolute_path.relative_path_from(working_directory)
+        output.printf("  %s:%d:%d: %s\n", relative_path, o.line, o.real_column, o.message.tr("\n", " "))
+      end
+    end
+
+    private
+
+    def print_header_once
+      return if @header_printed_already
+      command = if File.split($PROGRAM_NAME).last == "rake"
+        "rake standard:fix"
+      else
+        "standardrb --fix"
+      end
+
+      output.print <<-HEADER.gsub(/^ {8}/, "")
+        standard: Use Ruby Standard Style (https://github.com/testdouble/standard)
+        standard: Run `#{command}` to automatically fix some problems.
+      HEADER
+      @header_printed_already = true
+    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,60 @@
+require "yaml"
+require "pathname"
+require_relative "file_finder"
+require_relative "parses_cli_option"
+
+module Standard
+  class LoadsYamlConfig
+    def initialize
+      @parses_cli_option = ParsesCliOption.new
+    end
+
+    def call(argv, search_path)
+      yaml_path = @parses_cli_option.call(argv, "--config") ||
+                  FileFinder.new.call(".standard.yml", search_path)
+      construct_config(yaml_path, load_standard_yaml(yaml_path))
+    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)
+      {
+        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"]),
+        default_ignores: standard_yaml.key?("default_ignores") ? !!standard_yaml["default_ignores"] : true,
+        config_root: yaml_path ? Pathname.new(yaml_path).dirname.to_s : nil,
+      }
+    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,61 @@
+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|
+        ["--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
+        end
+      }
+    end
+
+    def determine_command(argv)
+      if (argv & ["--help", "-h"]).any?
+        :help
+      elsif (argv & ["--version", "-v"]).any?
+        :version
+      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],
+      }.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

data/lib/standard/rake.rb

@@ -0,0 +1,26 @@
+module Standard
+  module RakeSupport
+    # Allow command line flags set in STANDARDOPTS (like MiniTest's TESTOPTS)
+    def self.argvify
+      if ENV["STANDARDOPTS"]
+        ENV["STANDARDOPTS"].split(/\s+/)
+      else
+        []
+      end
+    end
+  end
+end
+
+desc "Lint with the Standard Ruby style guide"
+task :standard do
+  require "standard"
+  exit_code = Standard::Cli.new(Standard::RakeSupport.argvify).run
+  fail unless exit_code == 0
+end
+
+desc "Lint and automatically fix with the Standard Ruby style guide"
+task :"standard:fix" do
+  require "standard"
+  exit_code = Standard::Cli.new(Standard::RakeSupport.argvify + ["--fix"]).run
+  fail unless exit_code == 0
+end

data/lib/standard/rubocop/ext.rb

@@ -0,0 +1,7 @@
+module RuboCop
+  class Cop::Lint::AssignmentInCondition
+    def message(_)
+      "Wrap assignment in parentheses if intentional"
+    end
+  end
+end

data/lib/standard/runners/help.rb

@@ -0,0 +1,43 @@
+require_relative "../file_finder"
+
+module Standard
+  module Runners
+    class Help
+      def call(config)
+        puts <<-MESSAGE.gsub(/^ {10}/, "")
+          Usage: standardrb [--fix] [-vh] [--format <name>] [--] [FILE]...
+
+          Options:
+
+            --fix             Automatically fix failures where possible
+            --format <name>   Format output with any RuboCop formatter (e.g. "json")
+            -v, --version     Print the version of Standard
+            -h, --help        Print this message
+            FILE              Files to lint [default: ./]
+
+          Standard also forwards most CLI arguments to RuboCop. To see them, run:
+
+            $ rubocop --help
+
+          While Standard only offers a few configuration options, most can be set in
+          a `.standard.yml` file. For full documentation, please visit:
+
+            https://github.com/testdouble/standard
+
+          Having trouble? Here's some diagnostic information:
+
+                  Ruby version: #{RUBY_VERSION}
+             Current directory: #{Dir.pwd}
+               RuboCop version: #{RuboCop::Version.version}
+              Standard version: #{Standard::VERSION}
+          Standard config file: #{FileFinder.new.call(".standard.yml", Dir.pwd) || "[No file found]"}
+
+          Please report any problems (and include the above information) at the URL below:
+
+            https://github.com/testdouble/standard/issues/new
+
+        MESSAGE
+      end
+    end
+  end
+end