rufo 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4651dcdf170f65e4e0da813add1f99623939ab8704b78c48572188a65de85252
-  data.tar.gz: 0d846bca50b9f15142e94894866280afb1a7963b9c729d0de84d3f469c7c0aad
+  metadata.gz: 3bbc374be047a3b1a07b7f73dd004aa0629b07bdf70de0342041dabbebd16166
+  data.tar.gz: ac54fb2d1e593baa3207109d9cb40d4bef40ab9eb64db13be344fcfd64bdcfe2
 SHA512:
-  metadata.gz: af569cb8f398b61616546c2ba098e3fbe6ff576b0c7e0b467ef5bd181e6df90d4edae49f3e72a05b45de52c875e01cd9ed88ce2343af19a889efba571cdc4207
-  data.tar.gz: 75caf9bd7891406ee099eb8d707744ecf29f557a925b6c6b7d9108b7196ae52e793c7b53566af358f7676566e492c61b7a74af4ffbece87c6fb6c1b24b7f0e98
+  metadata.gz: 0bf1ada9dcd91f5565c519a90693f7b2e35b46b4075f7cb92e57a120539df196286fce17ab42427fd3b9937f97585093487309624b59415ee42dbd87259d3178
+  data.tar.gz: 40b9de53720d9ad2c1b09c44f4b5a88cd3bb69ad4ceef8034d78abdb940052f504fff1995df5eaada6d936ae418d96ba1a1c5c3d82745761f9a8f8cf45a8a4f0

data/.circleci/config.yml

@@ -15,18 +15,12 @@
     # Restore bundle cache
     - restore_cache:
         keys:
-          - bundler-packages-{{ checksum "ruby-version-for-ci.txt" }}-{{ checksum "rufo.gemspec" }}
+          - bundler-packages-v2-{{ checksum "ruby-version-for-ci.txt" }}-{{ checksum "rufo.gemspec" }}-{{ checksum "bin/verify-sample-code" }}
 
     - run:
         name: Bundle Install
         command: bundle check || bundle install
 
-    # Store bundle cache
-    - save_cache:
-        key: bundler-packages-{{ checksum "ruby-version-for-ci.txt" }}-{{ checksum "rufo.gemspec" }}
-        paths:
-          - vendor/bundle
-          - Gemfile.lock
     - run:
         name: Run rspec
         command: |
@@ -43,6 +37,18 @@
         command: |
           bundle exec rake rufo:run
 
+    - run:
+        name: Verify rufo works against sample codebases
+        command: |
+          bin/verify-sample-code
+
+    # Store bundle cache
+    - save_cache:
+        key: bundler-packages-v2-{{ checksum "ruby-version-for-ci.txt" }}-{{ checksum "rufo.gemspec" }}-{{ checksum "bin/verify-sample-code" }}
+        paths:
+          - vendor/bundle
+          - Gemfile.lock
+
     # Save test results for timing analysis
     - store_test_results:
         path: test_results
@@ -50,6 +56,14 @@
 
 version: 2
 jobs:
+  build-2-7-0:
+    <<: *dockerbuild
+    docker:
+      - image: circleci/ruby:2.7.0
+        environment:
+          BUNDLE_JOBS: "3"
+          BUNDLE_RETRY: "3"
+          BUNDLE_PATH: /home/circleci/project/vendor/bundle
   build-2-6-3:
     <<: *dockerbuild
     docker:
@@ -57,7 +71,7 @@ jobs:
         environment:
           BUNDLE_JOBS: "3"
           BUNDLE_RETRY: "3"
-          BUNDLE_PATH: vendor/bundle
+          BUNDLE_PATH: /home/circleci/project/vendor/bundle
   build-2-6-1:
     <<: *dockerbuild
     docker:
@@ -86,6 +100,7 @@ workflows:
   version: 2
   test:
     jobs:
+      - build-2-7-0
       - build-2-6-3
       - build-2-6-1
       - build-2-5-3

data/.gitignore

@@ -11,3 +11,4 @@
 
 # rspec failure tracking
 .rspec_status
+sample_code

data/CHANGELOG.md

@@ -12,6 +12,24 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ### Added
 
+## [0.8.0] - 2020-01-02
+
+### Fixed
+- Handle endless ranges in ruby 2.6
+- Handle empty string hash keys
+
+### Changed
+- Output detailed description of Syntax Error to log
+- Removed newlines from start of files.
+
+### Added
+
+- Support for rackup files
+- Settings for 'quote_style' to settings.md
+- Add support for ERB files
+- Add Ruby 2.7.0 to test runs on CI
+- `includes` and `excludes` configuration options
+
 ## [0.7.0] - 2019-04-28
 
 ### Fixed

