standard 0.0.13

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}/, "")
+  WARNING: Run 'standardrb' instead of 'standard'. We are renaming 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 will be removed in the next release of the standard gem
+WARNING
+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,37 @@
+require_relative "config"
+
+module Standard
+  class Cli
+    SUCCESS_STATUS_CODE = 0
+    FAILURE_STATUS_CODE = 1
+
+    def initialize(argv)
+      @argv = argv
+      @config = Config.new
+    end
+
+    def run
+      rubocop_config = @config.call(@argv)
+      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,25 @@
+require_relative "loads_yaml_config"
+require_relative "merges_settings"
+require_relative "creates_config_store"
+
+module Standard
+  class Config
+    RuboCopConfig = Struct.new(:paths, :options, :config_store)
+
+    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(search_path)
+      settings = @merges_settings.call(argv, standard_config)
+      RuboCopConfig.new(
+        settings.paths,
+        settings.options,
+        @creates_config_store.call(standard_config)
+      )
+    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.rb

@@ -0,0 +1,58 @@
+require "rubocop"
+require "pathname"
+
+module Standard
+  class CreatesConfigStore
+    def call(standard_config)
+      config_store = RuboCop::ConfigStore.new
+      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(
+        max_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_config[:config_root]).join(path).to_s,
+          ]
+        end
+      end
+
+      config_store
+    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
+
+    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/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/loads_yaml_config.rb

@@ -0,0 +1,53 @@
+require "yaml"
+require_relative "file_finder"
+require "pathname"
+
+module Standard
+  class LoadsYamlConfig
+    def call(search_path)
+      yaml_path = 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"]),
+        config_root: yaml_path ? Pathname.new(yaml_path).dirname.to_s : "",
+      }
+    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,44 @@
+require "rubocop"
+
+module Standard
+  class MergesSettings
+    Settings = Struct.new(: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(
+        merge(standard_yaml, standard_cli_flags, rubocop_cli_flags),
+        lint_paths
+      )
+    end
+
+    private
+
+    def separate_argv(argv)
+      argv.partition { |flag|
+        flag == "--fix"
+      }
+    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 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
+  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 = Gem::Version.new("0.0.13")
+end

data/lib/standard.rb

@@ -0,0 +1,13 @@
+require "rubocop"
+
+require "standard/rubocop/ext"
+
+require "standard/version"
+require "standard/cli"
+require "standard/railtie" if defined?(Rails)
+
+require "standard/formatter"
+require "standard/cop/semantic_blocks"
+
+module Standard
+end

data/standard.gemspec

@@ -0,0 +1,28 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "standard/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "standard"
+  spec.version       = Standard::VERSION
+  spec.authors       = ["Justin Searls"]
+  spec.email         = ["searls@gmail.com"]
+
+  spec.summary       = "Ruby Style Guide, with linter & automatic code fixer"
+  spec.homepage      = "https://github.com/testdouble/standard"
+
+  spec.files         = Dir.chdir(File.expand_path("..", __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rubocop", ">= 0.60"
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "simplecov"
+end