standard 0.0.9

data/config/base.yml

@@ -0,0 +1,230 @@
+AllCops:
+  # Prevent RuboCop from exploding when it finds an older-than-2.2 .ruby-version
+  TargetRubyVersion: 2.5
+
+Bundler/OrderedGems:
+  Enabled: false
+
+Gemspec/OrderedDependencies:
+  Enabled: false
+
+Layout/AlignParameters:
+  EnforcedStyle: with_fixed_indentation
+
+Layout/AlignHash:
+  EnforcedLastArgumentHashStyle: always_ignore
+
+# Disabled because IndentOneStep can't be configured for one-liner cases. See:
+# https://github.com/rubocop-hq/rubocop/issues/6447
+Layout/CaseIndentation:
+  Enabled: false
+
+Layout/DotPosition:
+  EnforcedStyle: trailing
+
+Layout/EmptyLineAfterGuardClause:
+  Enabled: false
+
+Layout/EndAlignment:
+  EnforcedStyleAlignWith: variable
+
+Layout/FirstParameterIndentation:
+  EnforcedStyle: consistent
+
+Layout/IndentHash:
+  EnforcedStyle: consistent
+
+Layout/IndentArray:
+  EnforcedStyle: consistent
+
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+
+# Disabled without this:
+# http://github.com/rubocop-hq/rubocop/issues/6446
+Layout/SpaceInsideBlockBraces:
+  Enabled: false
+
+Layout/SpaceInsideHashLiteralBraces:
+  EnforcedStyle: no_space
+
+Lint/ScriptPermission:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/BlockNesting:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/LineLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Naming/PredicateName:
+  Enabled: false
+
+Naming/UncommunicativeMethodParamName:
+  Enabled: false
+
+Naming/VariableNumber:
+  Enabled: false
+
+Performance/TimesMap:
+  Enabled: false
+
+Security/MarshalLoad:
+  Enabled: false
+
+Standard/SemanticBlocks:
+  ProceduralMethods:
+    - benchmark
+    - bm
+    - bmbm
+    - create
+    - each_with_object
+    - measure
+    - new
+    - realtime
+    - tap
+    - with_object
+  FunctionalMethods:
+    - let
+    - let!
+    - subject
+    - watch
+    - Given
+    - Given!
+    - Invariant
+    - Then
+    - And
+  IgnoredMethods:
+    - lambda
+    - proc
+    - it
+    - When
+
+Style/AsciiComments:
+  Enabled: false
+
+Style/BlockDelimiters:
+  Enabled: false
+
+Style/BracesAroundHashParameters:
+  Enabled: false
+
+Style/CaseEquality:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/CommentAnnotation:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/EmptyMethod:
+  EnforcedStyle: expanded
+
+Style/ExpandPathArguments:
+  Enabled: false
+
+Style/FormatStringToken:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  EnforcedStyle: never
+
+Style/GuardClause:
+  Enabled: false
+
+Style/HashSyntax:
+  EnforcedStyle: ruby19_no_mixed_keys
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/InverseMethods:
+  Enabled: false
+
+Style/MethodDefParentheses:
+  Enabled: false
+
+Style/MultilineBlockChain:
+  Enabled: false
+
+Style/MultilineTernaryOperator:
+  Enabled: false
+
+Style/MultipleComparison:
+  Enabled: false
+
+Style/MutableConstant:
+  Enabled: false
+
+Style/NumericLiterals:
+  Enabled: false
+
+Style/NumericPredicate:
+  Enabled: false
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Style/RescueStandardError:
+  EnforcedStyle: implicit
+
+Style/SignalException:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/StructInheritance:
+  Enabled: false
+
+Style/SymbolArray:
+  Enabled: false
+
+Style/TrailingCommaInArguments:
+  Enabled: false
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/WordArray:
+  Enabled: false
+
+Style/ZeroLengthPredicate:
+  Enabled: false

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

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/cli.rb

