standard 0.0.34

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/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
+      ".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.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/detects_fixability.rb

@@ -0,0 +1,20 @@
+module Standard
+  class DetectsFixability
+    def call(offenses)
+      offenses.any? { |offense|
+        cop = cop_instance(offense.cop_name)
+        cop.support_autocorrect? && safe?(cop)
+      }
+    end
+
+    private
+
+    def cop_instance(cop_name)
+      RuboCop::Cop.const_get(cop_name.gsub("/", "::")).new
+    end
+
+    def safe?(cop)
+      cop.cop_config.fetch("SafeAutoCorrect", true)
+    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,79 @@
+require "rubocop"
+require_relative "detects_fixability"
+
+module Standard
+  class Formatter < RuboCop::Formatter::BaseFormatter
+    CALL_TO_ACTION_MESSAGE = <<-CALL_TO_ACTION.gsub(/^ {6}/, "")
+      Notice: Disagree with these rules? While StandardRB is pre-1.0.0, feel free to submit suggestions to:
+        https://github.com/testdouble/standard/issues/new
+    CALL_TO_ACTION
+
+    def initialize(*args)
+      super
+      @detects_fixability = DetectsFixability.new
+      @header_printed_already = false
+      @fix_suggestion_printed_already = false
+      @any_uncorrected_offenses = false
+    end
+
+    def file_finished(file, offenses)
+      return unless (uncorrected_offenses = offenses.reject(&:corrected?)).any?
+      @any_uncorrected_offenses = true
+
+      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
+
+    def finished(_)
+      print_call_for_feedback if @any_uncorrected_offenses
+    end
+
+    private
+
+    def print_header_once
+      return if @header_printed_already
+
+      output.print <<-HEADER.gsub(/^ {8}/, "")
+        standard: Use Ruby Standard Style (https://github.com/testdouble/standard)
+      HEADER
+
+      @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 <<-HEADER.gsub(/^ {10}/, "")
+          standard: Run `#{command}` to automatically fix some problems.
+        HEADER
+        @fix_suggestion_printed_already = true
+      end
+    end
+
+    def path_to(file)
+      Pathname.new(file).relative_path_from(Pathname.new(Dir.pwd))
+    end
+
+    def print_call_for_feedback
+      output.print "\n"
+      output.print CALL_TO_ACTION_MESSAGE
+    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,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,64 @@
+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", "--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
+      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