data/bin/verify-sample-code

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+repos = {
+  "rspec/rspec-core" => {
+    "--exclude-pattern" => [
+      "spec/rspec/core/world_spec.rb",
+      "spec/rspec/core/formatters/exception_presenter_spec.rb",
+      "spec/rspec/core/formatters/snippet_extractor_spec.rb",
+      "spec/rspec/core/metadata_spec.rb",
+      "spec/rspec/core/formatters/html_formatter_spec.rb",
+    ].join(","),
+  },
+}
+
+def run_command(cmd, allowed_statuses: [0])
+  puts "Running: #{cmd.inspect}"
+  system(cmd)
+  unless allowed_statuses.include?($?.exitstatus)
+    $stderr.puts "Command failed, aborting!"
+    exit 1
+  end
+end
+
+def clone_repo(repo)
+  run_command(
+    "git clone --depth=1 'https://github.com/#{repo}' sample_code/#{repo}"
+  )
+end
+
+def setup_repo(repo)
+  run_command("cd sample_code/#{repo} && bundle")
+end
+
+def run_rspec(repo, flags)
+  str_flags = flags.to_a.join(" ")
+  run_command("cd sample_code/#{repo} && bundle exec rspec #{str_flags}")
+end
+
+def pre_format_checks(repo, rspec_flags)
+  run_rspec(repo, rspec_flags)
+end
+
+def format_repo(repo)
+  run_command(
+    "bundle exec rake rufo:run sample_code/#{repo}",
+    allowed_statuses: [0, 1, 3],
+  )
+end
+
+def post_format_checks(repo, rspec_flags)
+  run_rspec(repo, rspec_flags)
+end
+
+repos.each do |repo, rspec_flags|
+  clone_repo(repo)
+  setup_repo(repo)
+  pre_format_checks(repo, rspec_flags)
+  format_repo(repo)
+  post_format_checks(repo, rspec_flags)
+end

data/docs/settings.md