@@ -0,0 +1,36 @@
+require_relative "config"
+
+module Standard
+  class Cli
+    SUCCESS_STATUS_CODE = 0
+    FAILURE_STATUS_CODE = 1
+
+    def initialize(argv)
+      @config = Config.new(argv)
+    end
+
+    def run
+      rubocop_config = @config.to_rubocop
+      runner = RuboCop::Runner.new(
+        rubocop_config.options,
+        rubocop_config.config_store
+      )
+
+      run_succeeded = runner.run(rubocop_config.paths)
+
+      if run_succeeded
+        SUCCESS_STATUS_CODE
+      else
+        (runner.warnings + runner.errors).each do |message|
+          warn message
+        end
+        puts <<-CALL_TO_ACTION.gsub(/^ {10}/, "")
+
+          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
+        FAILURE_STATUS_CODE
+      end
+    end
+  end
+end

data/lib/standard/config.rb

@@ -0,0 +1,126 @@
+require "rubocop"
+require "pathname"
+require "yaml"
+require_relative "file_finder"
+require_relative "formatter"
+
+module Standard
+  class Config
+    RuboCopConfig = Struct.new(:paths, :options, :config_store)
+
+    def initialize(argv)
+      filtered_argv, fix_flag = parse_argv(argv)
+      @rubocop_options, @paths = RuboCop::Options.new.parse(filtered_argv)
+      @standard_yml_path = FileFinder.new.call(".standard.yml", Dir.pwd)
+      @standard_config = init_standard_config(@standard_yml_path, fix_flag)
+    end
+
+    def to_rubocop
+      RuboCopConfig.new(
+        @paths,
+        wrap_rubocop_options(@rubocop_options),
+        RuboCop::ConfigStore.new.tap(&method(:mutate_config_store!))
+      )
+    end
+
+    private
+
+    # Filtered b/c RuboCop will switch to --only Layout when --fix is set (undocumented behavior)
+    def parse_argv(argv)
+      filtered_argv = argv.dup
+      fix_flag = !!filtered_argv.delete("--fix")
+      [filtered_argv, fix_flag]
+    end
+
+    def init_standard_config(yml_path, fix_flag)
+      user_config = YAML.load_file(Pathname.new(Dir.pwd).join(yml_path)) if yml_path
+      user_config ||= {}
+
+      {
+        :fix => fix_flag || !!user_config["fix"],
+        :format => user_config["format"],
+        :ignore => expand_ignore_config(user_config["ignore"]),
+        :parallel => !!user_config["parallel"],
+        :ruby_version => ruby_version(user_config["ruby_version"] || RUBY_VERSION),
+      }
+    end
+
+    def wrap_rubocop_options(rubocop_options)
+      {
+        :auto_correct => @standard_config[:fix],
+        :safe_auto_correct => @standard_config[:fix],
+        :formatters => [[@standard_config[:format] || "Standard::Formatter", nil]],
+        :parallel => @standard_config[:parallel],
+      }.merge(rubocop_options)
+    end
+
+    def mutate_config_store!(config_store)
+      config_store.options_config = rubocop_yaml_path(@standard_config[:ruby_version])
+      options_config = config_store.instance_variable_get("@options_config")
+
+      options_config["AllCops"]["TargetRubyVersion"] = floatify_version(
+        minimum_rubocop_supported_version(@standard_config[:ruby_version])
+      )
+
+      @standard_config[:ignore].each do |(path, cops)|
+        cops.each do |cop|
+          options_config[cop] ||= {}
+          options_config[cop]["Exclude"] ||= []
+          options_config[cop]["Exclude"] |= [Pathname.new(@standard_yml_path).dirname.join(path).to_s]
+        end
+      end
+    end
+
+    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
+
+    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 ruby_version(version)
+      Gem::Version.new(version)
+    end
+
+    def floatify_version(version)
+      major, minor = version.segments
+      "#{major}.#{minor}".to_f # lol
+    end
+
+    def minimum_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 arrayify(object)
+      if object.nil?
+        []
+      elsif object.respond_to?(:to_ary)
+        object.to_ary || [object]
+      else
+        [object]
+      end
+    end
+  end
+end

data/lib/standard/cop/semantic_blocks.rb

@@ -0,0 +1,161 @@
+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?
+          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/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
+        "standard --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/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/version.rb

@@ -0,0 +1,3 @@
+module Standard
+  VERSION = "0.0.9"
+end