@@ -22,6 +22,7 @@ See https://github.com/ruby-formatter/rufo/issues/2 for more context!
 - [align_chained_calls](#align_chained_calls)
 - [parens_in_def](#parens_in_def)
 - [trailing_commas](#trailing_commas)
+- [quote_style](#quote_style)
 
 ### align_case_when
 
@@ -184,6 +185,7 @@ foo(
   y: 2,
 )
 ```
+
 With `:never`, the formatter will change it to:
 
 ```ruby
@@ -217,3 +219,60 @@ foo(
   y: 2
 )
 ```
+
+### quote_style
+
+Use the specified quotation marks. 
+
+- `:double`: (default) use doublequotations unless one or more escaped double-quotations are included
+- `:single`: use single quotations unless one or more interpolations `#{}` or escaped single quotations are included
+
+This does not affect `%q()` (single), `%Q()` (double), or quotation marks within heredocs.
+
+Given this code:
+
+```ruby
+'a great string'
+
+'import \"quotes\"'
+"import \'quotes\'"
+"#{interpolation}"
+%q(single quoted)
+%Q(double quoted)
+code = <<CODE
+  "double"
+  'single'
+CODE
+```
+
+With `:double`, the formatter will change the first line to:
+
+```ruby
+"a great string"
+
+'import \"quotes\"'
+"import \'quotes\'"
+"#{interpolation}"
+%q(single quoted)
+%Q(double quoted)
+code = <<CODE
+  "double"
+  'single'
+CODE
+```
+
+With `:single`, the formatter will change the first line just above to:
+
+```ruby
+'a great string'
+
+'import \"quotes\"'
+"import \'quotes\'"
+"#{interpolation}"
+%q(single quoted)
+%Q(double quoted)
+code = <<CODE
+  "double"
+  'single'
+CODE
+```

data/lib/rufo/command.rb

@@ -17,7 +17,6 @@ class Rufo::Command
     @exit_code = exit_code
     @filename_for_dot_rufo = filename_for_dot_rufo
     @dot_file = Rufo::DotFile.new
-    @squiggly_warning_files = []
     @logger = Rufo::Logger.new(loglevel)
   end
 
@@ -51,8 +50,8 @@ class Rufo::Command
     print(result) if !@want_check
 
     code == result ? CODE_OK : CODE_CHANGE
-  rescue Rufo::SyntaxError
-    logger.error("Error: the given text is not a valid ruby program (it has syntax errors)")
+  rescue Rufo::SyntaxError => e
+    logger.error("STDIN is invalid code. Error on line:#{e.lineno} #{e.message}")
     CODE_ERROR
   rescue => ex
     logger.error("You've found a bug!")
@@ -61,7 +60,11 @@ class Rufo::Command
   end
 
   def format_args(args)
-    file_finder = Rufo::FileFinder.new(args)
+    top_level_dot_file = @filename_for_dot_rufo || Dir.getwd
+    options = @dot_file.get_config_in(top_level_dot_file) || {}
+    file_finder = Rufo::FileFinder.new(
+      args, includes: options[:includes], excludes: options[:excludes],
+    )
     files = file_finder.to_a
 
     changed = false
@@ -95,11 +98,13 @@ class Rufo::Command
     code = File.read(filename)
 
     begin
-      result = format(code, @filename_for_dot_rufo || File.dirname(filename))
-    rescue Rufo::SyntaxError
+      location = @filename_for_dot_rufo || File.dirname(filename)
+      erb = filename.end_with?(".erb")
+      result = format(code, location, erb: erb)
+    rescue Rufo::SyntaxError => e
       # We ignore syntax errors as these might be template files
       # with .rb extension
-      logger.warn("Error: #{filename} has syntax errors")
+      logger.warn("#{filename}:#{e.lineno} #{e.message}")
       return CODE_ERROR
     end
 
@@ -113,8 +118,8 @@ class Rufo::Command
 
       return CODE_CHANGE
     end
-  rescue Rufo::SyntaxError
-    logger.error("Error: the given text in #{filename} is not a valid ruby program (it has syntax errors)")
+  rescue Rufo::SyntaxError => e
+    logger.error("#{filename}:#{e.lineno} #{e.message}")
     CODE_ERROR
   rescue => ex
     logger.error("You've found a bug!")
@@ -123,14 +128,14 @@ class Rufo::Command
     raise ex
   end
 
-  def format(code, dir)
-    @squiggly_warning = false
-    formatter = Rufo::Formatter.new(code)
-
-    options = @dot_file.get_config_in(dir)
-    unless options.nil?
-      formatter.init_settings(options)
+  def format(code, dir, erb: false)
+    options = @dot_file.get_config_in(dir) || {}
+    if erb
+      formatter = Rufo::ErbFormatter.new(code, **options)
+    else
+      formatter = Rufo::Formatter.new(code, **options)
     end
+
     formatter.format
     result = formatter.result
     result

data/lib/rufo/dot_file.rb

@@ -29,6 +29,8 @@ class Rufo::DotFile
         value = true
       elsif value == "false"
         value = false
+      elsif value.start_with?("[")
+        value = value[1..-2].split(",")
       else
         $stderr.puts "Unknown config value=#{value.inspect} for #{name.inspect}"
         next

data/lib/rufo/erb_formatter.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+require "erb"
+
+class Rufo::ErbFormatter
+  def self.format(code, **options)
+    new(code, **options).format
+  end
+
+  attr_reader :result
+
+  def initialize(code, **options)
+    compiler = ERB::Compiler.new("<>")
+    @options = options
+    @scanner = compiler.make_scanner(code)
+    @code_mode = false
+    @current_lineno = 0
+    @current_column = 0
+  end
+
+  def format
+    out = []
+    process_erb do |(type, content)|
+      if type == :code
+        formatted_code = process_code(content)
+        indented_code = formatted_code.lines.join(" " * current_column)
+        out << " #{indented_code} "
+      else
+        out << content
+      end
+
+      update_lineno(out.last)
+      update_column(out.last)
+    end
+    @result = out.join("")
+  end
+
+  private
+
+  attr_reader :scanner, :code_mode
+  attr_accessor :current_lineno, :current_column
+
+  def update_lineno(token)
+    lines = token.count("\n")
+    if lines > 0
+      self.current_lineno = current_lineno + lines
+    end
+  end
+
+  def update_column(token)
+    last_newline_index = token.rindex("\n")
+    if last_newline_index == nil
+      self.current_column = current_column + token.length
+    else
+      self.current_column = token[last_newline_index..-1].length
+    end
+  end
+
+  def process_erb
+    code = []
+    scanner.scan do |token|
+      if token.is_a?(String) && token.end_with?("%>")
+        disable_code_mode
+        yield [:code, code.join("")]
+        yield [:text, token]
+        code = []
+      elsif code_mode
+        code << token
+      elsif token == :cr
+        yield [:text, "\n"]
+      else
+        yield [:text, token]
+      end
+
+      enable_code_mode if token.is_a?(String) && token.start_with?("<%")
+    end
+  end
+
+  def process_code(code_str)
+    sexps = Ripper.sexp(code_str)
+    if sexps.nil?
+      prefix, suffix = determine_code_wrappers(code_str)
+    end
+    result = format_code("#{prefix} " + code_str + " #{suffix}")
+    unless suffix.nil?
+      result = result.chomp(suffix)
+    end
+    unless prefix.nil?
+      result = result.sub(prefix, "")
+    end
+    result.strip
+  end
+
+  def determine_code_wrappers(code_str)
+    return nil, "\nend" if Ripper.sexp("#{code_str}\nend")
+    return nil, "}" if Ripper.sexp("#{code_str} }")
+    return "{", nil if Ripper.sexp("{ #{code_str}")
+    return "begin", nil if Ripper.sexp("begin #{code_str}")
+    return "begin\n", "\nend" if Ripper.sexp("begin\n#{code_str}\nend")
+    return "if a\n", "\nend" if Ripper.sexp("if a\n#{code_str}\nend")
+    raise_syntax_error!(code_str)
+  end
+
+  def raise_syntax_error!(code_str)
+    format_code(code_str)
+  rescue Rufo::SyntaxError => e
+    raise Rufo::SyntaxError.new(e.message, current_lineno + e.lineno)
+  end
+
+  def format_code(str)
+    Rufo::Formatter.format(str).chomp
+  end
+
+  def enable_code_mode
+    @code_mode = true
+  end
+
+  def disable_code_mode
+    @code_mode = false
+  end
+end

data/lib/rufo/file_finder.rb

@@ -1,34 +1,48 @@
 require "find"
+require "rake/file_list"
 
 class Rufo::FileFinder
   include Enumerable
 
   # Taken from https://github.com/ruby/rake/blob/f0a897e3fb557f64f5da59785b1a4464826f77b2/lib/rake/application.rb#L41
   RAKEFILES = [
-    "rakefile",
-    "Rakefile",
-    "rakefile.rb",
-    "Rakefile.rb",
+    "**/rakefile",
+    "**/Rakefile",
+    "**/rakefile.rb",
+    "**/Rakefile.rb",
   ]
 
   FILENAMES = [
-    "Gemfile",
+    "**/Gemfile",
     *RAKEFILES,
   ]
 
   EXTENSIONS = [
-    ".rb",
-    ".gemspec",
-    ".rake",
-    ".jbuilder",
+    "**/*.rb",
+    "**/*.gemspec",
+    "**/*.rake",
+    "**/*.ru",
+    "**/*.jbuilder",
+    "**/*.erb",
+  ]
+
+  DEFAULT_PATTERNS = [
+    *FILENAMES,
+    *EXTENSIONS,
   ]
 
   EXCLUDED_DIRS = [
     "vendor",
   ]
 
-  def initialize(files_or_dirs)
+  EXCLUDE_PATTERNS = [
+    "vendor/**/*",
+  ]
+
+  def initialize(files_or_dirs, includes: [], excludes: [])
     @files_or_dirs = files_or_dirs
+    @includes = includes
+    @excludes = excludes
   end
 
   def each
@@ -43,20 +57,15 @@ class Rufo::FileFinder
 
   private
 
-  attr_reader :files_or_dirs
+  attr_reader :files_or_dirs, :includes, :excludes
 
   def all_rb_files(file_or_dir)
-    files = []
-    Find.find(file_or_dir) do |path|
-      basename = File.basename(path)
-      if File.directory?(path)
-        Find.prune if EXCLUDED_DIRS.include?(basename)
-      else
-        if EXTENSIONS.include?(File.extname(basename)) || FILENAMES.include?(basename)
-          files << path
-        end
-      end
+    Dir.chdir(file_or_dir) do
+      fl = Rake::FileList.new(*DEFAULT_PATTERNS)
+      fl.exclude(*EXCLUDE_PATTERNS)
+      fl.exclude(*excludes)
+      fl.include(*includes)
+      fl.to_a
     end
-    files
   end
 end

data/lib/rufo/formatter.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require "ripper"
-
 class Rufo::Formatter
   include Rufo::Settings
 
   INDENT_SIZE = 2
+  EMPTY_STRING = [:string_literal, [:string_content]]
+  EMPTY_HASH = [:hash, nil]
 
   def self.format(code, **options)
     formatter = new(code, **options)
@@ -15,12 +15,13 @@ class Rufo::Formatter
 
   def initialize(code, **options)
     @code = code
-    @tokens = Ripper.lex(code).reverse!
-    @sexp = Ripper.sexp(code)
 
-    unless @sexp
-      raise ::Rufo::SyntaxError.new
-    end
+    @tokens = Rufo::Parser.lex(code).reverse!
+    @sexp = Rufo::Parser.sexp(code)
+
+    # sexp being nil means that the code is not valid.
+    # Parse the code so we get better error messages.
+    Rufo::Parser.parse(code) if @sexp.nil?
 
     @indent = 0
     @line = 0
@@ -179,6 +180,8 @@ class Rufo::Formatter
     indent_literals
     do_align_case_when if align_case_when
     remove_lines_before_inline_declarations
+    @output.lstrip!
+    @output = "\n" if @output.empty?
   end
 
   def visit(node)
@@ -2378,7 +2381,7 @@ class Rufo::Formatter
     skip_space_or_newline
     consume_op(inclusive ? ".." : "...")
     skip_space_or_newline
-    visit right
+    visit right unless right.nil?
   end
 
   def visit_regexp_literal(node)
@@ -3848,15 +3851,13 @@ class Rufo::Formatter
     when :hash, :string_literal, :symbol_literal, :symbol, :vcall, :string_content, :assoc_splat, :var_ref
       node_line(node[1], beginning: beginning)
     when :assoc_new
-      if beginning
+      # There's no line number info for empty strings or hashes.
+      if node[1] != EMPTY_STRING && node[1] != EMPTY_HASH
         node_line(node[1], beginning: beginning)
+      elsif node.last != EMPTY_STRING && node.last != EMPTY_HASH
+        node_line(node.last, beginning: beginning)
       else
-        if node.last == [:string_literal, [:string_content]] || node.last == [:hash, nil]
-          # there's no line number for [:string_literal, [:string_content]] or [:hash, nil]
-          node_line(node[1], beginning: beginning)
-        else
-          node_line(node.last, beginning: beginning)
-        end
+        return
       end
     when :assoclist_from_args
       node_line(beginning ? node[1][0] : node[1].last, beginning: beginning)

data/lib/rufo/parser.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+class Rufo::Parser < Ripper
+  def compile_error(msg)
+    raise ::Rufo::SyntaxError.new(msg, lineno)
+  end
+
+  def on_parse_error(msg)
+    raise ::Rufo::SyntaxError.new(msg, lineno)
+  end
+end

data/lib/rufo/settings.rb

@@ -5,15 +5,17 @@ module Rufo::Settings
     align_chained_calls: [false, true],
     trailing_commas: [true, false],
     quote_style: [:double, :single],
+    includes: nil,
+    excludes: nil,
   }
 
   attr_accessor(*OPTIONS.keys)
 
   def init_settings(options)
     OPTIONS.each do |name, valid_options|
-      default = valid_options.first
+      default = valid_options&.first
       value = options.fetch(name, default)
-      unless valid_options.include?(value)
+      if !valid_options.nil? && !valid_options.include?(value)
         $stderr.puts "Invalid value for #{name}: #{value.inspect}. Valid " \
                      "values are: #{valid_options.map(&:inspect).join(", ")}"
         value = default

data/lib/rufo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rufo
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

data/lib/rufo.rb

@@ -3,7 +3,14 @@
 module Rufo
   class Bug < StandardError; end
 
-  class SyntaxError < StandardError; end
+  class SyntaxError < StandardError
+    attr_reader :lineno
+
+    def initialize(message, lineno)
+      super(message)
+      @lineno = lineno
+    end
+  end
 
   def self.format(code, **options)
     Formatter.format(code, **options)
@@ -14,6 +21,8 @@ require_relative "rufo/command"
 require_relative "rufo/logger"
 require_relative "rufo/dot_file"
 require_relative "rufo/settings"
+require_relative "rufo/parser"
 require_relative "rufo/formatter"
+require_relative "rufo/erb_formatter"
 require_relative "rufo/version"
 require_relative "rufo/file_finder"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rufo
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Ary Borenszweig
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-28 00:00:00.000000000 Z
+date: 2020-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -130,6 +130,7 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- bin/verify-sample-code
 - docs/developing-rufo.md
 - docs/releasing-a-gem.md
 - docs/settings.md
@@ -137,9 +138,11 @@ files:
 - lib/rufo.rb
 - lib/rufo/command.rb
 - lib/rufo/dot_file.rb
+- lib/rufo/erb_formatter.rb
 - lib/rufo/file_finder.rb
 - lib/rufo/formatter.rb
 - lib/rufo/logger.rb
+- lib/rufo/parser.rb
 - lib/rufo/settings.rb
 - lib/rufo/version.rb
 - rakelib/rufo.rake
@@ -163,7 +166,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Ruby code formatter