├── .circleci └── config.yml ├── .github ├── PULL_REQUEST_TEMPLATE.md └── workflows │ └── ruby.yml ├── .gitignore ├── .rspec ├── .rubocop.yml ├── .rufo ├── .vscode └── settings.json ├── Gemfile ├── Guardfile ├── LICENSE.txt ├── README.md ├── Rakefile ├── bin ├── compile_post_process ├── console └── setup ├── docs ├── developing-ruby-crystal-codemod.md └── releasing-a-gem.md ├── exe └── ruby_crystal_codemod ├── lib ├── ruby_crystal_codemod.rb └── ruby_crystal_codemod │ ├── command.rb │ ├── dot_file.rb │ ├── file_finder.rb │ ├── formatter.rb │ ├── logger.rb │ ├── post_process_crystal.rb │ ├── settings.rb │ └── version.rb ├── rakelib └── ruby_crystal_codemod.rake ├── ruby_crystal_codemod.gemspec ├── run_test ├── spec ├── crystal_codemod_acceptance_spec.rb ├── fixtures │ ├── crystal_codemod_test │ │ ├── example.cr │ │ ├── example.rb │ │ ├── example_invalid.cr │ │ ├── example_invalid.rb │ │ ├── expected_output.txt │ │ ├── input │ │ ├── parent_require.cr │ │ ├── parent_require.rb │ │ ├── require_relative_paren.cr │ │ ├── require_relative_paren.rb │ │ └── subfolder │ │ │ ├── double.cr │ │ │ ├── double.rb │ │ │ ├── nested_require.cr │ │ │ ├── nested_require.rb │ │ │ ├── triple.cr │ │ │ └── triple.rb │ ├── file_finder │ │ ├── only_gemfiles │ │ │ ├── Gemfile │ │ │ └── a.gemspec │ │ ├── only_rake_files │ │ │ ├── Rakefile │ │ │ └── a.rake │ │ ├── only_ruby │ │ │ └── a.rb │ │ └── only_vendor │ │ │ └── vendor │ │ │ └── a.rb │ ├── needs_changes │ ├── rspec_project │ │ ├── .gitignore │ │ ├── Gemfile │ │ ├── run_gelauto │ │ ├── shard.lock │ │ ├── shard.yml │ │ ├── sorbet │ │ │ ├── config │ │ │ └── rbi │ │ │ │ ├── gems │ │ │ │ ├── ast.rbi │ │ │ │ ├── byebug.rbi │ │ │ │ ├── coderay.rbi │ │ │ │ ├── gelauto.rbi │ │ │ │ ├── method_source.rbi │ │ │ │ ├── parser.rbi │ │ │ │ ├── pry-byebug.rbi │ │ │ │ ├── pry.rbi │ │ │ │ ├── rake.rbi │ │ │ │ ├── rspec-core.rbi │ │ │ │ ├── rspec-expectations.rbi │ │ │ │ ├── rspec-mocks.rbi │ │ │ │ ├── rspec-support.rbi │ │ │ │ └── rspec.rbi │ │ │ │ └── hidden-definitions │ │ │ │ ├── errors.txt │ │ │ │ └── hidden.rbi │ │ ├── spec │ │ │ ├── spec_helper.cr │ │ │ ├── spec_helper.rb │ │ │ └── src │ │ │ │ ├── example_class_annotated_spec.cr │ │ │ │ └── example_class_annotated_spec.rb │ │ └── src │ │ │ ├── example_class.rb │ │ │ ├── example_class_annotated.cr │ │ │ └── example_class_annotated.rb │ ├── syntax_error │ └── valid ├── lib │ └── ruby_crystal_codemod │ │ ├── command_spec.rb │ │ ├── dot_file_spec.rb │ │ ├── file_finder_spec.rb │ │ ├── formatter_crystal_specs │ │ ├── blocks_and_procs.rb.spec │ │ ├── operators.rb.spec │ │ ├── properties.rb.spec │ │ ├── pseudo_constants.rb.spec │ │ ├── require_dynamic.rb.spec │ │ └── unshift_loadpath.spec │ │ ├── formatter_source_specs │ │ ├── 2.6 │ │ │ └── range.rb.spec │ │ ├── BEGIN.rb.spec │ │ ├── END.rb.spec │ │ ├── __END__.rb.spec │ │ ├── alias.rb.spec │ │ ├── align_assignments.rb.spec │ │ ├── align_case_when.rb.spec │ │ ├── align_chained_calls.rb.spec │ │ ├── align_comments.rb.spec │ │ ├── align_hash_keys.rb.spec │ │ ├── align_mix.rb.spec │ │ ├── and_or_not.rb.spec │ │ ├── array_access.rb.spec │ │ ├── array_literal.rb.spec │ │ ├── array_setter.rb.spec │ │ ├── assignment_operators.rb.spec │ │ ├── assignments.rb.spec │ │ ├── backtick_strings.rb.spec │ │ ├── begin_end.rb.spec │ │ ├── begin_rescue_end.rb.spec │ │ ├── binary_operators.rb.spec │ │ ├── blocks.rb.spec │ │ ├── booleans.rb.spec │ │ ├── break.rb.spec │ │ ├── calls_with_dot.rb.spec │ │ ├── calls_with_receiver.rb.spec │ │ ├── case.rb.spec │ │ ├── chars.rb.spec │ │ ├── class.rb.spec │ │ ├── class_into_self.rb.spec │ │ ├── class_rescue_end.rb.spec │ │ ├── class_variables.rb.spec │ │ ├── comments.rb.spec │ │ ├── constants.rb.spec │ │ ├── defined_rb.spec │ │ ├── double_newline_inside_type.rb.spec │ │ ├── double_quotes.rb.spec │ │ ├── floats.rb.spec │ │ ├── for.rb.spec │ │ ├── global_variables.rb.spec │ │ ├── hash_literal.rb.spec │ │ ├── heredoc.rb.spec │ │ ├── if.rb.spec │ │ ├── imaginaries.rb.spec │ │ ├── inline_classes.rb.spec │ │ ├── integers.rb.spec │ │ ├── junk_drawer.rb.spec │ │ ├── keyword_arguments.rb.spec │ │ ├── lambdas.rb.spec │ │ ├── lonely.rb.spec │ │ ├── lonely_operator.rb.spec │ │ ├── lonely_property_setters.rb.spec │ │ ├── lonely_receiver_and_block.rb.spec │ │ ├── method_calls.rb.spec │ │ ├── method_definition.rb.spec │ │ ├── method_definition_with_receiver.rb.spec │ │ ├── module.rb.spec │ │ ├── multiline_comments.rb.spec │ │ ├── multiple_assignments.rb.spec │ │ ├── next.rb.spec │ │ ├── nil.rb.spec │ │ ├── parens.rb.spec │ │ ├── parens_in_def.rb.spec │ │ ├── percent_array_literal.rb.spec │ │ ├── property_setters.rb.spec │ │ ├── range.rb.spec │ │ ├── rationals.rb.spec │ │ ├── received_and_block.rb.spec │ │ ├── receiver_and_block.rb.spec │ │ ├── redo.rb.spec │ │ ├── regex.rb.spec │ │ ├── retry.rb.spec │ │ ├── return.rb.spec │ │ ├── semicolons.rb.spec │ │ ├── single_quotes.rb.spec │ │ ├── spaces_after_comma.rb.spec │ │ ├── spaces_after_lambda_arrow.rb.spec │ │ ├── spaces_after_method_name.rb.spec │ │ ├── spaces_around_binary.rb.spec │ │ ├── spaces_around_block_brace.rb.spec │ │ ├── spaces_around_dot.rb.spec │ │ ├── spaces_around_equal.rb.spec │ │ ├── spaces_around_hash_arrow.rb.spec │ │ ├── spaces_around_unary.rb.spec │ │ ├── spaces_around_when.rb.spec │ │ ├── spaces_in_commands.rb.spec │ │ ├── spaces_in_inline_expressions.rb.spec │ │ ├── spaces_in_suffix.rb.spec │ │ ├── spaces_in_ternary.rb.spec │ │ ├── spaces_inside_array_bracket.rb.spec │ │ ├── spaces_inside_hash_brace.rb.spec │ │ ├── special_global_variables.rb.spec │ │ ├── squiggly_heredoc.rb.spec │ │ ├── string_literal_concatenation.rb.spec │ │ ├── string_literals.rb.spec │ │ ├── suffix_if.rb.spec │ │ ├── suffix_rescue.rb.spec │ │ ├── super.rb.spec │ │ ├── symbol_literals.rb.spec │ │ ├── ternaries.rb.spec │ │ ├── trailing_commas.rb.spec │ │ ├── unary_operators.rb.spec │ │ ├── undef.rb.spec │ │ ├── unless.rb.spec │ │ ├── until.rb.spec │ │ ├── variables.rb.spec │ │ ├── visibility_indent.rb.spec │ │ ├── visibility_markers.rb.spec │ │ ├── while.rb.spec │ │ └── yield.rb.spec │ │ ├── formatter_spec.rb │ │ ├── logger_spec.rb │ │ ├── post_process_crystal_spec.rb │ │ └── settings_spec.rb ├── source_specs │ └── empty.rb.spec └── spec_helper.rb └── util └── post_process_crystal ├── shard.lock ├── shard.yml ├── spec ├── fixtures │ └── example.rb ├── post_process_crystal_spec.cr └── spec_helper.cr └── src ├── command.cr └── post_process_crystal.cr /.circleci/config.yml: -------------------------------------------------------------------------------- 1 | "-": &dockerbuild 2 | steps: 3 | - checkout 4 | 5 | # Which version of ruby? 6 | - run: 7 | name: Which ruby? 8 | command: ruby --version | tee ruby-version-for-ci.txt 9 | 10 | # Which version of bundler? 11 | - run: 12 | name: Which bundler? 13 | command: bundle -v 14 | 15 | - run: 16 | name: Install Crystal 17 | command: >- 18 | sudo apt-get update && 19 | sudo apt-get install apt-transport-https ca-certificates && 20 | curl -sSL https://dist.crystal-lang.org/apt/setup.sh | sudo bash && 21 | curl -sL "https://keybase.io/crystal/pgp_keys.asc" | sudo apt-key add - && 22 | echo "deb https://dist.crystal-lang.org/apt crystal main" | sudo tee /etc/apt/sources.list.d/crystal.list && 23 | sudo apt-get update && 24 | sudo apt-get -y install crystal && 25 | crystal --version 26 | 27 | # Restore bundle cache 28 | - restore_cache: 29 | keys: 30 | - bundler-packages-v2-{{ checksum "ruby-version-for-ci.txt" }}-{{ checksum "ruby_crystal_codemod.gemspec" }} 31 | 32 | - run: 33 | name: Bundle Install 34 | command: bundle check || bundle install 35 | 36 | - run: 37 | name: Run rspec 38 | command: | 39 | bundle exec rspec --profile 10 \ 40 | --format RspecJunitFormatter \ 41 | --out test_results/rspec.xml \ 42 | --format progress 43 | - run: 44 | name: Run RuboCop 45 | command: | 46 | bundle exec rake rubocop 47 | - run: 48 | name: Run Rufo 49 | command: | 50 | bundle exec rufo -c lib/ spec/lib/ 51 | 52 | # Store bundle cache 53 | - save_cache: 54 | key: bundler-packages-v2-{{ checksum "ruby-version-for-ci.txt" }}-{{ checksum "ruby_crystal_codemod.gemspec" }} 55 | paths: 56 | - vendor/bundle 57 | - Gemfile.lock 58 | 59 | # Save test results for timing analysis 60 | - store_test_results: 61 | path: test_results 62 | 63 | 64 | version: 2 65 | jobs: 66 | build-2-6-5: 67 | <<: *dockerbuild 68 | docker: 69 | - image: circleci/ruby:2.6.5 70 | environment: 71 | BUNDLE_JOBS: "3" 72 | BUNDLE_RETRY: "3" 73 | BUNDLE_PATH: /home/circleci/project/vendor/bundle 74 | build-2-4-5: 75 | <<: *dockerbuild 76 | docker: 77 | - image: circleci/ruby:2.4.5 78 | environment: 79 | BUNDLE_JOBS: "3" 80 | BUNDLE_RETRY: "3" 81 | BUNDLE_PATH: vendor/bundle 82 | workflows: 83 | version: 2 84 | test: 85 | jobs: 86 | - build-2-6-5 87 | - build-2-4-5 88 | -------------------------------------------------------------------------------- /.github/PULL_REQUEST_TEMPLATE.md: -------------------------------------------------------------------------------- 1 | 5 | -------------------------------------------------------------------------------- /.github/workflows/ruby.yml: -------------------------------------------------------------------------------- 1 | # This workflow uses actions that are not certified by GitHub. 2 | # They are provided by a third-party and are governed by 3 | # separate terms of service, privacy policy, and support 4 | # documentation. 5 | # This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake 6 | # For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby 7 | 8 | name: Ruby 9 | 10 | on: 11 | push: 12 | branches: [ "master" ] 13 | pull_request: 14 | branches: [ "master" ] 15 | 16 | permissions: 17 | contents: read 18 | 19 | jobs: 20 | test: 21 | 22 | runs-on: ubuntu-latest 23 | strategy: 24 | matrix: 25 | ruby-version: ['2.6', '2.7', '3.0'] 26 | 27 | steps: 28 | - uses: actions/checkout@v4 29 | - name: Set up Ruby 30 | # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby, 31 | # change this to (see https://github.com/ruby/setup-ruby#versioning): 32 | # uses: ruby/setup-ruby@v1 33 | uses: ruby/setup-ruby@55283cc23133118229fd3f97f9336ee23a179fcf # v1.146.0 34 | with: 35 | ruby-version: ${{ matrix.ruby-version }} 36 | bundler-cache: true # runs 'bundle install' and caches installed gems automatically 37 | - name: Run tests 38 | run: bundle exec rake 39 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /.bundle/ 2 | /.yardoc 3 | /Gemfile.lock 4 | /_yardoc/ 5 | /coverage/ 6 | /doc/ 7 | /pkg/ 8 | /spec/reports/ 9 | /tmp/ 10 | /*.gem 11 | 12 | # rspec failure tracking 13 | .rspec_status 14 | sample_code 15 | 16 | .byebug_history 17 | # *.cr 18 | 19 | test.rb 20 | test.cr 21 | 22 | util/post_process 23 | util/post_process_crystal/lib/ 24 | *.dwarf 25 | 26 | spec/fixtures/rspec_project/.git 27 | -------------------------------------------------------------------------------- /.rspec: -------------------------------------------------------------------------------- 1 | --format documentation 2 | --color 3 | --exclude-pattern spec/fixtures/rspec_project/**/* 4 | -------------------------------------------------------------------------------- /.rubocop.yml: -------------------------------------------------------------------------------- 1 | AllCops: 2 | Exclude: 3 | - "spec/**/*" 4 | - "vendor/**/*" 5 | TargetRubyVersion: 2.4 6 | 7 | Layout: 8 | Enabled: false 9 | 10 | Metrics: 11 | Enabled: false 12 | 13 | Style: 14 | Enabled: false 15 | 16 | -------------------------------------------------------------------------------- /.rufo: -------------------------------------------------------------------------------- 1 | align_case_when true 2 | align_chained_calls true 3 | -------------------------------------------------------------------------------- /.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "ruby.rubocop.onSave": false, 3 | "python.linting.lintOnSave": false 4 | } -------------------------------------------------------------------------------- /Gemfile: -------------------------------------------------------------------------------- 1 | source "https://rubygems.org" 2 | 3 | # Specify your gem's dependencies in ruby_crystal_codemod.gemspec 4 | gemspec 5 | -------------------------------------------------------------------------------- /Guardfile: -------------------------------------------------------------------------------- 1 | guard :rspec, cmd: 'rspec' do 2 | watch(%r{^spec/.+_spec\.rb$}) 3 | watch(%r{^lib/(.+)\.rb$}) { |m| "spec/lib/#{m[1]}_spec.rb" } 4 | watch('spec/spec_helper.rb') { "spec" } 5 | end 6 | -------------------------------------------------------------------------------- /LICENSE.txt: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2017 Ary Borenszweig 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in 13 | all copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | THE SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | [![CircleCI](https://circleci.com/gh/DocSpring/ruby_crystal_codemod.svg?style=svg)](https://circleci.com/gh/DocSpring/ruby_crystal_codemod) 2 | 3 | # Ruby => Crystal Codemod 4 | 5 | This project is a fork of [Rufo](https://github.com/ruby-formatter/rufo). (Rufo and Crystal were both created by [Ary Borenszweig](https://github.com/asterite)!) 6 | 7 | > Rufo is as an _opinionated_ ruby formatter, intended to be used via the command line as a text-editor plugin, to autoformat files on save or on demand. 8 | 9 | The formatting rules have been modified in an attempt to produce some semi-valid Crystal code. Then you need to add some type annotations and fix any other issues manually. See the [Crystal for Rubyists](https://github.com/crystal-lang/crystal/wiki/Crystal-for-Rubyists) wiki page to learn more about the syntax differences. 10 | 11 | > Ruby => Crystal Codemod / Rufo supports all Ruby versions >= 2.4.5, due to a bug in Ruby's Ripper parser. 12 | 13 | ## Requirements 14 | 15 | * Ruby >= `2.4.5` 16 | * [Crystal](https://crystal-lang.org/install/) >= `0.31.1` 17 | 18 | ## Installation 19 | 20 | Install the gem with: 21 | 22 | ``` 23 | $ gem install ruby_crystal_codemod 24 | ``` 25 | 26 | ## Usage 27 | 28 | Go to the directory where you want to convert Ruby files into Crystal. Then run: 29 | 30 | ``` 31 | ruby_crystal_codemod . 32 | ``` 33 | 34 | This command will create new `*.cr` files and attempt to fix any simple errors. Then it will 35 | run `crystal tool format` to format the generated code. 36 | 37 | ## Next Steps: 38 | 39 | * Once you've fixed all of the syntax and type errors, run `crystal tool format` to autoformat your code. 40 | * Run [Ameba](https://github.com/crystal-ameba/ameba) for static code analysis (similar to RuboCop), and fix all of the errors. 41 | * *(Unfortunately Ameba doesn't have a --fix option yet.)* 42 | 43 | ## Writing Ruby / Crystal in the same file 44 | 45 | If you want to write both Ruby and Crystal in a Ruby file, you can use some 46 | special `#~# BEGIN ` and `#~# END ` comments. 47 | Code between `#~# BEGIN ruby` and `#~# END ruby` should be uncommented, 48 | and code between `#~# BEGIN crystal` and `#~# END crystal` should be commented. 49 | When transpiling a Ruby file into Crystal, the transpiler will remove all of the Ruby lines between these comments, and it will uncomment all of the Crystal lines. 50 | 51 | The `BEGIN` / `END` comments can start with either `#~#` or `# ~#`. (Code formatters / linters often enforce a space after the `#` character for comments.) 52 | 53 | For example, here's how you can define a class that works for both Ruby and Crystal: 54 | (Crystal requires type annotations here.) 55 | 56 | ``` 57 | class Foo 58 | attr_accessor :foo 59 | 60 | #~# BEGIN ruby 61 | def initialize(foo) 62 | @foo = foo 63 | end 64 | #~# END ruby 65 | #~# BEGIN crystal 66 | # @foo : Int32 67 | # def initialize(@foo : Int32); end 68 | #~# END crystal 69 | end 70 | ``` 71 | 72 | When this file is executed by Ruby, Ruby will ignore all of the commented lines. When the file is run through the Ruby => Crystal transpiler, it will be transformed into the following Crystal code: 73 | 74 | ``` 75 | class Foo 76 | property :foo 77 | 78 | @foo : Int32 79 | def initialize(@foo : Int32); end 80 | end 81 | ``` 82 | 83 | (The transpiler automatically renames `attr_accessor` to `property`.) 84 | 85 | > See [`spec/fixtures/crystal_codemod_test/example.rb:87`](https://github.com/DocSpring/ruby_crystal_codemod/blob/master/spec/fixtures/crystal_codemod_test/example.rb#L87-L114) for a real-world example that is used in our acceptance specs. 86 | 87 | ## Status 88 | 89 | - [x] Rename all file extensions from `.rb` to `.cr` 90 | - [x] Replace single quoted strings with double quotes 91 | - [x] `require_relative "foo"` -> `require "./foo"` 92 | - [x] `$:`, `LOAD_PATH` => Show error and link to docs about CRYSTAL_PATH (for compiler) 93 | - [x] Translate methods / keywords / operators: 94 | - [x] `include?` -> `includes?` 95 | - [x] `key?` -> `has_key?` 96 | - [x] `detect` -> `find` 97 | - [x] `collect` -> `map` 98 | - [x] `respond_to?` -> `responds_to?` 99 | - [x] `length`, `count` -> `size` 100 | - [x] `__dir__` -> `__DIR__` 101 | - [x] `and` -> `&&` 102 | - [x] `or` -> `||` 103 | - [x] `not` -> `!` 104 | - [x] `foo.each(&:method)` -> `foo.each(&.method)` 105 | - [x] `foo.map &:method` -> `foo.map &.method` 106 | - [x] `attr_accessor` => `property` 107 | - [x] `attr_reader` => `getter` 108 | - [x] `attr_writer` => `setter` 109 | - [ ] `private` / `protected` methods 110 | - [ ] `class << self` => `def self.foo` (?) 111 | - [ ] `YAML.load_file("./foo.yml")` => `YAML.parse(File.read("./foo.yml"))` 112 | - [ ] .each returns nil - Try to warn if it looks like the return value of `.each` is being used 113 | - [ ] for loops - Show a warning or link to the docs 114 | - [ ] Consistent dot notation - `File::exists?` => `File.exists?` 115 | 116 | ## Future 117 | 118 | * Sorbet Type Annotations -> Crystal type annotations 119 | * Integration with [gelauto](https://github.com/camertron/gelauto), to automatically annotate Ruby code with Sorbet type definitions. 120 | 121 | ## Testing 122 | 123 | Run `rspec` to run all the specs and integration tests. I've kept all of the original rufo specs, because they're all really fast, it doesn't hurt to produce nicely formatted Crystal code (before the crystal format pass.) 124 | 125 | Crystal-specific formatting specs can be found in `spec/lib/ruby_crystal_codemod/formatter_crystal_specs/*`. 126 | 127 | There's also a Crystal acceptance spec at `spec/lib/ruby_crystal_codemod/crystal_codemod_acceptance_spec.rb`. 128 | This transpiles the example Ruby code in `spec/fixtures/crystal_codemod_test`, and makes sure that Ruby 129 | and Crystal produce the same output when they both run the respective code. 130 | 131 | ## Developing 132 | 133 | Before submitting a PR, please run: 134 | 135 | * `bundle exec rake rubocop -a` 136 | * `bundle exec rufo lib/ spec/lib/` 137 | 138 | ## Contributing 139 | 140 | Bug reports and pull requests are welcome on GitHub at https://github.com/DocSpring/ruby_crystal_codemod. 141 | 142 | ## License 143 | 144 | The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT). 145 | -------------------------------------------------------------------------------- /Rakefile: -------------------------------------------------------------------------------- 1 | require "bundler/gem_tasks" 2 | require "rspec/core/rake_task" 3 | require "rubocop/rake_task" 4 | 5 | RSpec::Core::RakeTask.new(:spec) 6 | RuboCop::RakeTask.new 7 | 8 | task :default => :spec 9 | -------------------------------------------------------------------------------- /bin/compile_post_process: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | set -e 3 | (cd util/post_process_crystal && shards install) 4 | crystal build --release util/post_process_crystal/src/command.cr -o util/post_process 5 | -------------------------------------------------------------------------------- /bin/console: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | require "bundler/setup" 4 | require "ruby_crystal_codemod" 5 | 6 | # You can add fixtures and/or initialization code here to make experimenting 7 | # with your gem easier. You can also use a different console, if you like. 8 | 9 | # (If you use this, don't forget to add pry to your Gemfile!) 10 | # require "pry" 11 | # Pry.start 12 | 13 | require "irb" 14 | IRB.start(__FILE__) 15 | -------------------------------------------------------------------------------- /bin/setup: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | set -euo pipefail 3 | IFS=$'\n\t' 4 | set -vx 5 | 6 | bundle install 7 | 8 | # Do any other automated setup that you need to do here 9 | -------------------------------------------------------------------------------- /docs/developing-ruby-crystal-codemod.md: -------------------------------------------------------------------------------- 1 | # ruby_crystal_codemod Development 2 | 3 | Thanks for your help! 4 | -------------------------------------------------------------------------------- /docs/releasing-a-gem.md: -------------------------------------------------------------------------------- 1 | # Releasing a gem 2 | 3 | 1. Ensure that the tests pass and everything is working! 4 | 5 | 2. Add missing release notes to `CHANGELOG.md` 6 | 7 | 3. Bump version in 8 | * `lib/ruby_crystal_codemod/version.rb` 9 | * `CHANGELOG.md` 10 | 11 | 4. Commit version bump via 12 | * `git commit -v "Version X.Y.Z"` 13 | 14 | 5. Release gem to RubyGems via 15 | * `rake release` 16 | 17 | 6. :tada: 18 | -------------------------------------------------------------------------------- /exe/ruby_crystal_codemod: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | require_relative "../lib/ruby_crystal_codemod" 3 | 4 | RubyCrystalCodemod::Command.run(ARGV) 5 | -------------------------------------------------------------------------------- /lib/ruby_crystal_codemod.rb: -------------------------------------------------------------------------------- 1 | # frozen_string_literal: true 2 | 3 | module RubyCrystalCodemod 4 | class Bug < StandardError; end 5 | 6 | class SyntaxError < StandardError; end 7 | 8 | def self.format(code, filename, dir, **options) 9 | Formatter.format(code, filename, dir, **options) 10 | end 11 | end 12 | 13 | require_relative "ruby_crystal_codemod/command" 14 | require_relative "ruby_crystal_codemod/logger" 15 | require_relative "ruby_crystal_codemod/dot_file" 16 | require_relative "ruby_crystal_codemod/settings" 17 | require_relative "ruby_crystal_codemod/formatter" 18 | require_relative "ruby_crystal_codemod/version" 19 | require_relative "ruby_crystal_codemod/file_finder" 20 | require_relative "ruby_crystal_codemod/post_process_crystal" 21 | -------------------------------------------------------------------------------- /lib/ruby_crystal_codemod/dot_file.rb: -------------------------------------------------------------------------------- 1 | # frozen_string_literal: true 2 | 3 | class RubyCrystalCodemod::DotFile 4 | def initialize 5 | @cache = {} 6 | end 7 | 8 | def get_config_in(dir) 9 | dot_ruby_crystal_codemod = find_in(dir) 10 | if dot_ruby_crystal_codemod 11 | return parse(dot_ruby_crystal_codemod) 12 | end 13 | end 14 | 15 | def find_in(dir) 16 | @cache.fetch(dir) do 17 | @cache[dir] = internal_find_in(dir) 18 | end 19 | end 20 | 21 | def parse(file_contents) 22 | file_contents.lines 23 | .map { |s| s.strip.split(/\s+/, 2) } 24 | .each_with_object({}) do |(name, value), acc| 25 | value ||= "" 26 | if value.start_with?(":") 27 | value = value[1..-1].to_sym 28 | elsif value == "true" 29 | value = true 30 | elsif value == "false" 31 | value = false 32 | else 33 | $stderr.puts "Unknown config value=#{value.inspect} for #{name.inspect}" 34 | next 35 | end 36 | acc[name.to_sym] = value 37 | end 38 | end 39 | 40 | def internal_find_in(dir) 41 | dir = File.expand_path(dir) 42 | file = File.join(dir, ".ruby_crystal_codemod") 43 | if File.exist?(file) 44 | return File.read(file) 45 | end 46 | 47 | parent_dir = File.dirname(dir) 48 | return if parent_dir == dir 49 | 50 | find_in(parent_dir) 51 | end 52 | end 53 | -------------------------------------------------------------------------------- /lib/ruby_crystal_codemod/file_finder.rb: -------------------------------------------------------------------------------- 1 | require "find" 2 | 3 | class RubyCrystalCodemod::FileFinder 4 | include Enumerable 5 | 6 | # Taken from https://github.com/ruby/rake/blob/f0a897e3fb557f64f5da59785b1a4464826f77b2/lib/rake/application.rb#L41 7 | # RAKEFILES = [ 8 | # "rakefile", 9 | # "Rakefile", 10 | # "rakefile.rb", 11 | # "Rakefile.rb", 12 | # ] 13 | 14 | # FILENAMES = [ 15 | # "Gemfile", 16 | # *RAKEFILES, 17 | # ] 18 | 19 | EXTENSIONS = [ 20 | ".rb", 21 | # ".gemspec", 22 | # ".rake", 23 | # ".jbuilder", 24 | ] 25 | 26 | EXCLUDED_DIRS = [ 27 | "vendor", 28 | ] 29 | 30 | def initialize(files_or_dirs) 31 | @files_or_dirs = files_or_dirs 32 | end 33 | 34 | def each 35 | files_or_dirs.each do |file_or_dir| 36 | if Dir.exist?(file_or_dir) 37 | all_rb_files(file_or_dir).each { |file| yield [true, file] } 38 | else 39 | yield [File.exist?(file_or_dir), file_or_dir] 40 | end 41 | end 42 | end 43 | 44 | private 45 | 46 | attr_reader :files_or_dirs 47 | 48 | def all_rb_files(file_or_dir) 49 | files = [] 50 | Find.find(file_or_dir) do |path| 51 | basename = File.basename(path) 52 | if File.directory?(path) 53 | Find.prune if EXCLUDED_DIRS.include?(basename) 54 | else 55 | if EXTENSIONS.include?(File.extname(basename)) #|| FILENAMES.include?(basename) 56 | files << path 57 | end 58 | end 59 | end 60 | files 61 | end 62 | end 63 | -------------------------------------------------------------------------------- /lib/ruby_crystal_codemod/logger.rb: -------------------------------------------------------------------------------- 1 | module RubyCrystalCodemod 2 | class Logger 3 | LEVELS = { 4 | silent: 0, 5 | error: 1, 6 | warn: 2, 7 | log: 3, 8 | debug: 4, 9 | } 10 | 11 | def initialize(level) 12 | @level = LEVELS.fetch(level) 13 | end 14 | 15 | def debug(*args) 16 | $stdout.puts(*args) if should_output?(:debug) 17 | end 18 | 19 | def log(*args) 20 | $stdout.puts(*args) if should_output?(:log) 21 | end 22 | 23 | def warn(*args) 24 | $stderr.puts(*args) if should_output?(:warn) 25 | end 26 | 27 | def error(*args) 28 | $stderr.puts(*args) if should_output?(:error) 29 | end 30 | 31 | private 32 | 33 | attr_reader :level 34 | 35 | def should_output?(level_to_check) 36 | LEVELS.fetch(level_to_check) <= level 37 | end 38 | end 39 | end 40 | -------------------------------------------------------------------------------- /lib/ruby_crystal_codemod/post_process_crystal.rb: -------------------------------------------------------------------------------- 1 | class PostProcessCrystal 2 | attr_reader :filename, :contents 3 | 4 | def self.file_read_lines(path) 5 | File.read(path).lines.map(&:chomp) 6 | end 7 | 8 | def initialize(filename = "") 9 | @filename = filename 10 | @contents = "" 11 | end 12 | 13 | def filename=(filename) 14 | @filename = filename 15 | @contents = "" 16 | end 17 | 18 | def post_process_crystal 19 | @contents = +"" 20 | lines = self.class.file_read_lines(@filename) 21 | 22 | current_lang = nil 23 | regex = /^\s*# ?~# (?(BEGIN|END)) (?(ruby|crystal))/ 24 | uncomment_regex = /^(?\s*)# ?/ 25 | lines.each do |line| 26 | matches = regex.match(line) 27 | if matches 28 | case matches["action"] 29 | when "BEGIN" 30 | current_lang = matches["lang"] 31 | when "END" 32 | current_lang = nil 33 | end 34 | next 35 | end 36 | case current_lang 37 | when "ruby" 38 | next 39 | when "crystal" 40 | line = line.sub(uncomment_regex, "\\k") 41 | end 42 | 43 | @contents << line << "\n" 44 | end 45 | end 46 | end 47 | -------------------------------------------------------------------------------- /lib/ruby_crystal_codemod/settings.rb: -------------------------------------------------------------------------------- 1 | module RubyCrystalCodemod::Settings 2 | OPTIONS = { 3 | parens_in_def: [:yes, :dynamic], 4 | align_case_when: [false, true], 5 | align_chained_calls: [false, true], 6 | trailing_commas: [true, false], 7 | quote_style: [:double, :single], 8 | store_logs: [false, true], 9 | } 10 | 11 | attr_accessor(*OPTIONS.keys) 12 | 13 | def init_settings(options) 14 | OPTIONS.each do |name, valid_options| 15 | default = valid_options.first 16 | value = options.fetch(name, default) 17 | unless valid_options.include?(value) 18 | $stderr.puts "Invalid value for #{name}: #{value.inspect}. Valid " \ 19 | "values are: #{valid_options.map(&:inspect).join(", ")}" 20 | value = default 21 | end 22 | self.public_send("#{name}=", value) 23 | end 24 | diff = options.keys - OPTIONS.keys 25 | diff.each do |key| 26 | $stderr.puts "Invalid config option=#{key}" 27 | end 28 | end 29 | end 30 | -------------------------------------------------------------------------------- /lib/ruby_crystal_codemod/version.rb: -------------------------------------------------------------------------------- 1 | # frozen_string_literal: true 2 | 3 | module RubyCrystalCodemod 4 | VERSION = "0.1.3" 5 | end 6 | -------------------------------------------------------------------------------- /rakelib/ruby_crystal_codemod.rake: -------------------------------------------------------------------------------- 1 | # desc "Alias for `rake rufo:run`" 2 | # task :rufo => ["rufo:run"] 3 | 4 | # namespace :rufo do 5 | # require "rufo" 6 | 7 | # def rufo_command(*switches, rake_args) 8 | # files_or_dirs = rake_args[:files_or_dirs] || "." 9 | # args = switches + files_or_dirs.split(" ") 10 | # RubyCrystalCodemod::Command.run(args) 11 | # end 12 | 13 | # desc "Format Ruby code in current directory" 14 | # task :run, [:files_or_dirs] do |_task, rake_args| 15 | # rufo_command(rake_args) 16 | # end 17 | 18 | # desc "Check that no formatting changes are produced" 19 | # task :check, [:files_or_dirs] do |_task, rake_args| 20 | # rufo_command("--check", rake_args) 21 | # end 22 | # end 23 | -------------------------------------------------------------------------------- /ruby_crystal_codemod.gemspec: -------------------------------------------------------------------------------- 1 | # coding: utf-8 2 | lib = File.expand_path("../lib", __FILE__) 3 | $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib) 4 | require "ruby_crystal_codemod/version" 5 | 6 | Gem::Specification.new do |spec| 7 | spec.name = "ruby_crystal_codemod" 8 | spec.version = RubyCrystalCodemod::VERSION 9 | spec.authors = ["Ary Borenszweig", "Nathan Broadbent"] 10 | spec.email = ["asterite@gmail.com", "nathan@docspring.com"] 11 | 12 | spec.summary = %q{Ruby => Crystal codemod} 13 | spec.description = %q{Attempts to transpile Ruby code into Crystal code} 14 | spec.homepage = "https://github.com/docspring/ruby_crystal_codemod" 15 | spec.license = "MIT" 16 | 17 | spec.files = `git ls-files -z`.split("\x0").reject do |f| 18 | f.match(%r{^(test|spec|features)/}) 19 | end 20 | spec.bindir = "exe" 21 | spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) } 22 | spec.require_paths = ["lib"] 23 | spec.required_ruby_version = ">= 2.4.5" 24 | 25 | spec.add_dependency "gelauto", "~> 1.3.0" 26 | spec.add_dependency "awesome_print", "~> 1.8.0" 27 | spec.add_dependency "byebug", "~> 10.0.2" 28 | 29 | spec.add_development_dependency "bundler", ">= 1.15" 30 | spec.add_development_dependency "guard-rspec", "~> 4.0" 31 | spec.add_development_dependency "rake", "~> 10.0" 32 | spec.add_development_dependency "rspec", "~> 3.0" 33 | spec.add_development_dependency "rspec_junit_formatter", "~> 0.4.1" 34 | spec.add_development_dependency "rubocop", "~> 0.63.1" 35 | spec.add_development_dependency "rufo", "~> 0.7.0" 36 | end 37 | -------------------------------------------------------------------------------- /run_test: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | set -eo pipefail 3 | 4 | # For testing things 5 | ./exe/ruby_crystal_codemod --simple-exit test.rb && crystal run test.cr 6 | -------------------------------------------------------------------------------- /spec/crystal_codemod_acceptance_spec.rb: -------------------------------------------------------------------------------- 1 | require "spec_helper" 2 | require "open3" 3 | 4 | RSpec.describe "Crystal Codemod" do 5 | it "transpiles the example Ruby code into Crystal and produces the same output" do 6 | root_folder = File.expand_path(File.join(__dir__, "../")) 7 | 8 | crystal_files = Dir.glob(File.join(root_folder, "spec/fixtures/**/*.cr")) 9 | crystal_files -= Dir.glob(File.join(root_folder, "spec/fixtures/rspec_project/**/*.cr")) 10 | FileUtils.rm_rf(crystal_files) 11 | 12 | source_folder = File.join(root_folder, "spec/fixtures/crystal_codemod_test") 13 | ruby_entry = File.join(source_folder, "example.rb") 14 | crystal_entry = File.join(source_folder, "example.cr") 15 | 16 | Dir.chdir source_folder do 17 | stdout, stderr, status = Open3.capture3("../../../exe/ruby_crystal_codemod", "--simple-exit", source_folder) 18 | unless status.success? 19 | raise "ruby_crystal_codemod failed with status: #{status.exitstatus}\n\n" \ 20 | "stdout: #{stdout}\n\n" \ 21 | "stderr: #{stderr}" 22 | end 23 | end 24 | 25 | stdout, stderr, status = Open3.capture3("ruby", ruby_entry) 26 | unless status.success? 27 | raise "Ruby failed with status: #{status.exitstatus}\n\n" \ 28 | "stdout: #{stdout}\n\n" \ 29 | "stderr: #{stderr}" 30 | end 31 | ruby_output = stdout.strip 32 | 33 | # expected_output_file = File.join(source_folder, "expected_output.txt") 34 | # # File.open(expected_ruby_output_file, 'w') { |f| f.puts stdout.strip } 35 | # expected_output = File.read(expected_output_file) 36 | # expect(ruby_output).to eq expected_output.strip 37 | 38 | default_crystal_path = `crystal env CRYSTAL_PATH`.chomp 39 | crystal_path = "#{default_crystal_path}:#{source_folder}" 40 | 41 | stdout, stderr, status = Open3.capture3({ 42 | "CRYSTAL_PATH" => crystal_path, 43 | }, "crystal", "run", crystal_entry) 44 | unless status.success? 45 | raise "Crystal failed with status: #{status.exitstatus}\n\n" \ 46 | "stdout: #{stdout}\n\n" \ 47 | "stderr: #{stderr}" 48 | end 49 | crystal_output = stdout.strip 50 | 51 | expect(crystal_output).to eq ruby_output 52 | end 53 | end 54 | -------------------------------------------------------------------------------- /spec/fixtures/crystal_codemod_test/example.cr: -------------------------------------------------------------------------------- 1 | require "./subfolder/double" 2 | require "./subfolder/double" 3 | require "subfolder/double" 4 | require "subfolder/double" 5 | require "subfolder/double" 6 | puts "helllooooooooooooo" 7 | require "subfolder/double" 8 | puts "hello" 9 | require "../crystal_codemod_test/subfolder/double" 10 | require "./subfolder/triple" 11 | require "./subfolder/triple" 12 | require "./subfolder/triple" 13 | require "./subfolder/triple" 14 | require "./subfolder/triple" 15 | 16 | def fuel_for(mass) 17 | puts "Calculating fuel for mass: #{mass}" 18 | fuel = (mass.to_i / 3).floor.to_i - 2 19 | return 0 if fuel <= 0 20 | fuel + fuel_for(fuel) 21 | end 22 | 23 | puts File.read(File.join(__DIR__, "input")).lines.sum { |mass| fuel_for(mass) } 24 | 25 | puts "2 x 2: #{double(2)}" 26 | puts "2 x 2 x 2: #{triple(2)}" 27 | 28 | include NestedRequire 29 | nested_require_works? 30 | include ParentRequire 31 | require_parent_file_works? 32 | 33 | arr = %w[apple orange pear pineapple] 34 | puts arr.includes?("apple") ? "got apple" : "don't got apple" 35 | 36 | hash = {foo: 123, bar: 345, baz: 456} 37 | puts hash.has_key? :foo ? "got foo" : "don't got foo" 38 | 39 | has_pear = arr.find do |el| 40 | el == "pear" 41 | end 42 | puts has_pear ? "has a pear" : "not has a pear" 43 | 44 | has_pear = arr.find { |el| el == "pear" } 45 | puts has_pear ? "has a pear" : "not has a pear" 46 | 47 | puts arr.map { |el| "#{el.upcase}!" }.join(", ") 48 | upcased = arr.map do |el| 49 | "#{el.upcase}!" 50 | end 51 | puts upcased.join(", ") 52 | 53 | if arr.responds_to?(:map) 54 | puts "arr responds to map" 55 | end 56 | 57 | puts "array size: " 58 | puts arr.size 59 | puts arr.size 60 | puts arr.size 61 | 62 | puts "not false" if !false 63 | puts "not false" if !false 64 | puts "not !true" if !!true 65 | puts "is !!true" if !!true 66 | 67 | arr.size > 2 && arr.size < 10 && puts "arr size is between 2 and 10" 68 | 69 | (arr.size < 2 || arr.size > 100_000) || puts "arr size is between 2 and 10" 70 | (arr.size > 2 || arr.size > 100_000) || puts "should not be called" 71 | 72 | puts arr.map(&.downcase).join("|") 73 | upcase = arr.map &.upcase 74 | puts upcase.join(" ") 75 | up_reverse = arr.map(&.upcase).map &.reverse 76 | puts up_reverse.to_s 77 | 78 | class Foo 79 | property :foo 80 | setter :bar 81 | getter :baz 82 | 83 | @foo : Int32 84 | @bar : Int32 85 | @baz : Int32 86 | 87 | def initialize(@foo : Int32, @bar : Int32, @baz : Int32) 88 | end 89 | 90 | def bar 91 | @bar 92 | end 93 | 94 | def baz=(val) 95 | @baz = val 96 | end 97 | end 98 | 99 | foo = Foo.new(1, 100, 1000) 100 | puts "foo: #{foo.foo}" 101 | puts "bar: #{foo.bar}" 102 | puts "baz: #{foo.baz}" 103 | foo.foo *= 2 104 | puts "foo: #{foo.foo}" 105 | foo.bar *= 2 106 | puts "bar: #{foo.bar}" 107 | foo.baz *= 2 108 | puts "baz: #{foo.baz}" 109 | -------------------------------------------------------------------------------- /spec/fixtures/crystal_codemod_test/example.rb: -------------------------------------------------------------------------------- 1 | $:.unshift __dir__ 2 | 3 | require_relative './subfolder/double' 4 | require_relative "./subfolder/double" 5 | require \ 6 | "subfolder/double" 7 | require( 8 | "subfolder/double" 9 | ) 10 | require( 11 | "subfolder/double" 12 | ); puts 'helllooooooooooooo' 13 | require 'subfolder/double'; puts 'hello' 14 | require_relative "../crystal_codemod_test/subfolder/double" 15 | require_relative 'subfolder/triple' 16 | require_relative "subfolder/triple" 17 | require_relative \ 18 | "subfolder/triple" 19 | require_relative("subfolder/triple") 20 | require_relative( 21 | "subfolder/triple" 22 | ) 23 | 24 | def fuel_for(mass) 25 | puts "Calculating fuel for mass: #{mass}" 26 | fuel = (mass.to_i / 3).floor.to_i - 2 27 | return 0 if fuel <= 0 28 | fuel + fuel_for(fuel) 29 | end 30 | 31 | puts File.read(File.join(__dir__, 'input')).lines.sum { |mass| fuel_for(mass) } 32 | 33 | puts "2 x 2: #{double(2)}" 34 | puts "2 x 2 x 2: #{triple(2)}" 35 | 36 | include NestedRequire 37 | nested_require_works? 38 | include ParentRequire 39 | require_parent_file_works? 40 | 41 | 42 | arr = %w[apple orange pear pineapple] 43 | puts arr.include?('apple') ? 'got apple' : "don't got apple" 44 | 45 | hash = { foo: 123, bar: 345, baz: 456 } 46 | puts hash.key? :foo ? "got foo" : "don't got foo" 47 | 48 | has_pear = arr.detect do |el| 49 | el == 'pear' 50 | end 51 | puts has_pear ? "has a pear" : "not has a pear" 52 | 53 | has_pear = arr.detect { |el| el == 'pear' } 54 | puts has_pear ? "has a pear" : "not has a pear" 55 | 56 | puts arr.collect {|el| "#{el.upcase}!" }.join(", ") 57 | upcased = arr.collect do |el| 58 | "#{el.upcase}!" 59 | end 60 | puts upcased.join(", ") 61 | 62 | if arr.respond_to?(:map) 63 | puts "arr responds to map" 64 | end 65 | 66 | puts "array size: " 67 | puts arr.length 68 | puts arr.count 69 | puts arr.size 70 | 71 | puts "not false" if !false 72 | puts "not false" if not false 73 | puts "not !true" if not !true 74 | puts "is !!true" if !!true 75 | 76 | arr.size > 2 and arr.size < 10 and puts "arr size is between 2 and 10" 77 | 78 | (arr.size < 2 or arr.size > 100_000) or puts "arr size is between 2 and 10" 79 | (arr.size > 2 or arr.size > 100_000) or puts "should not be called" 80 | 81 | puts arr.map(&:downcase).join('|') 82 | upcase = arr.map &:upcase 83 | puts upcase.join(' ') 84 | up_reverse = arr.map(&:upcase).map &:reverse 85 | puts up_reverse.to_s 86 | 87 | class Foo 88 | attr_accessor :foo 89 | attr_writer :bar 90 | attr_reader :baz 91 | 92 | #~# BEGIN ruby 93 | def initialize(foo, bar, baz) 94 | @foo = foo 95 | @bar = bar 96 | @baz = baz 97 | end 98 | #~# END ruby 99 | #~# BEGIN crystal 100 | # @foo : Int32 101 | # @bar : Int32 102 | # @baz : Int32 103 | # def initialize(@foo : Int32, @bar : Int32, @baz : Int32) 104 | # end 105 | #~# END crystal 106 | 107 | def bar 108 | @bar 109 | end 110 | 111 | def baz=(val) 112 | @baz = val 113 | end 114 | end 115 | 116 | foo = Foo.new(1, 100, 1000) 117 | puts "foo: #{foo.foo}" 118 | puts "bar: #{foo.bar}" 119 | puts "baz: #{foo.baz}" 120 | foo.foo *= 2 121 | puts "foo: #{foo.foo}" 122 | foo.bar *= 2 123 | puts "bar: #{foo.bar}" 124 | foo.baz *= 2 125 | puts "baz: #{foo.baz}" 126 | -------------------------------------------------------------------------------- /spec/fixtures/crystal_codemod_test/example_invalid.cr: -------------------------------------------------------------------------------- 1 | require_relative 2 | require_relative 123 3 | require_relative :asdf 4 | require_relative ["asdf"] 5 | require_relative %w[asdf] 6 | require_relative({aasdf: 232}) 7 | -------------------------------------------------------------------------------- /spec/fixtures/crystal_codemod_test/example_invalid.rb: -------------------------------------------------------------------------------- 1 | require_relative 2 | require_relative 123 3 | require_relative :asdf 4 | require_relative ['asdf'] 5 | require_relative %w[asdf] 6 | require_relative({ aasdf: 232 }) 7 | -------------------------------------------------------------------------------- /spec/fixtures/crystal_codemod_test/expected_output.txt: -------------------------------------------------------------------------------- 1 | helllooooooooooooo 2 | hello 3 | Calculating fuel for mass: 141255 4 | Calculating fuel for mass: 47083 5 | Calculating fuel for mass: 15692 6 | Calculating fuel for mass: 5228 7 | Calculating fuel for mass: 1740 8 | Calculating fuel for mass: 578 9 | Calculating fuel for mass: 190 10 | Calculating fuel for mass: 61 11 | Calculating fuel for mass: 18 12 | Calculating fuel for mass: 4 13 | Calculating fuel for mass: 93769 14 | Calculating fuel for mass: 31254 15 | Calculating fuel for mass: 10416 16 | Calculating fuel for mass: 3470 17 | Calculating fuel for mass: 1154 18 | Calculating fuel for mass: 382 19 | Calculating fuel for mass: 125 20 | Calculating fuel for mass: 39 21 | Calculating fuel for mass: 11 22 | Calculating fuel for mass: 1 23 | 117446 24 | 2 x 2: 4 25 | 2 x 2 x 2: 6 26 | yeah it works 27 | yeah parent file works 28 | -------------------------------------------------------------------------------- /spec/fixtures/crystal_codemod_test/input: -------------------------------------------------------------------------------- 1 | 141255 2 | 93769 3 | -------------------------------------------------------------------------------- /spec/fixtures/crystal_codemod_test/parent_require.cr: -------------------------------------------------------------------------------- 1 | module ParentRequire 2 | def require_parent_file_works? 3 | puts "yeah parent file works" 4 | end 5 | end 6 | -------------------------------------------------------------------------------- /spec/fixtures/crystal_codemod_test/parent_require.rb: -------------------------------------------------------------------------------- 1 | module ParentRequire 2 | def require_parent_file_works? 3 | puts "yeah parent file works" 4 | end 5 | end 6 | -------------------------------------------------------------------------------- /spec/fixtures/crystal_codemod_test/require_relative_paren.cr: -------------------------------------------------------------------------------- 1 | require "subfolder/nested_require" 2 | 3 | require "subfolder/nested_require" 4 | 5 | require "example" 6 | 7 | require "subfolder/triple" 8 | puts "hello" 9 | 10 | require "test" 11 | puts "hello" 12 | 13 | require "test\"'" 14 | puts "hello" 15 | 16 | require "test\"'" 17 | require "test'" 18 | require "test" 19 | 20 | require "./test\"" 21 | require "./test" 22 | require "./test" 23 | -------------------------------------------------------------------------------- /spec/fixtures/crystal_codemod_test/require_relative_paren.rb: -------------------------------------------------------------------------------- 1 | require File.expand_path('./subfolder/nested_require', File.dirname(__FILE__)) 2 | 3 | require( 4 | File.expand_path('./subfolder/nested_require', File.dirname(__FILE__)) 5 | ) 6 | 7 | require \ 8 | File.expand_path('example', __dir__) 9 | 10 | require \ 11 | File.expand_path('subfolder/triple', __dir__); puts 'hello' 12 | 13 | require( 14 | "test" 15 | ); puts 'hello' 16 | 17 | require 'test"\''; puts 'hello' 18 | 19 | require 'test"\'' 20 | require "test'" 21 | require("test") 22 | 23 | require_relative 'test"' 24 | require_relative "test" 25 | require_relative("test") 26 | -------------------------------------------------------------------------------- /spec/fixtures/crystal_codemod_test/subfolder/double.cr: -------------------------------------------------------------------------------- 1 | require "parent_'require\"" 2 | require "../parent_'require\"" 3 | require "subfolder/nested_require" 4 | 5 | def double(x) 6 | x + x 7 | end 8 | -------------------------------------------------------------------------------- /spec/fixtures/crystal_codemod_test/subfolder/double.rb: -------------------------------------------------------------------------------- 1 | require 'parent_\'require"' 2 | require_relative "../parent_'require\"" 3 | require File.expand_path('./nested_require', File.dirname(__FILE__)) 4 | 5 | def double(x) 6 | x + x 7 | end 8 | -------------------------------------------------------------------------------- /spec/fixtures/crystal_codemod_test/subfolder/nested_require.cr: -------------------------------------------------------------------------------- 1 | module NestedRequire 2 | def nested_require_works? 3 | puts "yeah it works" 4 | end 5 | end 6 | -------------------------------------------------------------------------------- /spec/fixtures/crystal_codemod_test/subfolder/nested_require.rb: -------------------------------------------------------------------------------- 1 | module NestedRequire 2 | def nested_require_works? 3 | puts 'yeah it works' 4 | end 5 | end 6 | -------------------------------------------------------------------------------- /spec/fixtures/crystal_codemod_test/subfolder/triple.cr: -------------------------------------------------------------------------------- 1 | def triple(x) 2 | x * 3 3 | end 4 | -------------------------------------------------------------------------------- /spec/fixtures/crystal_codemod_test/subfolder/triple.rb: -------------------------------------------------------------------------------- 1 | def triple(x) 2 | x * 3 3 | end 4 | -------------------------------------------------------------------------------- /spec/fixtures/file_finder/only_gemfiles/Gemfile: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /spec/fixtures/file_finder/only_gemfiles/a.gemspec: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /spec/fixtures/file_finder/only_rake_files/Rakefile: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /spec/fixtures/file_finder/only_rake_files/a.rake: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /spec/fixtures/file_finder/only_ruby/a.rb: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /spec/fixtures/file_finder/only_vendor/vendor/a.rb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DocSpring/ruby_crystal_codemod/f7ed800c83c087f4c299a4bfe0679d3f932d5b62/spec/fixtures/file_finder/only_vendor/vendor/a.rb -------------------------------------------------------------------------------- /spec/fixtures/needs_changes: -------------------------------------------------------------------------------- 1 | class NeedsChanges 2 | def a_method( with_bizarre_formatting) 3 | end 4 | end 5 | -------------------------------------------------------------------------------- /spec/fixtures/rspec_project/.gitignore: -------------------------------------------------------------------------------- 1 | .git 2 | .bundle 3 | lib 4 | Gemfile.lock 5 | -------------------------------------------------------------------------------- /spec/fixtures/rspec_project/Gemfile: -------------------------------------------------------------------------------- 1 | source 'https://rubygems.org' 2 | 3 | gem 'gelauto' 4 | gem 'sorbet' 5 | gem 'sorbet-runtime' 6 | 7 | group :development do 8 | gem 'pry-byebug' 9 | gem 'rspec' 10 | gem 'rake' 11 | end 12 | -------------------------------------------------------------------------------- /spec/fixtures/rspec_project/run_gelauto: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | gelauto run --annotate $(find . -name '*.rb') -- bundle exec rspec spec/ 3 | -------------------------------------------------------------------------------- /spec/fixtures/rspec_project/shard.lock: -------------------------------------------------------------------------------- 1 | version: 1.0 2 | shards: 3 | spectator: 4 | gitlab: arctic-fox/spectator 5 | version: 0.8.3 6 | 7 | -------------------------------------------------------------------------------- /spec/fixtures/rspec_project/shard.yml: -------------------------------------------------------------------------------- 1 | name: example_class 2 | version: 0.1.0 3 | 4 | development_dependencies: 5 | spectator: 6 | gitlab: arctic-fox/spectator 7 | 8 | license: MIT 9 | -------------------------------------------------------------------------------- /spec/fixtures/rspec_project/sorbet/config: -------------------------------------------------------------------------------- 1 | --dir 2 | . 3 | -------------------------------------------------------------------------------- /spec/fixtures/rspec_project/sorbet/rbi/gems/ast.rbi: -------------------------------------------------------------------------------- 1 | # This file is autogenerated. Do not edit it by hand. Regenerate it with: 2 | # srb rbi gems 3 | 4 | # typed: strong 5 | # 6 | # If you would like to make changes to this file, great! Please create the gem's shim here: 7 | # 8 | # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/ast/all/ast.rbi 9 | # 10 | # ast-2.4.0 11 | module AST 12 | end 13 | class AST::Node 14 | def +(array); end 15 | def <<(element); end 16 | def ==(other); end 17 | def append(element); end 18 | def assign_properties(properties); end 19 | def children; end 20 | def clone; end 21 | def concat(array); end 22 | def dup; end 23 | def eql?(other); end 24 | def fancy_type; end 25 | def hash; end 26 | def initialize(type, children = nil, properties = nil); end 27 | def inspect(indent = nil); end 28 | def original_dup; end 29 | def to_a; end 30 | def to_ast; end 31 | def to_s(indent = nil); end 32 | def to_sexp(indent = nil); end 33 | def to_sexp_array; end 34 | def type; end 35 | def updated(type = nil, children = nil, properties = nil); end 36 | end 37 | class AST::Processor 38 | include AST::Processor::Mixin 39 | end 40 | module AST::Processor::Mixin 41 | def handler_missing(node); end 42 | def process(node); end 43 | def process_all(nodes); end 44 | end 45 | module AST::Sexp 46 | def s(type, *children); end 47 | end 48 | -------------------------------------------------------------------------------- /spec/fixtures/rspec_project/sorbet/rbi/gems/coderay.rbi: -------------------------------------------------------------------------------- 1 | # This file is autogenerated. Do not edit it by hand. Regenerate it with: 2 | # srb rbi gems 3 | 4 | # typed: strong 5 | # 6 | # If you would like to make changes to this file, great! Please create the gem's shim here: 7 | # 8 | # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/coderay/all/coderay.rbi 9 | # 10 | # coderay-1.1.2 11 | module CodeRay 12 | def self.coderay_path(*path); end 13 | def self.encode(code, lang, format, options = nil); end 14 | def self.encode_file(filename, format, options = nil); end 15 | def self.encode_tokens(tokens, format, options = nil); end 16 | def self.encoder(format, options = nil); end 17 | def self.get_scanner_options(options); end 18 | def self.highlight(code, lang, options = nil, format = nil); end 19 | def self.highlight_file(filename, options = nil, format = nil); end 20 | def self.scan(code, lang, options = nil, &block); end 21 | def self.scan_file(filename, lang = nil, options = nil, &block); end 22 | def self.scanner(lang, options = nil, &block); end 23 | end 24 | module CodeRay::PluginHost 25 | def [](id, *args, &blk); end 26 | def all_plugins; end 27 | def const_missing(const); end 28 | def default(id = nil); end 29 | def list; end 30 | def load(id, *args, &blk); end 31 | def load_all; end 32 | def load_plugin_map; end 33 | def make_plugin_hash; end 34 | def map(hash); end 35 | def path_to(plugin_id); end 36 | def plugin_hash; end 37 | def plugin_path(*args); end 38 | def register(plugin, id); end 39 | def self.extended(mod); end 40 | def validate_id(id); end 41 | end 42 | class CodeRay::PluginHost::PluginNotFound < LoadError 43 | end 44 | class CodeRay::PluginHost::HostNotFound < LoadError 45 | end 46 | module CodeRay::Encoders 47 | extend CodeRay::PluginHost 48 | end 49 | module CodeRay::Plugin 50 | def aliases; end 51 | def plugin_host(host = nil); end 52 | def plugin_id; end 53 | def register_for(id); end 54 | def title(title = nil); end 55 | end 56 | class CodeRay::Encoders::Encoder 57 | def <<(token); end 58 | def begin_group(kind); end 59 | def begin_line(kind); end 60 | def compile(tokens, options = nil); end 61 | def encode(code, lang, options = nil); end 62 | def encode_tokens(tokens, options = nil); end 63 | def end_group(kind); end 64 | def end_line(kind); end 65 | def file_extension; end 66 | def finish(options); end 67 | def get_output(options); end 68 | def highlight(code, lang, options = nil); end 69 | def initialize(options = nil); end 70 | def options; end 71 | def options=(arg0); end 72 | def output(data); end 73 | def scanner; end 74 | def scanner=(arg0); end 75 | def self.const_missing(sym); end 76 | def self.file_extension; end 77 | def setup(options); end 78 | def text_token(text, kind); end 79 | def token(content, kind); end 80 | def tokens(tokens, options = nil); end 81 | extend CodeRay::Plugin 82 | end 83 | class CodeRay::Encoders::Terminal < CodeRay::Encoders::Encoder 84 | def begin_group(kind); end 85 | def begin_line(kind); end 86 | def end_group(kind); end 87 | def end_line(kind); end 88 | def open_token(kind); end 89 | def setup(options); end 90 | def text_token(text, kind); end 91 | end 92 | -------------------------------------------------------------------------------- /spec/fixtures/rspec_project/sorbet/rbi/gems/gelauto.rbi: -------------------------------------------------------------------------------- 1 | # This file is autogenerated. Do not edit it by hand. Regenerate it with: 2 | # srb rbi gems 3 | 4 | # typed: strong 5 | # 6 | # If you would like to make changes to this file, great! Please create the gem's shim here: 7 | # 8 | # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/gelauto/all/gelauto.rbi 9 | # 10 | # gelauto-1.3.0 11 | module Gelauto 12 | def self.annotate_file(path); end 13 | def self.call_trace; end 14 | def self.disable_traces; end 15 | def self.discover; end 16 | def self.each_absolute_path(&block); end 17 | def self.enable_traces; end 18 | def self.index_methods; end 19 | def self.introspect(obj); end 20 | def self.logger; end 21 | def self.logger=(arg0); end 22 | def self.method_index; end 23 | def self.paths; end 24 | def self.paths=(arg0); end 25 | def self.register_type(type, handler); end 26 | def self.return_trace; end 27 | def self.setup; end 28 | def self.teardown; end 29 | def self.types; end 30 | end 31 | class Gelauto::GenericType 32 | def [](generic_arg_name); end 33 | def generic_args; end 34 | def initialize(ruby_type, generic_arg_names = nil); end 35 | def ruby_type; end 36 | def to_sig; end 37 | end 38 | class Gelauto::HashType < Gelauto::GenericType 39 | def initialize; end 40 | def merge!(other); end 41 | def self.introspect(obj); end 42 | def to_sig; end 43 | end 44 | class Gelauto::Type 45 | def initialize(ruby_type); end 46 | def ruby_type; end 47 | def self.introspect(obj); end 48 | def to_sig; end 49 | end 50 | class Gelauto::ArrayType < Gelauto::GenericType 51 | def initialize; end 52 | def merge!(other); end 53 | def self.introspect(obj); end 54 | def to_sig; end 55 | end 56 | class Gelauto::BooleanType < Gelauto::Type 57 | def to_sig; end 58 | end 59 | -------------------------------------------------------------------------------- /spec/fixtures/rspec_project/sorbet/rbi/gems/method_source.rbi: -------------------------------------------------------------------------------- 1 | # This file is autogenerated. Do not edit it by hand. Regenerate it with: 2 | # srb rbi gems 3 | 4 | # typed: strong 5 | # 6 | # If you would like to make changes to this file, great! Please create the gem's shim here: 7 | # 8 | # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/method_source/all/method_source.rbi 9 | # 10 | # method_source-0.9.2 11 | module MethodSource 12 | def self.comment_helper(source_location, name = nil); end 13 | def self.extract_code(source_location); end 14 | def self.lines_for(file_name, name = nil); end 15 | def self.source_helper(source_location, name = nil); end 16 | def self.valid_expression?(str); end 17 | extend MethodSource::CodeHelpers 18 | end 19 | module MethodSource::ReeSourceLocation 20 | def source_location; end 21 | end 22 | module MethodSource::SourceLocation 23 | end 24 | module MethodSource::SourceLocation::MethodExtensions 25 | def source_location; end 26 | def trace_func(event, file, line, id, binding, classname); end 27 | end 28 | module MethodSource::SourceLocation::ProcExtensions 29 | def source_location; end 30 | end 31 | module MethodSource::SourceLocation::UnboundMethodExtensions 32 | def source_location; end 33 | end 34 | module MethodSource::CodeHelpers 35 | def comment_describing(file, line_number); end 36 | def complete_expression?(str); end 37 | def expression_at(file, line_number, options = nil); end 38 | def extract_first_expression(lines, consume = nil, &block); end 39 | def extract_last_comment(lines); end 40 | end 41 | module MethodSource::CodeHelpers::IncompleteExpression 42 | def self.===(ex); end 43 | def self.rbx?; end 44 | end 45 | class MethodSource::SourceNotFoundError < StandardError 46 | end 47 | module MethodSource::MethodExtensions 48 | def comment; end 49 | def self.included(klass); end 50 | def source; end 51 | end 52 | class Method 53 | include MethodSource::MethodExtensions 54 | include MethodSource::SourceLocation::MethodExtensions 55 | end 56 | class UnboundMethod 57 | include MethodSource::MethodExtensions 58 | include MethodSource::SourceLocation::UnboundMethodExtensions 59 | end 60 | class Proc 61 | include MethodSource::MethodExtensions 62 | include MethodSource::SourceLocation::ProcExtensions 63 | end 64 | -------------------------------------------------------------------------------- /spec/fixtures/rspec_project/sorbet/rbi/gems/pry-byebug.rbi: -------------------------------------------------------------------------------- 1 | # This file is autogenerated. Do not edit it by hand. Regenerate it with: 2 | # srb rbi gems 3 | 4 | # typed: true 5 | # 6 | # If you would like to make changes to this file, great! Please create the gem's shim here: 7 | # 8 | # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/pry-byebug/all/pry-byebug.rbi 9 | # 10 | # pry-byebug-3.7.0 11 | module PryByebug 12 | def check_file_context(target, msg = nil); end 13 | def current_remote_server; end 14 | def current_remote_server=(arg0); end 15 | def file_context?(target); end 16 | def self.check_file_context(target, msg = nil); end 17 | def self.file_context?(target); end 18 | end 19 | module Byebug 20 | end 21 | class Byebug::PryProcessor < Byebug::CommandProcessor 22 | def at_breakpoint(breakpoint); end 23 | def at_end; end 24 | def at_line; end 25 | def at_return(_return_value); end 26 | def bold(*args, &block); end 27 | def n_hits(breakpoint); end 28 | def output(*args, &block); end 29 | def perform(action, options = nil); end 30 | def perform_backtrace(_options); end 31 | def perform_down(options); end 32 | def perform_finish(*arg0); end 33 | def perform_frame(options); end 34 | def perform_next(options); end 35 | def perform_step(options); end 36 | def perform_up(options); end 37 | def pry; end 38 | def pry=(arg0); end 39 | def resume_pry; end 40 | def run(&_block); end 41 | def self.start; end 42 | extend Forwardable 43 | end 44 | class Pry 45 | def self.start_with_pry_byebug(target = nil, options = nil); end 46 | def self.start_without_pry_byebug(target = nil, options = nil); end 47 | end 48 | module PryByebug::Helpers 49 | end 50 | module PryByebug::Helpers::Navigation 51 | def breakout_navigation(action, options = nil); end 52 | end 53 | class PryByebug::BacktraceCommand < Pry::ClassCommand 54 | def process; end 55 | include PryByebug::Helpers::Navigation 56 | end 57 | module PryByebug::Helpers::Multiline 58 | def check_multiline_context; end 59 | end 60 | class PryByebug::NextCommand < Pry::ClassCommand 61 | def process; end 62 | include PryByebug::Helpers::Multiline 63 | include PryByebug::Helpers::Navigation 64 | end 65 | class PryByebug::StepCommand < Pry::ClassCommand 66 | def process; end 67 | include PryByebug::Helpers::Navigation 68 | end 69 | module PryByebug::Helpers::Breakpoints 70 | def bold_puts(msg); end 71 | def breakpoints; end 72 | def current_file; end 73 | def max_width; end 74 | def print_breakpoints_header; end 75 | def print_full_breakpoint(breakpoint); end 76 | def print_short_breakpoint(breakpoint); end 77 | end 78 | class PryByebug::ContinueCommand < Pry::ClassCommand 79 | def process; end 80 | include PryByebug::Helpers::Breakpoints 81 | include PryByebug::Helpers::Navigation 82 | end 83 | class PryByebug::FinishCommand < Pry::ClassCommand 84 | def process; end 85 | include PryByebug::Helpers::Navigation 86 | end 87 | class PryByebug::UpCommand < Pry::ClassCommand 88 | def process; end 89 | include PryByebug::Helpers::Navigation 90 | end 91 | class PryByebug::DownCommand < Pry::ClassCommand 92 | def process; end 93 | include PryByebug::Helpers::Navigation 94 | end 95 | class PryByebug::FrameCommand < Pry::ClassCommand 96 | def process; end 97 | include PryByebug::Helpers::Navigation 98 | end 99 | module Pry::Byebug 100 | end 101 | module Pry::Byebug::Breakpoints 102 | def add_file(file, line, expression = nil); end 103 | def add_method(method, expression = nil); end 104 | def breakpoints; end 105 | def change(id, expression = nil); end 106 | def change_status(id, enabled = nil); end 107 | def delete(id); end 108 | def delete_all; end 109 | def disable(id); end 110 | def disable_all; end 111 | def each(&block); end 112 | def enable(id); end 113 | def find_by_id(id); end 114 | def last; end 115 | def size; end 116 | def to_a; end 117 | def validate_expression(exp); end 118 | extend Enumerable 119 | extend Pry::Byebug::Breakpoints 120 | end 121 | class Pry::Byebug::Breakpoints::FileBreakpoint < SimpleDelegator 122 | def source_code; end 123 | def to_s; end 124 | end 125 | class Pry::Byebug::Breakpoints::MethodBreakpoint < SimpleDelegator 126 | def initialize(byebug_bp, method); end 127 | def source_code; end 128 | def to_s; end 129 | end 130 | class PryByebug::BreakCommand < Pry::ClassCommand 131 | def add_breakpoint(place, condition); end 132 | def new_breakpoint; end 133 | def option_to_method(option); end 134 | def options(opt); end 135 | def print_all; end 136 | def process; end 137 | def process_condition; end 138 | def process_delete; end 139 | def process_delete_all; end 140 | def process_disable; end 141 | def process_disable_all; end 142 | def process_enable; end 143 | def process_show; end 144 | include PryByebug::Helpers::Breakpoints 145 | include PryByebug::Helpers::Multiline 146 | end 147 | class PryByebug::ExitAllCommand < Pry::Command::ExitAll 148 | def process; end 149 | end 150 | -------------------------------------------------------------------------------- /spec/fixtures/rspec_project/sorbet/rbi/gems/rspec.rbi: -------------------------------------------------------------------------------- 1 | # This file is autogenerated. Do not edit it by hand. Regenerate it with: 2 | # srb rbi gems 3 | 4 | # typed: strong 5 | # 6 | # If you would like to make changes to this file, great! Please create the gem's shim here: 7 | # 8 | # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec/all/rspec.rbi 9 | # 10 | # rspec-3.9.0 11 | module RSpec 12 | end 13 | module RSpec::Version 14 | end 15 | -------------------------------------------------------------------------------- /spec/fixtures/rspec_project/spec/spec_helper.cr: -------------------------------------------------------------------------------- 1 | require "../src/example_class_annotated" 2 | require "spectator" 3 | -------------------------------------------------------------------------------- /spec/fixtures/rspec_project/spec/spec_helper.rb: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | $:.push(File.expand_path("../..", __FILE__)) 3 | $:.push(File.dirname(__FILE__)) 4 | 5 | require 'rspec' 6 | require 'pry-byebug' 7 | require 'sorbet-runtime' 8 | require 'src/example_class_annotated' 9 | 10 | Dir.chdir('spec') do 11 | Dir.glob('support/*.rb').each do |f| 12 | require f 13 | end 14 | end 15 | 16 | # quiet logs for test runs 17 | # Gelauto.logger.level = :fatal 18 | -------------------------------------------------------------------------------- /spec/fixtures/rspec_project/spec/src/example_class_annotated_spec.cr: -------------------------------------------------------------------------------- 1 | require "../spec_helper" 2 | 3 | Spectator.describe ExampleClass do 4 | it "should add @foo and @bar" do 5 | instance = ExampleClass.new(2, 3) 6 | expect(instance.add).to eq 5 7 | end 8 | 9 | it "should add @foo and @bar and val" do 10 | instance = ExampleClass.new(2, 3) 11 | expect(instance.add(5)).to eq 10 12 | end 13 | 14 | it "should add @foo and @bar and val and @baz" do 15 | instance = ExampleClass.new(2, 3) 16 | instance.baz = 10 17 | expect(instance.add(5)).to eq 20 18 | end 19 | 20 | it "returns the correct value for ExampleClass.whisper" do 21 | expect(ExampleClass.whisper("HELLOOOOOOOOOOOOOOOO")).to eq "hello" 22 | end 23 | 24 | it "returns the correct value for ExampleClass#shout" do 25 | instance = ExampleClass.new(nil, :random_unused_symbol) 26 | expect(instance.shout("hello")).to eq "HELLOOOOOOOOOOOOOOOO" 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /spec/fixtures/rspec_project/spec/src/example_class_annotated_spec.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | require 'spec_helper' 4 | 5 | RSpec.describe ExampleClass do 6 | it 'should add @foo and @bar' do 7 | instance = ExampleClass.new(2, 3, 4) 8 | expect(instance.add).to eq 5 9 | end 10 | 11 | it 'should add @foo and @bar and val' do 12 | instance = ExampleClass.new(2, 3, 4) 13 | expect(instance.add(5)).to eq 10 14 | end 15 | 16 | it 'should add @foo and @bar and val and @baz' do 17 | instance = ExampleClass.new(2, 3, 4) 18 | instance.baz = 10 19 | expect(instance.add(5)).to eq 20 20 | end 21 | 22 | it 'returns the correct value for ExampleClass.whisper' do 23 | expect(ExampleClass.whisper("HELLOOOOOOOOOOOOOOOO")).to eq "hello" 24 | end 25 | 26 | it 'returns the correct value for ExampleClass#shout' do 27 | # This call makes foo nilable, and adds Symbol to the bar types 28 | instance = ExampleClass.new(nil, :random_unused_symbol, 4) 29 | expect(instance.shout("hello")).to eq "HELLOOOOOOOOOOOOOOOO" 30 | end 31 | end 32 | -------------------------------------------------------------------------------- /spec/fixtures/rspec_project/src/example_class.rb: -------------------------------------------------------------------------------- 1 | # typed: ignore 2 | 3 | class ExampleClass 4 | attr_accessor :foo, :bar, :qux 5 | 6 | def initialize(foo, bar, qux) 7 | @foo = foo 8 | @bar = bar 9 | @qux = qux 10 | end 11 | 12 | def baz=(val) 13 | @baz = val 14 | end 15 | 16 | def add(val = 0) 17 | @foo + @bar + @qux + val + (@baz || 0) 18 | end 19 | 20 | def self.whisper(str) 21 | str.downcase.gsub(/o+$/, 'o') 22 | end 23 | 24 | def shout(str) 25 | str.upcase.gsub(/O+$/, 'O' * 16) 26 | end 27 | end 28 | -------------------------------------------------------------------------------- /spec/fixtures/rspec_project/src/example_class_annotated.cr: -------------------------------------------------------------------------------- 1 | class ExampleClass 2 | @foo : Int32 | Nil 3 | @bar : Int32 | Symbol 4 | @baz : Int32 | Nil 5 | 6 | property :foo, :bar 7 | 8 | def initialize(@foo : Int32 | Nil, @bar : Int32 | Symbol) 9 | end 10 | 11 | def baz=(val : Int32) : Int32 12 | @baz = val 13 | end 14 | 15 | def add(val : Int32 = 0) : Int32 16 | foo = @foo 17 | return 0 unless foo.is_a?(Int32) 18 | bar = @bar 19 | return 0 unless bar.is_a?(Int32) 20 | foo + bar + val + (@baz || 0) 21 | end 22 | 23 | def self.whisper(str : String) : String 24 | str.downcase.gsub(/o+$/, "o") 25 | end 26 | 27 | def shout(str : String) : String 28 | str.upcase.gsub(/O+$/, "O" * 16) 29 | end 30 | end 31 | -------------------------------------------------------------------------------- /spec/fixtures/rspec_project/src/example_class_annotated.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | class ExampleClass 4 | extend T::Sig 5 | 6 | attr_accessor :foo, :bar 7 | 8 | sig { params(foo: T.nilable(Integer), bar: T.any(Integer, Symbol), qux: Integer).void } 9 | def initialize(foo, bar, qux) 10 | @foo = foo 11 | @bar = bar 12 | @qux = qux 13 | end 14 | 15 | sig { params(val: Integer).returns(Integer) } 16 | def baz=(val) 17 | @baz = val 18 | end 19 | 20 | sig { params(val: Integer).returns(Integer) } 21 | def add(val = 0) 22 | @foo + @bar + @qux + val + (@baz || 0) 23 | end 24 | 25 | sig { params(str: String).returns(String) } 26 | def self.whisper(str) 27 | str.downcase.gsub(/o+$/, 'o') 28 | end 29 | 30 | sig { params(str: String).returns(String) } 31 | def shout(str) 32 | str.upcase.gsub(/O+$/, 'O' * 16) 33 | end 34 | end 35 | -------------------------------------------------------------------------------- /spec/fixtures/syntax_error: -------------------------------------------------------------------------------- 1 | invalid(ruby_syntax 2 | -------------------------------------------------------------------------------- /spec/fixtures/valid: -------------------------------------------------------------------------------- 1 | def valid_ruby(argument) 2 | argument + 2 3 | end 4 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/command_spec.rb: -------------------------------------------------------------------------------- 1 | require "spec_helper" 2 | require "tempfile" 3 | 4 | RSpec.describe RubyCrystalCodemod::Command do 5 | describe "exit codes" do 6 | matcher :terminate do 7 | actual = nil 8 | 9 | match do |block| 10 | begin 11 | block.call 12 | rescue SystemExit => e 13 | actual = e.status 14 | end 15 | actual and actual == status_code 16 | end 17 | 18 | chain :with_code do |status_code| 19 | @status_code = status_code 20 | end 21 | 22 | failure_message do |block| 23 | "expected block to call exit(#{status_code}) but exit" + 24 | (actual.nil? ? " not called" : "(#{actual}) was called") 25 | end 26 | 27 | failure_message_when_negated do |block| 28 | "expected block not to call exit(#{status_code})" 29 | end 30 | 31 | description do 32 | "exit(#{status_code})" 33 | end 34 | 35 | def status_code 36 | @status_code ||= 0 37 | end 38 | end 39 | 40 | describe "files" do 41 | # NOTE - We disabled the check functionality, since it doesn't make sense for a transpiler / codemod 42 | # describe "check" do 43 | # subject { -> { described_class.run(["-c", file]) } } 44 | 45 | # context "missing file" do 46 | # let(:file) { "missing.rb" } 47 | # it { is_expected.to terminate.with_code(1) } 48 | # end 49 | 50 | # context "unchanged file" do 51 | # let(:file) { "spec/fixtures/valid" } 52 | # it { is_expected.to terminate } 53 | # end 54 | 55 | # context "changed file" do 56 | # let(:file) { "spec/fixtures/needs_changes" } 57 | # it { is_expected.to terminate.with_code 3 } 58 | # end 59 | 60 | # context "invalid file" do 61 | # let(:file) { "spec/fixtures/syntax_error" } 62 | # it { is_expected.to terminate.with_code 1 } 63 | # end 64 | # end 65 | 66 | describe "format" do 67 | subject do 68 | lambda do 69 | tempfile = File.exist?(file) && Tempfile.new("ruby_crystal_codemod-fixture") 70 | 71 | if tempfile 72 | begin 73 | tempfile.write(File.read(file)) 74 | tempfile.rewind 75 | described_class.run([tempfile.path]) 76 | rescue SystemExit 77 | tempfile.close 78 | tempfile.unlink 79 | raise 80 | end 81 | else 82 | described_class.run([file]) 83 | end 84 | end 85 | end 86 | 87 | context "missing file" do 88 | let(:file) { "missing.rb" } 89 | it { is_expected.to terminate.with_code(1) } 90 | end 91 | 92 | # context "unchanged file" do 93 | # let(:file) { "spec/fixtures/valid" } 94 | # it { is_expected.to terminate } 95 | # end 96 | 97 | context "changed file" do 98 | let(:file) { "spec/fixtures/needs_changes" } 99 | it { is_expected.to terminate.with_code 3 } 100 | end 101 | 102 | context "invalid file" do 103 | let(:file) { "spec/fixtures/syntax_error" } 104 | it { is_expected.to terminate.with_code 1 } 105 | end 106 | end 107 | end 108 | 109 | describe "STDIN" do 110 | describe "check" do 111 | subject { -> { described_class.run(["-c"]) } } 112 | before(:example) { expect(STDIN).to receive(:read).and_return code } 113 | 114 | context "no code" do 115 | let(:code) { "" } 116 | it { is_expected.to terminate.with_code 3 } 117 | end 118 | 119 | context "unchanged code" do 120 | let(:code) { "[]\n" } 121 | it { is_expected.to terminate } 122 | end 123 | 124 | context "changed code" do 125 | let(:code) { "[ ]\n" } 126 | it { is_expected.to terminate.with_code 3 } 127 | end 128 | 129 | context "invalid code" do 130 | let(:code) { "not_valid(ruby" } 131 | it { is_expected.to terminate.with_code 1 } 132 | end 133 | end 134 | 135 | describe "format" do 136 | subject { -> { described_class.run([]) } } 137 | before(:example) { expect(STDIN).to receive(:read).and_return code } 138 | 139 | context "no code" do 140 | let(:code) { "" } 141 | it { is_expected.to terminate.with_code 3 } 142 | end 143 | 144 | context "unchanged code" do 145 | let(:code) { "[]\n" } 146 | it { is_expected.to terminate } 147 | end 148 | 149 | context "changed code" do 150 | let(:code) { "[ ]\n" } 151 | it { is_expected.to terminate.with_code 3 } 152 | end 153 | 154 | context "invalid code" do 155 | let(:code) { "not_valid(ruby" } 156 | it { is_expected.to terminate.with_code 1 } 157 | end 158 | end 159 | end 160 | end 161 | end 162 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/dot_file_spec.rb: -------------------------------------------------------------------------------- 1 | require "spec_helper" 2 | 3 | RSpec.describe RubyCrystalCodemod::DotFile do 4 | describe "#parse" do 5 | it "parses booleans" do 6 | expect(subject.parse("key true\nother false")).to eql( 7 | key: true, 8 | other: false, 9 | ) 10 | end 11 | 12 | it "parses symbols" do 13 | expect(subject.parse("key :true")).to eql( 14 | key: :true, 15 | ) 16 | end 17 | 18 | it "warns about config it cannot parse" do 19 | result = nil 20 | expect { 21 | result = subject.parse("key 1") 22 | }.to output(%(Unknown config value="1" for "key"\n)).to_stderr 23 | 24 | expect(result).to eql({}) 25 | end 26 | end 27 | end 28 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/file_finder_spec.rb: -------------------------------------------------------------------------------- 1 | require "spec_helper" 2 | 3 | RSpec.describe RubyCrystalCodemod::FileFinder do 4 | subject { described_class.new([file_or_dir]) } 5 | 6 | context "the directory contains .rb files" do 7 | let(:file_or_dir) { finder_fixture_path("only_ruby") } 8 | 9 | it "returns all the .rb files in a directory" do 10 | expect(relative_paths(subject.to_a)).to eql([[true, "a.rb"]]) 11 | end 12 | end 13 | 14 | context "the directory does not exist" do 15 | let(:file_or_dir) { finder_fixture_path("does_not_exist") } 16 | 17 | it "returns paths with exists flag of false" do 18 | expect(relative_paths(subject.to_a, finder_fixture_path)).to eql([[false, "does_not_exist"]]) 19 | end 20 | end 21 | 22 | context "the argument is a file" do 23 | let(:file_or_dir) { finder_fixture_path("only_ruby", "a.rb") } 24 | 25 | it "returns file provided" do 26 | expect(relative_paths(subject.to_a, finder_fixture_path)).to eql([[true, "only_ruby/a.rb"]]) 27 | end 28 | end 29 | 30 | context "the argument is a file that does not exist" do 31 | let(:file_or_dir) { finder_fixture_path("only_ruby", "does_not_exist.rb") } 32 | 33 | it "returns files with exists flag of false" do 34 | expect(relative_paths(subject.to_a, finder_fixture_path)).to eql([[false, "only_ruby/does_not_exist.rb"]]) 35 | end 36 | end 37 | 38 | context "the directory contains gem related files" do 39 | let(:file_or_dir) { finder_fixture_path("only_gemfiles") } 40 | 41 | it "includes the files" do 42 | expect(relative_paths(subject.to_a)).to match_array([]) 43 | end 44 | end 45 | 46 | context "the directory contains rake files" do 47 | let(:file_or_dir) { finder_fixture_path("only_rake_files") } 48 | 49 | it "includes all the rake files" do 50 | expect(relative_paths(subject.to_a)).to match_array([]) 51 | end 52 | end 53 | 54 | context "the directory contains vendor directory" do 55 | let(:file_or_dir) { finder_fixture_path("only_vendor") } 56 | 57 | it "ignores the vendor directory" do 58 | expect(relative_paths(subject.to_a)).to match_array([]) 59 | end 60 | end 61 | 62 | def relative_paths(paths, base = file_or_dir) 63 | paths.map { |(exists, path)| [exists, path.sub("#{base}/", "")] } 64 | end 65 | 66 | def finder_fixture_path(*components) 67 | File.join(__dir__, "..", "..", "fixtures", "file_finder", *components) 68 | end 69 | end 70 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_crystal_specs/blocks_and_procs.rb.spec: -------------------------------------------------------------------------------- 1 | # See: https://crystal-lang.org/reference/syntax_and_semantics/blocks_and_procs.html 2 | 3 | #~# ORIGINAL block_do 4 | 5 | method do |argument| 6 | argument.some_method 7 | end 8 | 9 | #~# EXPECTED 10 | 11 | method do |argument| 12 | argument.some_method 13 | end 14 | 15 | #~# ORIGINAL block_curly 16 | 17 | method { |argument| argument.some_method } 18 | 19 | #~# EXPECTED 20 | 21 | method { |argument| argument.some_method } 22 | 23 | #~# ORIGINAL block_space_ampersand 24 | 25 | method &:some_method 26 | 27 | #~# EXPECTED 28 | 29 | method &.some_method 30 | 31 | #~# ORIGINAL block_paren_ampersand 32 | 33 | method(&:some_method) 34 | 35 | #~# EXPECTED 36 | 37 | method(&.some_method) 38 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_crystal_specs/operators.rb.spec: -------------------------------------------------------------------------------- 1 | # See: https://crystal-lang.org/reference/syntax_and_semantics/operators.html 2 | 3 | #~# ORIGINAL unary 4 | 5 | puts "not false" if !false 6 | 7 | #~# EXPECTED 8 | 9 | puts "not false" if !false 10 | 11 | #~# ORIGINAL unary 12 | 13 | puts "not false" if not false 14 | 15 | #~# EXPECTED 16 | 17 | puts "not false" if !false 18 | 19 | #~# ORIGINAL unary 20 | 21 | puts "not !true" if not !true 22 | 23 | #~# EXPECTED 24 | 25 | puts "not !true" if !!true 26 | 27 | #~# ORIGINAL unary 28 | 29 | puts "is !!true" if !!true 30 | 31 | #~# EXPECTED 32 | 33 | puts "is !!true" if !!true 34 | 35 | #~# ORIGINAL operator_and 36 | 37 | true && puts("yeah") 38 | 39 | #~# EXPECTED 40 | 41 | true && puts("yeah") 42 | 43 | #~# ORIGINAL operator_or 44 | 45 | false || puts("yeah") 46 | 47 | #~# EXPECTED 48 | 49 | false || puts("yeah") 50 | 51 | #~# ORIGINAL operator_and 52 | 53 | true and puts("yeah") 54 | 55 | #~# EXPECTED 56 | 57 | true && puts("yeah") 58 | 59 | #~# ORIGINAL operator_or 60 | 61 | false or puts("yeah") 62 | 63 | #~# EXPECTED 64 | 65 | false || puts("yeah") 66 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_crystal_specs/properties.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL properties_attr_accessor 2 | 3 | class Foo 4 | attr_accessor :foo 5 | end 6 | 7 | #~# EXPECTED 8 | 9 | class Foo 10 | property :foo 11 | end 12 | 13 | #~# ORIGINAL properties_attr_accessor 14 | 15 | class Foo 16 | attr_accessor :foo, :bar 17 | end 18 | 19 | #~# EXPECTED 20 | 21 | class Foo 22 | property :foo, :bar 23 | end 24 | 25 | #~# ORIGINAL properties_attr_reader 26 | 27 | class Foo 28 | attr_reader :foo 29 | end 30 | 31 | #~# EXPECTED 32 | 33 | class Foo 34 | getter :foo 35 | end 36 | 37 | #~# ORIGINAL properties_attr_reader 38 | 39 | class Foo 40 | attr_reader :foo, :bar 41 | end 42 | 43 | #~# EXPECTED 44 | 45 | class Foo 46 | getter :foo, :bar 47 | end 48 | 49 | #~# ORIGINAL properties_attr_writer 50 | 51 | class Foo 52 | attr_writer :foo 53 | end 54 | 55 | #~# EXPECTED 56 | 57 | class Foo 58 | setter :foo 59 | end 60 | 61 | #~# ORIGINAL properties_attr_writer 62 | 63 | class Foo 64 | attr_writer :foo, :bar 65 | end 66 | 67 | #~# EXPECTED 68 | 69 | class Foo 70 | setter :foo, :bar 71 | end 72 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_crystal_specs/pseudo_constants.rb.spec: -------------------------------------------------------------------------------- 1 | # See: https://github.com/crystal-lang/crystal/wiki/Crystal-for-Rubyists#pseudo-constants 2 | 3 | #~# ORIGINAL __dir__ 4 | 5 | puts __dir__ 6 | 7 | #~# EXPECTED 8 | 9 | puts __DIR__ 10 | 11 | #~# ORIGINAL __FILE__ 12 | 13 | puts __FILE__ 14 | 15 | #~# EXPECTED 16 | 17 | puts __FILE__ 18 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_crystal_specs/require_dynamic.rb.spec: -------------------------------------------------------------------------------- 1 | # See: https://crystal-lang.org/reference/syntax_and_semantics/requiring_files.html 2 | 3 | #~# ORIGINAL require_dynamic_expand_path_file 4 | 5 | require File.expand_path('../formatter_spec', File.dirname(__FILE__)) 6 | 7 | #~# EXPECTED 8 | 9 | require "spec/lib/ruby_crystal_codemod/formatter_spec" 10 | 11 | #~# ORIGINAL require_dynamic_expand_path_dir 12 | 13 | require File.expand_path('../formatter_spec', __dir__) 14 | 15 | #~# EXPECTED 16 | 17 | require "spec/lib/ruby_crystal_codemod/formatter_spec" 18 | 19 | #~# ORIGINAL require_dynamic_join_dir 20 | 21 | require File.join(__dir__, '../formatter_spec') 22 | 23 | #~# EXPECTED 24 | 25 | require "spec/lib/ruby_crystal_codemod/formatter_spec" 26 | 27 | 28 | #~# ORIGINAL require_dynamic_space_plus_parens 29 | 30 | require File.expand_path( 31 | '../formatter_spec', 32 | File.dirname( 33 | __FILE__ 34 | ) 35 | ) 36 | 37 | #~# EXPECTED 38 | 39 | require "spec/lib/ruby_crystal_codemod/formatter_spec" 40 | 41 | #~# ORIGINAL require_dynamic 42 | 43 | require( 44 | File.expand_path( 45 | '../formatter_spec', 46 | File.dirname( 47 | __FILE__ 48 | ) 49 | ) 50 | ) 51 | 52 | #~# EXPECTED 53 | 54 | require "spec/lib/ruby_crystal_codemod/formatter_spec" 55 | 56 | #~# ORIGINAL require_dynamic 57 | 58 | require(File.expand_path( 59 | '../formatter_spec', 60 | File.dirname( 61 | __FILE__ 62 | ) 63 | )) 64 | 65 | #~# EXPECTED 66 | 67 | require "spec/lib/ruby_crystal_codemod/formatter_spec" 68 | 69 | 70 | #~# ORIGINAL require_dynamic 71 | 72 | require f 73 | 74 | #~# EXPECTED 75 | 76 | require f 77 | 78 | #~# ERRORS 79 | 80 | "WARNING: require statements can only use strings in Crystal." 81 | 82 | #~# ORIGINAL require_dynamic 83 | 84 | require File.expand_path("../doesntexist", File.dirname(__FILE__)) 85 | 86 | #~# EXPECTED 87 | 88 | require File.expand_path("../doesntexist", File.dirname(__FILE__)) 89 | 90 | #~# ERRORS 91 | 92 | "WARNING: require statements can only use strings in Crystal" 93 | /ERROR: Could not find .*spec\/lib\/ruby_crystal_codemod\/doesntexist.rb!/ 94 | "Please fix this require statement manually." 95 | 96 | #~# ORIGINAL require_dynamic_dir_glob 97 | 98 | require Dir.glob(File.join(__dir__, '../*.rb')) 99 | 100 | #~# EXPECTED 101 | 102 | require Dir.glob(File.join(__DIR__, "../*.rb")) 103 | 104 | #~# ERRORS 105 | 106 | "Evaluated path was not a string! Please fix this require statement manually." 107 | 108 | #~# ORIGINAL require_dynamic_dir_glob_block 109 | 110 | Dir.glob(File.join(__dir__, '../*.rb')).each do |f| 111 | require f 112 | end 113 | 114 | #~# EXPECTED 115 | 116 | Dir.glob(File.join(__DIR__, "../*.rb")).each do |f| 117 | require f 118 | end 119 | 120 | #~# ERRORS 121 | 122 | "WARNING: require statements can only use strings in Crystal." 123 | "require args do not start with 'File.', so not attempting to evaluate the code." 124 | 125 | 126 | #~# ORIGINAL require_dynamic_interpolation 127 | 128 | asdf = "doesntexist" 129 | require "#{asdf}" 130 | 131 | #~# EXPECTED 132 | 133 | asdf = "doesntexist" 134 | require "#{asdf}" 135 | 136 | #~# ERRORS 137 | 138 | "String interpolation is not supported for Crystal require statements!" 139 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_crystal_specs/unshift_loadpath.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL load_path 2 | 3 | $LOAD_PATH.unshift __dir__ 4 | 5 | #~# EXPECTED 6 | 7 | #~# ERRORS 8 | 9 | "ERROR: Can't use $LOAD_PATH in a Crystal program!" 10 | "You might be able to replace this with CRYSTAL_PATH if needed." 11 | 12 | #~# ORIGINAL load_path_short 13 | 14 | $:.unshift __dir__ 15 | 16 | #~# EXPECTED 17 | 18 | #~# ERRORS 19 | 20 | "ERROR: Can't use $: in a Crystal program!" 21 | "You might be able to replace this with CRYSTAL_PATH if needed." 22 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/2.6/range.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | 0.. 4 | 5 | #~# EXPECTED 6 | 7 | 0.. 8 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/BEGIN.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | BEGIN { 4 | 1 5 | 2 6 | } 7 | 8 | #~# EXPECTED 9 | 10 | BEGIN { 11 | 1 12 | 2 13 | } 14 | 15 | #~# ORIGINAL 16 | 17 | BEGIN { 1 ; 2 } 18 | 19 | #~# EXPECTED 20 | 21 | BEGIN { 1; 2 } 22 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/END.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | END { 4 | 1 5 | 2 6 | } 7 | 8 | #~# EXPECTED 9 | 10 | END { 11 | 1 12 | 2 13 | } 14 | 15 | #~# ORIGINAL 16 | 17 | END { 1 ; 2 } 18 | 19 | #~# EXPECTED 20 | 21 | END { 1; 2 } 22 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/__END__.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | 1 4 | 5 | __END__ 6 | this 7 | is 8 | still 9 | here 10 | 11 | #~# EXPECTED 12 | 13 | 1 14 | 15 | __END__ 16 | this 17 | is 18 | still 19 | here 20 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/alias.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | alias foo bar 4 | 5 | #~# EXPECTED 6 | 7 | alias foo bar 8 | 9 | #~# ORIGINAL 10 | 11 | alias :foo :bar 12 | 13 | #~# EXPECTED 14 | 15 | alias :foo :bar 16 | 17 | #~# ORIGINAL 18 | 19 | alias store []= 20 | 21 | #~# EXPECTED 22 | 23 | alias store []= 24 | 25 | #~# ORIGINAL 26 | 27 | alias $foo $bar 28 | 29 | #~# EXPECTED 30 | 31 | alias $foo $bar 32 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/align_assignments.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | x = 1 4 | xyz = 2 5 | 6 | w = 3 7 | 8 | #~# EXPECTED 9 | 10 | x = 1 11 | xyz = 2 12 | 13 | w = 3 14 | 15 | #~# ORIGINAL 16 | 17 | x = 1 18 | foo[bar] = 2 19 | 20 | w = 3 21 | 22 | #~# EXPECTED 23 | 24 | x = 1 25 | foo[bar] = 2 26 | 27 | w = 3 28 | 29 | #~# ORIGINAL 30 | 31 | x = 1; x = 2 32 | xyz = 2 33 | 34 | w = 3 35 | 36 | #~# EXPECTED 37 | 38 | x = 1; x = 2 39 | xyz = 2 40 | 41 | w = 3 42 | 43 | #~# ORIGINAL 44 | 45 | a = begin 46 | b = 1 47 | abc = 2 48 | end 49 | 50 | #~# EXPECTED 51 | 52 | a = begin 53 | b = 1 54 | abc = 2 55 | end 56 | 57 | #~# ORIGINAL 58 | 59 | a = 1 60 | a += 2 61 | 62 | #~# EXPECTED 63 | 64 | a = 1 65 | a += 2 66 | 67 | #~# ORIGINAL 68 | 69 | foo = 1 70 | a += 2 71 | 72 | #~# EXPECTED 73 | 74 | foo = 1 75 | a += 2 76 | 77 | #~# ORIGINAL 78 | 79 | x = 1 80 | xyz = 2 81 | 82 | w = 3 83 | 84 | #~# EXPECTED 85 | 86 | x = 1 87 | xyz = 2 88 | 89 | w = 3 90 | 91 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/align_case_when.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | #~# align_case_when: true 3 | 4 | case 5 | when 1 then 2 6 | when 234 then 5 7 | else 6 8 | end 9 | 10 | #~# EXPECTED 11 | 12 | case 13 | when 1 then 2 14 | when 234 then 5 15 | else 6 16 | end 17 | 18 | #~# ORIGINAL 19 | #~# align_case_when: true 20 | 21 | case 22 | when 1; 2 23 | when 234; 5 24 | end 25 | 26 | #~# EXPECTED 27 | 28 | case 29 | when 1; 2 30 | when 234; 5 31 | end 32 | 33 | #~# ORIGINAL 34 | #~# align_case_when: true 35 | 36 | case 37 | when 1; 2 38 | when 234; 5 39 | else 6 40 | end 41 | 42 | #~# EXPECTED 43 | 44 | case 45 | when 1; 2 46 | when 234; 5 47 | else 6 48 | end 49 | 50 | #~# ORIGINAL 51 | #~# align_case_when: false 52 | 53 | case 54 | when 1 then 2 55 | when 234 then 5 56 | else 6 57 | end 58 | 59 | #~# EXPECTED 60 | 61 | case 62 | when 1 then 2 63 | when 234 then 5 64 | else 6 65 | end 66 | 67 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/align_chained_calls.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | #~# align_chained_calls: true 3 | 4 | foo . bar 5 | . baz 6 | 7 | #~# EXPECTED 8 | 9 | foo.bar 10 | .baz 11 | 12 | #~# ORIGINAL 13 | #~# align_chained_calls: true 14 | 15 | foo . bar 16 | . baz 17 | . qux 18 | 19 | #~# EXPECTED 20 | 21 | foo.bar 22 | .baz 23 | .qux 24 | 25 | #~# ORIGINAL 26 | #~# align_chained_calls: true 27 | 28 | foo . bar( x.y ) 29 | . baz 30 | . qux 31 | 32 | #~# EXPECTED 33 | 34 | foo.bar(x.y) 35 | .baz 36 | .qux 37 | 38 | #~# ORIGINAL 39 | 40 | x.foo 41 | .bar { a.b } 42 | .baz 43 | 44 | #~# EXPECTED 45 | 46 | x.foo 47 | .bar { a.b } 48 | .baz 49 | 50 | #~# ORIGINAL 51 | 52 | a do # 53 | b 54 | .w y(x) 55 | .z 56 | end 57 | 58 | #~# EXPECTED 59 | 60 | a do # 61 | b.w y(x) 62 | .z 63 | end 64 | 65 | #~# ORIGINAL 66 | 67 | a do # 68 | b # 69 | .w y(x) 70 | .z 71 | end 72 | 73 | #~# EXPECTED 74 | 75 | a do # 76 | b # 77 | .w y(x) 78 | .z 79 | end 80 | 81 | #~# ORIGINAL 82 | 83 | a do # 84 | b # 85 | .w y(x) # 86 | .z 87 | end 88 | 89 | #~# EXPECTED 90 | 91 | a do # 92 | b # 93 | .w y(x) # 94 | .z 95 | end 96 | 97 | #~# ORIGINAL 98 | 99 | a do 100 | b # 101 | .w x 102 | end 103 | 104 | #~# EXPECTED 105 | 106 | a do 107 | b # 108 | .w x 109 | end 110 | 111 | #~# ORIGINAL 112 | 113 | a 114 | .b 115 | .c 116 | .d 117 | 118 | #~# EXPECTED 119 | 120 | a 121 | .b 122 | .c 123 | .d 124 | 125 | #~# ORIGINAL 126 | 127 | a do 128 | b # 129 | .w x 130 | .z 131 | end 132 | 133 | #~# EXPECTED 134 | 135 | a do 136 | b # 137 | .w x 138 | .z 139 | end 140 | 141 | #~# ORIGINAL 142 | 143 | a { 144 | b # 145 | .w x 146 | .z 147 | } 148 | 149 | #~# EXPECTED 150 | 151 | a { 152 | b # 153 | .w x 154 | .z 155 | } 156 | 157 | #~# ORIGINAL 158 | 159 | a { 160 | b x # 161 | .w 162 | .z 163 | } 164 | 165 | #~# EXPECTED 166 | 167 | a { 168 | b x # 169 | .w 170 | .z 171 | } 172 | 173 | #~# ORIGINAL 174 | 175 | a do 176 | b # 177 | .w 178 | end 179 | 180 | #~# EXPECTED 181 | 182 | a do 183 | b # 184 | .w 185 | end 186 | 187 | #~# ORIGINAL 188 | 189 | b # 190 | .w 191 | 192 | #~# EXPECTED 193 | 194 | b # 195 | .w 196 | 197 | #~# ORIGINAL 198 | 199 | a do 200 | b # 201 | .w 202 | end 203 | 204 | #~# EXPECTED 205 | 206 | a do 207 | b # 208 | .w 209 | end 210 | 211 | #~# ORIGINAL 212 | 213 | a do 214 | b# 215 | .w x 216 | end 217 | 218 | #~# EXPECTED 219 | 220 | a do 221 | b # 222 | .w x 223 | end 224 | 225 | #~# ORIGINAL 226 | 227 | a b do 228 | c d do 229 | e # 230 | .f g 231 | .h 232 | .i 233 | end 234 | end 235 | 236 | #~# EXPECTED 237 | 238 | a b do 239 | c d do 240 | e # 241 | .f g 242 | .h 243 | .i 244 | end 245 | end 246 | 247 | #~# ORIGINAL 248 | 249 | context "b123" do 250 | it "d123" do 251 | expect_any_instance_of(Uploader::Null) # some comment 252 | .f123 g123(h123) 253 | .h123 254 | .i123 255 | end 256 | end 257 | 258 | #~# EXPECTED 259 | 260 | context "b123" do 261 | it "d123" do 262 | expect_any_instance_of(Uploader::Null) # some comment 263 | .f123 g123(h123) 264 | .h123 265 | .i123 266 | end 267 | end 268 | 269 | #~# ORIGINAL bug_49 270 | 271 | context "no sidecar/archive" do 272 | it "uploads destination master to the specified destination" do 273 | expect_any_instance_of(Uploader::Null) # rubocop:disable RSpec/AnyInstance 274 | .to receive(:upload) 275 | .with([file_path, "HON_TEST001_010.mxf"]) 276 | .and_return(Uploader::Result.new(success: true)) 277 | end 278 | end 279 | 280 | #~# EXPECTED 281 | 282 | context "no sidecar/archive" do 283 | it "uploads destination master to the specified destination" do 284 | expect_any_instance_of(Uploader::Null) # rubocop:disable RSpec/AnyInstance 285 | .to receive(:upload) 286 | .with([file_path, "HON_TEST001_010.mxf"]) 287 | .and_return(Uploader::Result.new(success: true)) 288 | end 289 | end 290 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/align_comments.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | 1 # one 4 | 123 # two 5 | 6 | #~# EXPECTED 7 | 8 | 1 # one 9 | 123 # two 10 | 11 | #~# ORIGINAL 12 | 13 | 1 # one 14 | 123 # two 15 | 4 16 | 5 # lala 17 | 18 | #~# EXPECTED 19 | 20 | 1 # one 21 | 123 # two 22 | 4 23 | 5 # lala 24 | 25 | #~# ORIGINAL 26 | 27 | foobar( # one 28 | 1 # two 29 | ) 30 | 31 | #~# EXPECTED 32 | 33 | foobar( # one 34 | 1 # two 35 | ) 36 | 37 | #~# ORIGINAL 38 | 39 | a = 1 # foo 40 | abc = 2 # bar 41 | 42 | #~# EXPECTED 43 | 44 | a = 1 # foo 45 | abc = 2 # bar 46 | 47 | #~# ORIGINAL 48 | 49 | a = 1 # foo 50 | # bar 51 | 52 | #~# EXPECTED 53 | 54 | a = 1 # foo 55 | # bar 56 | 57 | #~# ORIGINAL 58 | 59 | # foo 60 | a # bar 61 | 62 | #~# EXPECTED 63 | 64 | # foo 65 | a # bar 66 | 67 | #~# ORIGINAL 68 | 69 | # foo 70 | a # bar 71 | 72 | #~# EXPECTED 73 | 74 | # foo 75 | a # bar 76 | 77 | #~# ORIGINAL 78 | 79 | require x 80 | 81 | # Comment 1 82 | # Comment 2 83 | FOO = :bar # Comment 3 84 | 85 | #~# EXPECTED 86 | 87 | require x 88 | 89 | # Comment 1 90 | # Comment 2 91 | FOO = :bar # Comment 3 92 | 93 | #~# ORIGINAL 94 | 95 | begin 96 | require x 97 | 98 | # Comment 1 99 | # Comment 2 100 | FOO = :bar # Comment 3 101 | end 102 | 103 | #~# EXPECTED 104 | 105 | begin 106 | require x 107 | 108 | # Comment 1 109 | # Comment 2 110 | FOO = :bar # Comment 3 111 | end 112 | 113 | #~# ORIGINAL 114 | 115 | begin 116 | a # c1 117 | # c2 118 | b = 1 # c3 119 | end 120 | 121 | #~# EXPECTED 122 | 123 | begin 124 | a # c1 125 | # c2 126 | b = 1 # c3 127 | end 128 | 129 | #~# ORIGINAL 130 | 131 | 1 # one 132 | 123 # two 133 | 134 | #~# EXPECTED 135 | 136 | 1 # one 137 | 123 # two 138 | 139 | #~# ORIGINAL 140 | 141 | foo bar( # foo 142 | 1, # bar 143 | ) 144 | 145 | #~# EXPECTED 146 | 147 | foo bar( # foo 148 | 1, # bar 149 | ) 150 | 151 | #~# ORIGINAL 152 | 153 | a = 1 # foo 154 | bar = 2 # baz 155 | 156 | #~# EXPECTED 157 | 158 | a = 1 # foo 159 | bar = 2 # baz 160 | 161 | #~# ORIGINAL 162 | 163 | [ 164 | 1, # foo 165 | 234, # bar 166 | ] 167 | 168 | #~# EXPECTED 169 | 170 | [ 171 | 1, # foo 172 | 234, # bar 173 | ] 174 | 175 | #~# ORIGINAL 176 | 177 | [ 178 | 1, # foo 179 | 234 # bar 180 | ] 181 | 182 | #~# EXPECTED 183 | 184 | [ 185 | 1, # foo 186 | 234, # bar 187 | ] 188 | 189 | #~# ORIGINAL 190 | 191 | foo bar: 1, # comment 192 | baz: 2 # comment 193 | 194 | #~# EXPECTED 195 | 196 | foo bar: 1, # comment 197 | baz: 2 # comment 198 | 199 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/align_hash_keys.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | { 4 | 1 => 2, 5 | 123 => 4 } 6 | 7 | #~# EXPECTED 8 | 9 | { 10 | 1 => 2, 11 | 123 => 4, 12 | } 13 | 14 | #~# ORIGINAL 15 | 16 | { 17 | foo: 1, 18 | barbaz: 2 } 19 | 20 | #~# EXPECTED 21 | 22 | { 23 | foo: 1, 24 | barbaz: 2, 25 | } 26 | 27 | #~# ORIGINAL 28 | 29 | foo bar: 1, 30 | barbaz: 2 31 | 32 | #~# EXPECTED 33 | 34 | foo bar: 1, 35 | barbaz: 2 36 | 37 | #~# ORIGINAL 38 | 39 | foo( 40 | bar: 1, 41 | barbaz: 2) 42 | 43 | #~# EXPECTED 44 | 45 | foo( 46 | bar: 1, 47 | barbaz: 2, 48 | ) 49 | 50 | #~# ORIGINAL 51 | 52 | def foo(x, 53 | y: 1, 54 | bar: 2) 55 | end 56 | 57 | #~# EXPECTED 58 | 59 | def foo(x, 60 | y: 1, 61 | bar: 2) 62 | end 63 | 64 | #~# ORIGINAL 65 | 66 | {1 => 2} 67 | {123 => 4} 68 | 69 | #~# EXPECTED 70 | 71 | { 1 => 2 } 72 | { 123 => 4 } 73 | 74 | #~# ORIGINAL 75 | 76 | { 77 | 1 => 2, 78 | 345 => { 79 | 4 => 5 80 | } 81 | } 82 | 83 | #~# EXPECTED 84 | 85 | { 86 | 1 => 2, 87 | 345 => { 88 | 4 => 5, 89 | }, 90 | } 91 | 92 | #~# ORIGINAL 93 | 94 | { 95 | 1 => 2, 96 | 345 => { # foo 97 | 4 => 5 98 | } 99 | } 100 | 101 | #~# EXPECTED 102 | 103 | { 104 | 1 => 2, 105 | 345 => { # foo 106 | 4 => 5, 107 | }, 108 | } 109 | 110 | #~# ORIGINAL 111 | 112 | { 113 | 1 => 2, 114 | 345 => [ 115 | 4 116 | ] 117 | } 118 | 119 | #~# EXPECTED 120 | 121 | { 122 | 1 => 2, 123 | 345 => [ 124 | 4, 125 | ], 126 | } 127 | 128 | #~# ORIGINAL 129 | 130 | { 131 | 1 => 2, 132 | foo: [ 133 | 4 134 | ] 135 | } 136 | 137 | #~# EXPECTED 138 | 139 | { 140 | 1 => 2, 141 | foo: [ 142 | 4, 143 | ], 144 | } 145 | 146 | #~# ORIGINAL 147 | 148 | foo 1, bar: [ 149 | 2, 150 | ], 151 | baz: 3 152 | 153 | #~# EXPECTED 154 | 155 | foo 1, bar: [ 156 | 2, 157 | ], 158 | baz: 3 159 | 160 | #~# ORIGINAL 161 | 162 | a = b :foo => x, 163 | :baar => x 164 | 165 | #~# EXPECTED 166 | 167 | a = b :foo => x, 168 | :baar => x 169 | 170 | #~# ORIGINAL 171 | 172 | {:foo => 1 } 173 | 174 | #~# EXPECTED 175 | 176 | { :foo => 1 } 177 | 178 | #~# ORIGINAL 179 | 180 | {:foo => 1} 181 | 182 | #~# EXPECTED 183 | 184 | { :foo => 1 } 185 | 186 | #~# ORIGINAL 187 | 188 | { :foo => 1 } 189 | 190 | #~# EXPECTED 191 | 192 | { :foo => 1 } 193 | 194 | #~# ORIGINAL 195 | 196 | { :foo => 1 , 2 => 3 } 197 | 198 | #~# EXPECTED 199 | 200 | { :foo => 1, 2 => 3 } 201 | 202 | #~# ORIGINAL 203 | 204 | { 205 | :foo => 1 , 206 | 2 => 3 } 207 | 208 | #~# EXPECTED 209 | 210 | { 211 | :foo => 1, 212 | 2 => 3, 213 | } 214 | 215 | #~# ORIGINAL 216 | 217 | { foo: 1, 218 | bar: 2 } 219 | 220 | #~# EXPECTED 221 | 222 | { foo: 1, 223 | bar: 2 } 224 | 225 | #~# ORIGINAL 226 | 227 | =begin 228 | =end 229 | { 230 | :a => 1, 231 | :bc => 2 232 | } 233 | 234 | #~# EXPECTED 235 | 236 | =begin 237 | =end 238 | { 239 | :a => 1, 240 | :bc => 2, 241 | } 242 | 243 | #~# ORIGINAL 244 | 245 | foo 1, :bar => 2 , :baz => 3 246 | 247 | #~# EXPECTED 248 | 249 | foo 1, :bar => 2, :baz => 3 250 | 251 | #~# ORIGINAL 252 | 253 | { 254 | foo: 1, 255 | barbaz: 2 } 256 | 257 | #~# EXPECTED 258 | 259 | { 260 | foo: 1, 261 | barbaz: 2, 262 | } 263 | 264 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/align_mix.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | abc = 1 4 | a = {foo: 1, # comment 5 | bar: 2} # another 6 | 7 | #~# EXPECTED 8 | 9 | abc = 1 10 | a = { foo: 1, # comment 11 | bar: 2 } # another 12 | 13 | #~# ORIGINAL 14 | 15 | abc = 1 16 | a = {foobar: 1, # comment 17 | bar: 2} # another 18 | 19 | #~# EXPECTED 20 | 21 | abc = 1 22 | a = { foobar: 1, # comment 23 | bar: 2 } # another 24 | 25 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/and_or_not.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | foo and bar 4 | 5 | #~# EXPECTED 6 | 7 | foo && bar 8 | 9 | #~# ORIGINAL 10 | 11 | foo or bar 12 | 13 | #~# EXPECTED 14 | 15 | foo || bar 16 | 17 | #~# ORIGINAL 18 | 19 | not foo 20 | 21 | #~# EXPECTED 22 | 23 | !foo 24 | 25 | #~# ORIGINAL 26 | 27 | !x 28 | 29 | #~# EXPECTED 30 | 31 | !x 32 | 33 | 34 | #~# ORIGINAL not_paren_x 35 | 36 | not(x) 37 | 38 | #~# EXPECTED 39 | 40 | !(x) 41 | 42 | #~# ORIGINAL not_space_paren_x 43 | 44 | not (x) 45 | 46 | #~# EXPECTED 47 | 48 | !(x) 49 | 50 | #~# ORIGINAL not_space_x 51 | 52 | not x 53 | 54 | #~# EXPECTED 55 | 56 | !x 57 | 58 | #~# ORIGINAL 59 | 60 | not((a, b = 1, 2)) 61 | 62 | #~# EXPECTED 63 | 64 | !((a, b = 1, 2)) 65 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/array_access.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | foo[ ] 4 | 5 | #~# EXPECTED 6 | 7 | foo[] 8 | 9 | #~# ORIGINAL 10 | 11 | foo[ 12 | ] 13 | 14 | #~# EXPECTED 15 | 16 | foo[] 17 | 18 | #~# ORIGINAL 19 | 20 | foo[ 1 ] 21 | 22 | #~# EXPECTED 23 | 24 | foo[1] 25 | 26 | #~# ORIGINAL 27 | 28 | foo[ 1 , 2 , 3 ] 29 | 30 | #~# EXPECTED 31 | 32 | foo[1, 2, 3] 33 | 34 | #~# ORIGINAL 35 | 36 | foo[ 1 , 37 | 2 , 38 | 3 ] 39 | 40 | #~# EXPECTED 41 | 42 | foo[1, 43 | 2, 44 | 3] 45 | 46 | #~# ORIGINAL 47 | 48 | foo[ 49 | 1 , 50 | 2 , 51 | 3 ] 52 | 53 | #~# EXPECTED 54 | 55 | foo[ 56 | 1, 57 | 2, 58 | 3] 59 | 60 | #~# ORIGINAL 61 | 62 | foo[ *x ] 63 | 64 | #~# EXPECTED 65 | 66 | foo[*x] 67 | 68 | #~# ORIGINAL 69 | 70 | foo[ 71 | 1, 72 | ] 73 | 74 | #~# EXPECTED 75 | 76 | foo[ 77 | 1, 78 | ] 79 | 80 | #~# ORIGINAL 81 | 82 | foo[ 83 | 1, 84 | 2 , 3, 85 | 4, 86 | ] 87 | 88 | #~# EXPECTED 89 | 90 | foo[ 91 | 1, 92 | 2, 3, 93 | 4, 94 | ] 95 | 96 | #~# ORIGINAL 97 | 98 | x[a] [b] 99 | 100 | #~# EXPECTED 101 | 102 | x[a][b] 103 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/array_literal.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | [ ] 4 | 5 | #~# EXPECTED 6 | 7 | [] 8 | 9 | #~# ORIGINAL 10 | 11 | [ 1 ] 12 | 13 | #~# EXPECTED 14 | 15 | [1] 16 | 17 | #~# ORIGINAL 18 | 19 | [ 1 , 2 ] 20 | 21 | #~# EXPECTED 22 | 23 | [1, 2] 24 | 25 | #~# ORIGINAL 26 | 27 | [ 1 , 2 , ] 28 | 29 | #~# EXPECTED 30 | 31 | [1, 2] 32 | 33 | #~# ORIGINAL 34 | 35 | [ 36 | 1 , 2 ] 37 | 38 | #~# EXPECTED 39 | 40 | [ 41 | 1, 2, 42 | ] 43 | 44 | #~# ORIGINAL 45 | 46 | [ 47 | 1 , 2, ] 48 | 49 | #~# EXPECTED 50 | 51 | [ 52 | 1, 2, 53 | ] 54 | 55 | #~# ORIGINAL 56 | 57 | [ 58 | 1 , 2 , 59 | 3 , 4 ] 60 | 61 | #~# EXPECTED 62 | 63 | [ 64 | 1, 2, 65 | 3, 4, 66 | ] 67 | 68 | #~# ORIGINAL 69 | 70 | [ 71 | 1 , 72 | 2] 73 | 74 | #~# EXPECTED 75 | 76 | [ 77 | 1, 78 | 2, 79 | ] 80 | 81 | #~# ORIGINAL 82 | 83 | [ # comment 84 | 1 , 85 | 2] 86 | 87 | #~# EXPECTED 88 | 89 | [ # comment 90 | 1, 91 | 2, 92 | ] 93 | 94 | #~# ORIGINAL 95 | 96 | [ 97 | 1 , # comment 98 | 2] 99 | 100 | #~# EXPECTED 101 | 102 | [ 103 | 1, # comment 104 | 2, 105 | ] 106 | 107 | #~# ORIGINAL 108 | 109 | [ 1 , 110 | 2, 3, 111 | 4 ] 112 | 113 | #~# EXPECTED 114 | 115 | [1, 116 | 2, 3, 117 | 4] 118 | 119 | #~# ORIGINAL 120 | 121 | [ 1 , 122 | 2, 3, 123 | 4, ] 124 | 125 | #~# EXPECTED 126 | 127 | [1, 128 | 2, 3, 129 | 4] 130 | 131 | #~# ORIGINAL 132 | 133 | [ 1 , 134 | 2, 3, 135 | 4, 136 | ] 137 | 138 | #~# EXPECTED 139 | 140 | [1, 141 | 2, 3, 142 | 4] 143 | 144 | #~# ORIGINAL 145 | 146 | [ 1 , 147 | 2, 3, 148 | 4, # foo 149 | ] 150 | 151 | #~# EXPECTED 152 | 153 | [1, 154 | 2, 3, 155 | 4 # foo 156 | ] 157 | 158 | #~# ORIGINAL 159 | 160 | begin 161 | [ 162 | 1 , 2 ] 163 | end 164 | 165 | #~# EXPECTED 166 | 167 | begin 168 | [ 169 | 1, 2, 170 | ] 171 | end 172 | 173 | #~# ORIGINAL 174 | 175 | [ 176 | 1 # foo 177 | ] 178 | 179 | #~# EXPECTED 180 | 181 | [ 182 | 1, # foo 183 | ] 184 | 185 | #~# ORIGINAL 186 | 187 | [ *x ] 188 | 189 | #~# EXPECTED 190 | 191 | [*x] 192 | 193 | #~# ORIGINAL 194 | 195 | [ *x , 1 ] 196 | 197 | #~# EXPECTED 198 | 199 | [*x, 1] 200 | 201 | #~# ORIGINAL 202 | 203 | [ 1, *x ] 204 | 205 | #~# EXPECTED 206 | 207 | [1, *x] 208 | 209 | #~# ORIGINAL 210 | 211 | x = [{ 212 | foo: 1 213 | }] 214 | 215 | #~# EXPECTED 216 | 217 | x = [{ 218 | foo: 1, 219 | }] 220 | 221 | #~# ORIGINAL 222 | 223 | [1, 2] 224 | 225 | #~# EXPECTED 226 | 227 | [1, 2] 228 | 229 | #~# ORIGINAL 230 | 231 | [ 232 | 1, 233 | # comment 234 | 2, 235 | ] 236 | 237 | #~# EXPECTED 238 | 239 | [ 240 | 1, 241 | # comment 242 | 2, 243 | ] 244 | 245 | #~# ORIGINAL 246 | 247 | [ 248 | *a, 249 | b, 250 | ] 251 | 252 | #~# EXPECTED 253 | 254 | [ 255 | *a, 256 | b, 257 | ] 258 | 259 | #~# ORIGINAL 260 | 261 | [ 262 | 1, *a, 263 | b, 264 | ] 265 | 266 | #~# EXPECTED 267 | 268 | [ 269 | 1, *a, 270 | b, 271 | ] 272 | 273 | #~# ORIGINAL 274 | 275 | [*a, *b] 276 | 277 | #~# EXPECTED 278 | 279 | [*a, *b] 280 | 281 | #~# ORIGINAL 282 | 283 | [ 284 | *a, 285 | *b, 286 | ] 287 | 288 | #~# EXPECTED 289 | 290 | [ 291 | *a, 292 | *b, 293 | ] 294 | 295 | #~# ORIGINAL 296 | 297 | [*[a], *[b]] 298 | 299 | #~# EXPECTED 300 | 301 | [*[a], *[b]] 302 | 303 | #~# ORIGINAL 304 | 305 | [ 306 | *[a], 307 | *[b], 308 | ] 309 | 310 | #~# EXPECTED 311 | 312 | [ 313 | *[a], 314 | *[b], 315 | ] 316 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/array_setter.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | foo[ ] = 1 4 | 5 | #~# EXPECTED 6 | 7 | foo[] = 1 8 | 9 | #~# ORIGINAL 10 | 11 | foo[ 1 , 2 ] = 3 12 | 13 | #~# EXPECTED 14 | 15 | foo[1, 2] = 3 16 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/assignment_operators.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | a += 2 4 | 5 | #~# EXPECTED 6 | 7 | a += 2 8 | 9 | #~# ORIGINAL 10 | 11 | a += 12 | 2 13 | 14 | #~# EXPECTED 15 | 16 | a += 17 | 2 18 | 19 | #~# ORIGINAL 20 | 21 | a+=1 22 | 23 | #~# EXPECTED 24 | 25 | a += 1 26 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/assignments.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | a = 1 4 | 5 | #~# EXPECTED 6 | 7 | a = 1 8 | 9 | #~# ORIGINAL 10 | 11 | a = 12 | 2 13 | 14 | #~# EXPECTED 15 | 16 | a = 17 | 2 18 | 19 | #~# ORIGINAL 20 | 21 | a = # hello 22 | 2 23 | 24 | #~# EXPECTED 25 | 26 | a = # hello 27 | 2 28 | 29 | #~# ORIGINAL 30 | 31 | a = if 1 32 | 2 33 | end 34 | 35 | #~# EXPECTED 36 | 37 | a = if 1 38 | 2 39 | end 40 | 41 | #~# ORIGINAL 42 | 43 | a = unless 1 44 | 2 45 | end 46 | 47 | #~# EXPECTED 48 | 49 | a = unless 1 50 | 2 51 | end 52 | 53 | #~# ORIGINAL 54 | 55 | a = begin 56 | 1 57 | end 58 | 59 | #~# EXPECTED 60 | 61 | a = begin 62 | 1 63 | end 64 | 65 | #~# ORIGINAL 66 | 67 | a = case 68 | when 1 69 | 2 70 | end 71 | 72 | #~# EXPECTED 73 | 74 | a = case 75 | when 1 76 | 2 77 | end 78 | 79 | #~# ORIGINAL 80 | 81 | a = begin 82 | 1 83 | end 84 | 85 | #~# EXPECTED 86 | 87 | a = begin 88 | 1 89 | end 90 | 91 | #~# ORIGINAL 92 | 93 | a = begin 94 | 1 95 | rescue 96 | 2 97 | end 98 | 99 | #~# EXPECTED 100 | 101 | a = begin 102 | 1 103 | rescue 104 | 2 105 | end 106 | 107 | #~# ORIGINAL 108 | 109 | a = begin 110 | 1 111 | ensure 112 | 2 113 | end 114 | 115 | #~# EXPECTED 116 | 117 | a = begin 118 | 1 119 | ensure 120 | 2 121 | end 122 | 123 | #~# ORIGINAL 124 | 125 | a=1 126 | 127 | #~# EXPECTED 128 | 129 | a = 1 130 | 131 | #~# ORIGINAL 132 | 133 | a = \ 134 | begin 135 | 1 136 | end 137 | 138 | #~# EXPECTED 139 | 140 | a = 141 | begin 142 | 1 143 | end 144 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/backtick_strings.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | `cat meow` 4 | 5 | #~# EXPECTED 6 | 7 | `cat meow` 8 | 9 | #~# ORIGINAL 10 | 11 | %x( cat meow ) 12 | 13 | #~# EXPECTED 14 | 15 | %x( cat meow ) 16 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/begin_end.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | begin;end 4 | 5 | #~# EXPECTED 6 | 7 | begin; end 8 | 9 | #~# ORIGINAL 10 | 11 | begin 12 | end 13 | 14 | #~# EXPECTED 15 | 16 | begin 17 | end 18 | 19 | #~# ORIGINAL 20 | 21 | begin 1 end 22 | 23 | #~# EXPECTED 24 | 25 | begin 1 end 26 | 27 | #~# ORIGINAL 28 | 29 | begin; 1; end 30 | 31 | #~# EXPECTED 32 | 33 | begin; 1; end 34 | 35 | #~# ORIGINAL 36 | 37 | begin; 1; 2; end 38 | 39 | #~# EXPECTED 40 | 41 | begin; 1; 2; end 42 | 43 | #~# ORIGINAL 44 | 45 | begin; 1 46 | 2; end 47 | 48 | #~# EXPECTED 49 | 50 | begin; 1 51 | 2; end 52 | 53 | #~# ORIGINAL 54 | 55 | begin 56 | 1 57 | end 58 | 59 | #~# EXPECTED 60 | 61 | begin 62 | 1 63 | end 64 | 65 | #~# ORIGINAL 66 | 67 | begin 68 | 1 69 | 2 70 | end 71 | 72 | #~# EXPECTED 73 | 74 | begin 75 | 1 76 | 2 77 | end 78 | 79 | #~# ORIGINAL 80 | 81 | begin 82 | begin 83 | 1 84 | end 85 | 2 86 | end 87 | 88 | #~# EXPECTED 89 | 90 | begin 91 | begin 92 | 1 93 | end 94 | 2 95 | end 96 | 97 | #~# ORIGINAL 98 | 99 | begin # hello 100 | end 101 | 102 | #~# EXPECTED 103 | 104 | begin # hello 105 | end 106 | 107 | #~# ORIGINAL 108 | 109 | begin;# hello 110 | end 111 | 112 | #~# EXPECTED 113 | 114 | begin # hello 115 | end 116 | 117 | #~# ORIGINAL 118 | 119 | begin 120 | 1 # a 121 | end 122 | 123 | #~# EXPECTED 124 | 125 | begin 126 | 1 # a 127 | end 128 | 129 | #~# ORIGINAL 130 | 131 | begin 132 | 1 # a 133 | # b 134 | 3 # c 135 | end 136 | 137 | #~# EXPECTED 138 | 139 | begin 140 | 1 # a 141 | # b 142 | 3 # c 143 | end 144 | 145 | #~# ORIGINAL 146 | 147 | begin 148 | end 149 | 150 | # foo 151 | 152 | #~# EXPECTED 153 | 154 | begin 155 | end 156 | 157 | # foo 158 | 159 | #~# ORIGINAL 160 | 161 | begin 162 | begin 1 end 163 | end 164 | 165 | #~# EXPECTED 166 | 167 | begin 168 | begin 1 end 169 | end 170 | 171 | #~# ORIGINAL 172 | 173 | begin 174 | def foo(x) 1 end 175 | end 176 | 177 | #~# EXPECTED 178 | 179 | begin 180 | def foo(x) 1 end 181 | end 182 | 183 | #~# ORIGINAL 184 | 185 | begin 186 | if 1 then 2 end 187 | end 188 | 189 | #~# EXPECTED 190 | 191 | begin 192 | if 1 then 2 end 193 | end 194 | 195 | #~# ORIGINAL 196 | 197 | begin 198 | if 1 then 2 end 199 | end 200 | 201 | #~# EXPECTED 202 | 203 | begin 204 | if 1 then 2 end 205 | end 206 | 207 | #~# ORIGINAL 208 | 209 | begin 210 | foo do 1 end 211 | end 212 | 213 | #~# EXPECTED 214 | 215 | begin 216 | foo do 1 end 217 | end 218 | 219 | #~# ORIGINAL 220 | 221 | begin 222 | for x in y do 1 end 223 | end 224 | 225 | #~# EXPECTED 226 | 227 | begin 228 | for x in y do 1 end 229 | end 230 | 231 | #~# ORIGINAL 232 | 233 | begin 234 | # foo 235 | 236 | 1 237 | end 238 | 239 | #~# EXPECTED 240 | 241 | begin 242 | # foo 243 | 244 | 1 245 | end 246 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/begin_rescue_end.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | begin 4 | 1 5 | rescue 6 | 2 7 | end 8 | 9 | #~# EXPECTED 10 | 11 | begin 12 | 1 13 | rescue 14 | 2 15 | end 16 | 17 | #~# ORIGINAL 18 | 19 | begin 20 | rescue A 21 | rescue B 22 | end 23 | 24 | #~# EXPECTED 25 | 26 | begin 27 | rescue A 28 | rescue B 29 | end 30 | 31 | #~# ORIGINAL 32 | 33 | begin 34 | 1 35 | rescue Foo 36 | 2 37 | end 38 | 39 | #~# EXPECTED 40 | 41 | begin 42 | 1 43 | rescue Foo 44 | 2 45 | end 46 | 47 | #~# ORIGINAL 48 | 49 | begin 50 | 1 51 | rescue => ex 52 | 2 53 | end 54 | 55 | #~# EXPECTED 56 | 57 | begin 58 | 1 59 | rescue => ex 60 | 2 61 | end 62 | 63 | #~# ORIGINAL 64 | 65 | begin 66 | 1 67 | rescue Foo => ex 68 | 2 69 | end 70 | 71 | #~# EXPECTED 72 | 73 | begin 74 | 1 75 | rescue Foo => ex 76 | 2 77 | end 78 | 79 | #~# ORIGINAL 80 | 81 | begin 82 | 1 83 | rescue Foo , Bar , Baz => ex 84 | 2 85 | end 86 | 87 | #~# EXPECTED 88 | 89 | begin 90 | 1 91 | rescue Foo, Bar, Baz => ex 92 | 2 93 | end 94 | 95 | #~# ORIGINAL 96 | 97 | begin 98 | 1 99 | rescue Foo , 100 | Bar , 101 | Baz => ex 102 | 2 103 | end 104 | 105 | #~# EXPECTED 106 | 107 | begin 108 | 1 109 | rescue Foo, 110 | Bar, 111 | Baz => ex 112 | 2 113 | end 114 | 115 | #~# ORIGINAL 116 | 117 | begin 118 | 1 119 | ensure 120 | 2 121 | end 122 | 123 | #~# EXPECTED 124 | 125 | begin 126 | 1 127 | ensure 128 | 2 129 | end 130 | 131 | #~# ORIGINAL 132 | 133 | begin 134 | 1 135 | else 136 | 2 137 | end 138 | 139 | #~# EXPECTED 140 | 141 | begin 142 | 1 143 | else 144 | 2 145 | end 146 | 147 | #~# ORIGINAL 148 | 149 | begin 150 | 1 151 | rescue *x 152 | end 153 | 154 | #~# EXPECTED 155 | 156 | begin 157 | 1 158 | rescue *x 159 | end 160 | 161 | #~# ORIGINAL 162 | 163 | begin 164 | 1 165 | rescue *x, *y 166 | end 167 | 168 | #~# EXPECTED 169 | 170 | begin 171 | 1 172 | rescue *x, *y 173 | end 174 | 175 | #~# ORIGINAL 176 | 177 | begin 178 | 1 179 | rescue *x, y, *z 180 | end 181 | 182 | #~# EXPECTED 183 | 184 | begin 185 | 1 186 | rescue *x, y, *z 187 | end 188 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/binary_operators.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | 1 + 2 4 | 5 | #~# EXPECTED 6 | 7 | 1 + 2 8 | 9 | #~# ORIGINAL 10 | 11 | 1+2 12 | 13 | #~# EXPECTED 14 | 15 | 1 + 2 16 | 17 | #~# ORIGINAL 18 | 19 | 1 + 20 | 2 21 | 22 | #~# EXPECTED 23 | 24 | 1 + 25 | 2 26 | 27 | #~# ORIGINAL 28 | 29 | 1 + # hello 30 | 2 31 | 32 | #~# EXPECTED 33 | 34 | 1 + # hello 35 | 2 36 | 37 | #~# ORIGINAL 38 | 39 | 1 + 40 | 2+ 41 | 3 42 | 43 | #~# EXPECTED 44 | 45 | 1 + 46 | 2 + 47 | 3 48 | 49 | #~# ORIGINAL 50 | 51 | 1 && 2 52 | 53 | #~# EXPECTED 54 | 55 | 1 && 2 56 | 57 | #~# ORIGINAL 58 | 59 | 1 || 2 60 | 61 | #~# EXPECTED 62 | 63 | 1 || 2 64 | 65 | #~# ORIGINAL 66 | 67 | 1*2 68 | 69 | #~# EXPECTED 70 | 71 | 1 * 2 72 | 73 | #~# ORIGINAL 74 | 75 | 1* 2 76 | 77 | #~# EXPECTED 78 | 79 | 1 * 2 80 | 81 | #~# ORIGINAL 82 | 83 | 1 *2 84 | 85 | #~# EXPECTED 86 | 87 | 1 * 2 88 | 89 | #~# ORIGINAL 90 | 91 | 1/2 92 | 93 | #~# EXPECTED 94 | 95 | 1 / 2 96 | 97 | #~# ORIGINAL 98 | 99 | 1**2 100 | 101 | #~# EXPECTED 102 | 103 | 1 ** 2 104 | 105 | #~# ORIGINAL 106 | 107 | 1 \ 108 | + 2 109 | 110 | #~# EXPECTED 111 | 112 | 1 \ 113 | + 2 114 | 115 | #~# ORIGINAL 116 | 117 | a = 1 || 118 | 2 119 | 120 | #~# EXPECTED 121 | 122 | a = 1 || 123 | 2 124 | 125 | #~# ORIGINAL 126 | 127 | 1 || 128 | 2 129 | 130 | #~# EXPECTED 131 | 132 | 1 || 133 | 2 134 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/blocks.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | foo {} 4 | 5 | #~# EXPECTED 6 | 7 | foo { } 8 | 9 | #~# ORIGINAL 10 | 11 | foo { } 12 | 13 | #~# EXPECTED 14 | 15 | foo { } 16 | 17 | #~# ORIGINAL 18 | 19 | foo { 1 } 20 | 21 | #~# EXPECTED 22 | 23 | foo { 1 } 24 | 25 | #~# ORIGINAL 26 | 27 | foo { 1 ; 2 } 28 | 29 | #~# EXPECTED 30 | 31 | foo { 1; 2 } 32 | 33 | #~# ORIGINAL 34 | 35 | foo { 1 36 | 2 } 37 | 38 | #~# EXPECTED 39 | 40 | foo { 41 | 1 42 | 2 43 | } 44 | 45 | #~# ORIGINAL 46 | 47 | foo { 48 | 1 } 49 | 50 | #~# EXPECTED 51 | 52 | foo { 53 | 1 54 | } 55 | 56 | #~# ORIGINAL 57 | 58 | begin 59 | foo { 1 } 60 | end 61 | 62 | #~# EXPECTED 63 | 64 | begin 65 | foo { 1 } 66 | end 67 | 68 | #~# ORIGINAL 69 | 70 | foo { | x , y | } 71 | 72 | #~# EXPECTED 73 | 74 | foo { |x, y| } 75 | 76 | #~# ORIGINAL 77 | 78 | foo { | x , | } 79 | 80 | #~# EXPECTED 81 | 82 | foo { |x, | } 83 | 84 | #~# ORIGINAL 85 | 86 | foo { | x , y, | bar} 87 | 88 | #~# EXPECTED 89 | 90 | foo { |x, y, | bar } 91 | 92 | #~# ORIGINAL 93 | 94 | foo { || } 95 | 96 | #~# EXPECTED 97 | 98 | foo { } 99 | 100 | #~# ORIGINAL 101 | 102 | foo { | | } 103 | 104 | #~# EXPECTED 105 | 106 | foo { } 107 | 108 | #~# ORIGINAL 109 | 110 | foo { | ( x ) , z | } 111 | 112 | #~# EXPECTED 113 | 114 | foo { |(x), z| } 115 | 116 | #~# ORIGINAL 117 | 118 | foo { | ( x , y ) , z | } 119 | 120 | #~# EXPECTED 121 | 122 | foo { |(x, y), z| } 123 | 124 | #~# ORIGINAL 125 | 126 | foo { | ( x , ( y , w ) ) , z | } 127 | 128 | #~# EXPECTED 129 | 130 | foo { |(x, (y, w)), z| } 131 | 132 | #~# ORIGINAL 133 | 134 | foo { | bar: 1 , baz: 2 | } 135 | 136 | #~# EXPECTED 137 | 138 | foo { |bar: 1, baz: 2| } 139 | 140 | #~# ORIGINAL 141 | 142 | foo { | *z | } 143 | 144 | #~# EXPECTED 145 | 146 | foo { |*z| } 147 | 148 | #~# ORIGINAL 149 | 150 | foo { | **z | } 151 | 152 | #~# EXPECTED 153 | 154 | foo { |**z| } 155 | 156 | #~# ORIGINAL 157 | 158 | foo { | bar = 1 | } 159 | 160 | #~# EXPECTED 161 | 162 | foo { |bar = 1| } 163 | 164 | #~# ORIGINAL 165 | 166 | foo { | x , y | 1 } 167 | 168 | #~# EXPECTED 169 | 170 | foo { |x, y| 1 } 171 | 172 | #~# ORIGINAL 173 | 174 | foo { | x | 175 | 1 } 176 | 177 | #~# EXPECTED 178 | 179 | foo { |x| 180 | 1 181 | } 182 | 183 | #~# ORIGINAL 184 | 185 | foo { | x , 186 | y | 187 | 1 } 188 | 189 | #~# EXPECTED 190 | 191 | foo { |x, 192 | y| 193 | 1 194 | } 195 | 196 | #~# ORIGINAL 197 | 198 | foo do end 199 | 200 | #~# EXPECTED 201 | 202 | foo do end 203 | 204 | #~# ORIGINAL 205 | 206 | foo do 1 end 207 | 208 | #~# EXPECTED 209 | 210 | foo do 1 end 211 | 212 | #~# ORIGINAL 213 | 214 | bar foo { 215 | 1 216 | }, 2 217 | 218 | #~# EXPECTED 219 | 220 | bar foo { 221 | 1 222 | }, 2 223 | 224 | #~# ORIGINAL 225 | 226 | bar foo { 227 | 1 228 | } + 2 229 | 230 | #~# EXPECTED 231 | 232 | bar foo { 233 | 1 234 | } + 2 235 | 236 | #~# ORIGINAL 237 | 238 | foo { |;x| } 239 | 240 | #~# EXPECTED 241 | 242 | foo { |; x| } 243 | 244 | #~# ORIGINAL 245 | 246 | foo { | 247 | ;x| } 248 | 249 | #~# EXPECTED 250 | 251 | foo { |; x| } 252 | 253 | #~# ORIGINAL 254 | 255 | foo { |;x, y| } 256 | 257 | #~# EXPECTED 258 | 259 | foo { |; x, y| } 260 | 261 | #~# ORIGINAL 262 | 263 | foo { |a, b;x, y| } 264 | 265 | #~# EXPECTED 266 | 267 | foo { |a, b; x, y| } 268 | 269 | #~# ORIGINAL 270 | 271 | proc { |(x, *y),z| } 272 | 273 | #~# EXPECTED 274 | 275 | proc { |(x, *y), z| } 276 | 277 | #~# ORIGINAL 278 | 279 | proc { |(w, *x, y), z| } 280 | 281 | #~# EXPECTED 282 | 283 | proc { |(w, *x, y), z| } 284 | 285 | #~# ORIGINAL 286 | 287 | foo { |(*x, y), z| } 288 | 289 | #~# EXPECTED 290 | 291 | foo { |(*x, y), z| } 292 | 293 | #~# ORIGINAL 294 | 295 | foo { begin; end; } 296 | 297 | #~# EXPECTED 298 | 299 | foo { begin; end } 300 | 301 | #~# ORIGINAL 302 | 303 | foo { 304 | |i| } 305 | 306 | #~# EXPECTED 307 | 308 | foo { 309 | |i| } 310 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/booleans.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL false 2 | 3 | false 4 | 5 | #~# EXPECTED 6 | 7 | false 8 | 9 | #~# ORIGINAL true 10 | 11 | true 12 | 13 | #~# EXPECTED 14 | 15 | true 16 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/break.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL break 2 | 3 | break 4 | 5 | #~# EXPECTED 6 | 7 | break 8 | 9 | #~# ORIGINAL 10 | 11 | break 1 12 | 13 | #~# EXPECTED 14 | 15 | break 1 16 | 17 | #~# ORIGINAL 18 | 19 | break 1 , 2 20 | 21 | #~# EXPECTED 22 | 23 | break 1, 2 24 | 25 | #~# ORIGINAL 26 | 27 | break 1 , 28 | 2 29 | 30 | #~# EXPECTED 31 | 32 | break 1, 33 | 2 34 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/calls_with_dot.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | foo.() 4 | 5 | #~# EXPECTED 6 | 7 | foo.() 8 | 9 | #~# ORIGINAL 10 | 11 | foo.( 1 ) 12 | 13 | #~# EXPECTED 14 | 15 | foo.(1) 16 | 17 | #~# ORIGINAL 18 | 19 | foo.( 1, 2 ) 20 | 21 | #~# EXPECTED 22 | 23 | foo.(1, 2) 24 | 25 | #~# ORIGINAL 26 | 27 | x.foo.( 1, 2 ) 28 | 29 | #~# EXPECTED 30 | 31 | x.foo.(1, 2) 32 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/calls_with_receiver.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | foo . bar . baz 4 | 5 | #~# EXPECTED 6 | 7 | foo.bar.baz 8 | 9 | #~# ORIGINAL 10 | 11 | foo . bar( 1 , 2 ) 12 | 13 | #~# EXPECTED 14 | 15 | foo.bar(1, 2) 16 | 17 | #~# ORIGINAL 18 | 19 | foo . 20 | bar 21 | 22 | #~# EXPECTED 23 | 24 | foo. 25 | bar 26 | 27 | #~# ORIGINAL 28 | 29 | foo . 30 | bar . 31 | baz 32 | 33 | #~# EXPECTED 34 | 35 | foo. 36 | bar. 37 | baz 38 | 39 | #~# ORIGINAL 40 | 41 | foo 42 | . bar 43 | 44 | #~# EXPECTED 45 | 46 | foo 47 | .bar 48 | 49 | #~# ORIGINAL 50 | 51 | foo 52 | . bar 53 | . baz 54 | 55 | #~# EXPECTED 56 | 57 | foo 58 | .bar 59 | .baz 60 | 61 | #~# ORIGINAL 62 | 63 | foo.bar 64 | .baz 65 | 66 | #~# EXPECTED 67 | 68 | foo.bar 69 | .baz 70 | 71 | #~# ORIGINAL 72 | 73 | foo.bar(1) 74 | .baz(2) 75 | .qux(3) 76 | 77 | #~# EXPECTED 78 | 79 | foo.bar(1) 80 | .baz(2) 81 | .qux(3) 82 | 83 | #~# ORIGINAL 84 | 85 | foobar.baz 86 | .with( 87 | 1 88 | ) 89 | 90 | #~# EXPECTED 91 | 92 | foobar.baz 93 | .with( 94 | 1 95 | ) 96 | 97 | #~# ORIGINAL 98 | 99 | foo.bar 1, 100 | x: 1, 101 | y: 2 102 | 103 | #~# EXPECTED 104 | 105 | foo.bar 1, 106 | x: 1, 107 | y: 2 108 | 109 | #~# ORIGINAL 110 | 111 | foo 112 | .bar # x 113 | .baz 114 | 115 | #~# EXPECTED 116 | 117 | foo 118 | .bar # x 119 | .baz 120 | 121 | #~# ORIGINAL 122 | 123 | c.x w 1 124 | 125 | #~# EXPECTED 126 | 127 | c.x w 1 128 | 129 | #~# ORIGINAL 130 | 131 | foo.bar 132 | .baz 133 | .baz 134 | 135 | #~# EXPECTED 136 | 137 | foo.bar 138 | .baz 139 | .baz 140 | 141 | #~# ORIGINAL 142 | 143 | foo.bar 144 | .baz 145 | .baz 146 | 147 | #~# EXPECTED 148 | 149 | foo.bar 150 | .baz 151 | .baz 152 | 153 | #~# ORIGINAL 154 | 155 | foo.bar(1) 156 | .baz([ 157 | 2, 158 | ]) 159 | 160 | #~# EXPECTED 161 | 162 | foo.bar(1) 163 | .baz([ 164 | 2, 165 | ]) 166 | 167 | #~# ORIGINAL 168 | 169 | foo.bar(1) 170 | .baz( 171 | 2, 172 | ) 173 | 174 | #~# EXPECTED 175 | 176 | foo.bar(1) 177 | .baz( 178 | 2, 179 | ) 180 | 181 | #~# ORIGINAL 182 | 183 | foo.bar(1) 184 | .baz( 185 | qux( 186 | 2 187 | ) 188 | ) 189 | 190 | #~# EXPECTED 191 | 192 | foo.bar(1) 193 | .baz( 194 | qux( 195 | 2 196 | ) 197 | ) 198 | 199 | #~# ORIGINAL 200 | 201 | foo.bar(1) 202 | .baz( 203 | qux.last( 204 | 2 205 | ) 206 | ) 207 | 208 | #~# EXPECTED 209 | 210 | foo.bar(1) 211 | .baz( 212 | qux.last( 213 | 2 214 | ) 215 | ) 216 | 217 | #~# ORIGINAL 218 | 219 | foo.bar( 220 | 1 221 | ) 222 | 223 | #~# EXPECTED 224 | 225 | foo.bar( 226 | 1 227 | ) 228 | 229 | #~# ORIGINAL 230 | 231 | foo 1, [ 232 | 2, 233 | 234 | 3, 235 | ] 236 | 237 | #~# EXPECTED 238 | 239 | foo 1, [ 240 | 2, 241 | 242 | 3, 243 | ] 244 | 245 | #~# ORIGINAL 246 | 247 | foo :x, { 248 | :foo1 => :bar, 249 | 250 | :foo2 => bar, 251 | } 252 | 253 | multiline :call, 254 | :foo => :bar, 255 | :foo => bar 256 | 257 | #~# EXPECTED 258 | 259 | foo :x, { 260 | :foo1 => :bar, 261 | 262 | :foo2 => bar, 263 | } 264 | 265 | multiline :call, 266 | :foo => :bar, 267 | :foo => bar 268 | 269 | #~# ORIGINAL 270 | 271 | x 272 | .foo.bar 273 | .baz 274 | 275 | #~# EXPECTED 276 | 277 | x 278 | .foo.bar 279 | .baz 280 | 281 | #~# ORIGINAL 282 | 283 | x 284 | .foo.bar.baz 285 | .qux 286 | 287 | #~# EXPECTED 288 | 289 | x 290 | .foo.bar.baz 291 | .qux 292 | 293 | #~# ORIGINAL 294 | 295 | x 296 | .foo(a.b).bar(c.d).baz(e.f) 297 | .qux.z(a.b) 298 | .final 299 | 300 | #~# EXPECTED 301 | 302 | x 303 | .foo(a.b).bar(c.d).baz(e.f) 304 | .qux.z(a.b) 305 | .final 306 | 307 | #~# ORIGINAL 308 | 309 | x.y 1, 2 310 | 311 | #~# EXPECTED 312 | 313 | x.y 1, 2 314 | 315 | #~# ORIGINAL 316 | 317 | x.y \ 318 | 1, 2 319 | 320 | #~# EXPECTED 321 | 322 | x.y \ 323 | 1, 2 324 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/case.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | case 4 | when 1 then 2 5 | end 6 | 7 | #~# EXPECTED 8 | 9 | case 10 | when 1 then 2 11 | end 12 | 13 | #~# ORIGINAL 14 | 15 | case 16 | when 1 then 2 17 | when 3 then 4 18 | end 19 | 20 | #~# EXPECTED 21 | 22 | case 23 | when 1 then 2 24 | when 3 then 4 25 | end 26 | 27 | #~# ORIGINAL 28 | 29 | case 30 | when 1 then 2 else 3 31 | end 32 | 33 | #~# EXPECTED 34 | 35 | case 36 | when 1 then 2 37 | else 3 38 | end 39 | 40 | #~# ORIGINAL 41 | 42 | case 43 | when 1 ; 2 44 | end 45 | 46 | #~# EXPECTED 47 | 48 | case 49 | when 1; 2 50 | end 51 | 52 | #~# ORIGINAL 53 | 54 | case 55 | when 1 56 | 2 57 | end 58 | 59 | #~# EXPECTED 60 | 61 | case 62 | when 1 63 | 2 64 | end 65 | 66 | #~# ORIGINAL 67 | 68 | case 69 | when 1 70 | 2 71 | 3 72 | end 73 | 74 | #~# EXPECTED 75 | 76 | case 77 | when 1 78 | 2 79 | 3 80 | end 81 | 82 | #~# ORIGINAL 83 | 84 | case 85 | when 1 86 | 2 87 | 3 88 | when 4 89 | 5 90 | end 91 | 92 | #~# EXPECTED 93 | 94 | case 95 | when 1 96 | 2 97 | 3 98 | when 4 99 | 5 100 | end 101 | 102 | #~# ORIGINAL 103 | 104 | case 123 105 | when 1 106 | 2 107 | end 108 | 109 | #~# EXPECTED 110 | 111 | case 123 112 | when 1 113 | 2 114 | end 115 | 116 | #~# ORIGINAL 117 | 118 | case # foo 119 | when 1 120 | 2 121 | end 122 | 123 | #~# EXPECTED 124 | 125 | case # foo 126 | when 1 127 | 2 128 | end 129 | 130 | #~# ORIGINAL 131 | 132 | case 133 | when 1 # comment 134 | 2 135 | end 136 | 137 | #~# EXPECTED 138 | 139 | case 140 | when 1 # comment 141 | 2 142 | end 143 | 144 | #~# ORIGINAL 145 | 146 | case 147 | when 1 then 2 else 148 | 3 149 | end 150 | 151 | #~# EXPECTED 152 | 153 | case 154 | when 1 then 2 155 | else 156 | 3 157 | end 158 | 159 | #~# ORIGINAL 160 | 161 | case 162 | when 1 then 2 else ; 163 | 3 164 | end 165 | 166 | #~# EXPECTED 167 | 168 | case 169 | when 1 then 2 170 | else 171 | 3 172 | end 173 | 174 | #~# ORIGINAL 175 | 176 | case 177 | when 1 then 2 else # comm 178 | 3 179 | end 180 | 181 | #~# EXPECTED 182 | 183 | case 184 | when 1 then 2 185 | else # comm 186 | 3 187 | end 188 | 189 | #~# ORIGINAL 190 | 191 | begin 192 | case 193 | when 1 194 | 2 195 | when 3 196 | 4 197 | else 198 | 5 199 | end 200 | end 201 | 202 | #~# EXPECTED 203 | 204 | begin 205 | case 206 | when 1 207 | 2 208 | when 3 209 | 4 210 | else 211 | 5 212 | end 213 | end 214 | 215 | #~# ORIGINAL 216 | 217 | case 218 | when 1 then 219 | 2 220 | end 221 | 222 | #~# EXPECTED 223 | 224 | case 225 | when 1 226 | 2 227 | end 228 | 229 | #~# ORIGINAL 230 | 231 | case 232 | when 1 then ; 233 | 2 234 | end 235 | 236 | #~# EXPECTED 237 | 238 | case 239 | when 1 240 | 2 241 | end 242 | 243 | #~# ORIGINAL 244 | 245 | case 246 | when 1 ; 247 | 2 248 | end 249 | 250 | #~# EXPECTED 251 | 252 | case 253 | when 1 254 | 2 255 | end 256 | 257 | #~# ORIGINAL 258 | 259 | case 260 | when 1 , 261 | 2 ; 262 | 3 263 | end 264 | 265 | #~# EXPECTED 266 | 267 | case 268 | when 1, 269 | 2 270 | 3 271 | end 272 | 273 | #~# ORIGINAL 274 | 275 | case 276 | when 1 , 2, # comm 277 | 278 | 3 279 | end 280 | 281 | #~# EXPECTED 282 | 283 | case 284 | when 1, 2, # comm 285 | 3 286 | end 287 | 288 | #~# ORIGINAL 289 | 290 | begin 291 | case 292 | when :x 293 | # comment 294 | 2 295 | end 296 | end 297 | 298 | #~# EXPECTED 299 | 300 | begin 301 | case 302 | when :x 303 | # comment 304 | 2 305 | end 306 | end 307 | 308 | #~# ORIGINAL 309 | 310 | case 1 311 | when *x , *y 312 | 2 313 | end 314 | 315 | #~# EXPECTED 316 | 317 | case 1 318 | when *x, *y 319 | 2 320 | end 321 | 322 | #~# ORIGINAL 323 | 324 | case 1 325 | when *x then 2 326 | end 327 | 328 | #~# EXPECTED 329 | 330 | case 1 331 | when *x then 2 332 | end 333 | 334 | #~# ORIGINAL 335 | 336 | case 1 337 | when 2 then 3 338 | end 339 | 340 | #~# EXPECTED 341 | 342 | case 1 343 | when 2 then 3 344 | end 345 | 346 | #~# ORIGINAL 347 | 348 | case 1 349 | when 2 then # comment 350 | end 351 | 352 | #~# EXPECTED 353 | 354 | case 1 355 | when 2 then # comment 356 | end 357 | 358 | #~# ORIGINAL 359 | 360 | case 1 361 | when 2 then 3 362 | else 363 | 4 364 | end 365 | 366 | #~# EXPECTED 367 | 368 | case 1 369 | when 2 then 3 370 | else 371 | 4 372 | end 373 | 374 | #~# ORIGINAL issue_87_1 375 | 376 | include Module.new { 377 | def call(str) 378 | case str 379 | when 'b' 380 | else 381 | 'd' 382 | end 383 | end 384 | } 385 | 386 | #~# EXPECTED 387 | 388 | include Module.new { 389 | def call(str) 390 | case str 391 | when "b" 392 | else 393 | "d" 394 | end 395 | end 396 | } 397 | 398 | #~# ORIGINAL issue_87_2 399 | #~# quote_style: :single 400 | 401 | include Module.new { 402 | def call(str) 403 | case str 404 | when 'b' 405 | else 406 | 'd' 407 | end 408 | end 409 | } 410 | 411 | #~# EXPECTED 412 | 413 | include Module.new { 414 | def call(str) 415 | case str 416 | when 'b' 417 | else 418 | 'd' 419 | end 420 | end 421 | } 422 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/chars.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL char 2 | 3 | ?a 4 | 5 | #~# EXPECTED 6 | 7 | ?a 8 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/class.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | class Foo 4 | end 5 | 6 | #~# EXPECTED 7 | 8 | class Foo 9 | end 10 | 11 | #~# ORIGINAL 12 | 13 | class Foo < Bar 14 | end 15 | 16 | #~# EXPECTED 17 | 18 | class Foo < Bar 19 | end 20 | 21 | #~# ORIGINAL 22 | 23 | class Foo 24 | 1 25 | end 26 | 27 | #~# EXPECTED 28 | 29 | class Foo 30 | 1 31 | end 32 | 33 | #~# ORIGINAL 34 | 35 | class Foo ; end 36 | 37 | #~# EXPECTED 38 | 39 | class Foo; end 40 | 41 | #~# ORIGINAL 42 | 43 | class Foo; 44 | end 45 | 46 | #~# EXPECTED 47 | 48 | class Foo 49 | end 50 | 51 | #~# ORIGINAL 52 | 53 | class Foo; 1; end 54 | class Bar; 2; end 55 | 56 | #~# EXPECTED 57 | 58 | class Foo; 1; end 59 | class Bar; 2; end 60 | 61 | #~# ORIGINAL 62 | 63 | class Foo; 1; end 64 | 65 | class Bar; 2; end 66 | 67 | #~# EXPECTED 68 | 69 | class Foo; 1; end 70 | 71 | class Bar; 2; end 72 | 73 | #~# ORIGINAL multi_inline_definitions 74 | 75 | class A; end; class B; end 76 | 77 | #~# EXPECTED 78 | 79 | class A; end 80 | class B; end 81 | 82 | #~# ORIGINAL multi_inline_definitions_with_comment 83 | 84 | class A; end; class B; end; class C; end # comment 85 | 86 | #~# EXPECTED 87 | 88 | class A; end 89 | class B; end 90 | class C; end # comment 91 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/class_into_self.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | class << self 4 | 1 5 | end 6 | 7 | #~# EXPECTED 8 | 9 | class << self 10 | 1 11 | end 12 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/class_rescue_end.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | class Foo 4 | raise "bar" 5 | rescue Baz => ex 6 | end 7 | 8 | #~# EXPECTED 9 | 10 | class Foo 11 | raise "bar" 12 | rescue Baz => ex 13 | end 14 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/class_variables.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | @@foo 4 | 5 | #~# EXPECTED 6 | 7 | @@foo 8 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/comments.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL comment 2 | 3 | # foo 4 | 5 | #~# EXPECTED 6 | 7 | # foo 8 | 9 | #~# ORIGINAL two_comments 10 | 11 | # foo 12 | # bar 13 | 14 | #~# EXPECTED 15 | 16 | # foo 17 | # bar 18 | 19 | #~# ORIGINAL integer_with_comment 20 | 21 | 1 # foo 22 | 23 | #~# EXPECTED 24 | 25 | 1 # foo 26 | 27 | #~# ORIGINAL comment_with_double_line_break 28 | 29 | # a 30 | 31 | # b 32 | 33 | #~# EXPECTED 34 | 35 | # a 36 | 37 | # b 38 | 39 | #~# ORIGINAL comment_with_triple_line_break 40 | 41 | # a 42 | 43 | 44 | # b 45 | 46 | #~# EXPECTED 47 | 48 | # a 49 | 50 | # b 51 | 52 | #~# ORIGINAL comment_and_integer 53 | 54 | # a 55 | 1 56 | 57 | #~# EXPECTED 58 | 59 | # a 60 | 1 61 | 62 | #~# ORIGINAL comment_double_newline_integer 63 | 64 | # a 65 | 66 | 67 | 1 68 | 69 | #~# EXPECTED 70 | 71 | # a 72 | 73 | 1 74 | 75 | #~# ORIGINAL integer_with_comment_and_following_comment 76 | 77 | 1 # a 78 | # b 79 | 80 | #~# EXPECTED 81 | 82 | 1 # a 83 | # b 84 | 85 | #~# ORIGINAL integer_with_comment_and_multiline_break 86 | 87 | 1 # a 88 | 89 | # b 90 | 91 | #~# EXPECTED 92 | 93 | 1 # a 94 | 95 | # b 96 | 97 | #~# ORIGINAL integers_separated_by_comments 98 | 99 | 1 # a 100 | 101 | 2 # b 102 | 103 | #~# EXPECTED 104 | 105 | 1 # a 106 | 107 | 2 # b 108 | 109 | #~# ORIGINAL multiple_trailing_comments 110 | 111 | 1 # a 112 | 113 | 114 | 2 # b 115 | 116 | #~# EXPECTED 117 | 118 | 1 # a 119 | 120 | 2 # b 121 | 122 | #~# ORIGINAL more_trailing_comments 123 | 124 | 1 # a 125 | 126 | 127 | 128 | 129 | 130 | 131 | 2 # b 132 | 133 | #~# EXPECTED 134 | 135 | 1 # a 136 | 137 | 2 # b 138 | 139 | #~# ORIGINAL still_more_trailing_comments 140 | 141 | 1 # a 142 | 143 | 144 | # b 145 | 146 | 147 | # c 148 | 2 # b 149 | 150 | #~# EXPECTED 151 | 152 | 1 # a 153 | 154 | # b 155 | 156 | # c 157 | 2 # b 158 | 159 | #~# ORIGINAL comment_indentation_inside_method_call 160 | 161 | foo( 162 | # comment for foo 163 | foo: "foo" 164 | ) 165 | 166 | #~# EXPECTED 167 | 168 | foo( 169 | # comment for foo 170 | foo: "foo", 171 | ) 172 | 173 | #~# ORIGINAL comment_indentation_inside_method_call_2 174 | 175 | foo( 176 | # comment for foo 177 | foo: "foo" 178 | ) 179 | 180 | #~# EXPECTED 181 | 182 | foo( 183 | # comment for foo 184 | foo: "foo", 185 | ) 186 | 187 | #~# ORIGINAL comment_indentation_inside_method_call_3 188 | 189 | foo( 190 | # comment for foo 191 | foo: "foo" 192 | ) 193 | 194 | #~# EXPECTED 195 | 196 | foo( 197 | # comment for foo 198 | foo: "foo", 199 | ) 200 | 201 | #~# ORIGINAL comment_indentation_inside_method_call_4 202 | 203 | foo( 204 | # comment for foo 205 | foo: "foo" 206 | ) 207 | 208 | #~# EXPECTED 209 | 210 | foo( 211 | # comment for foo 212 | foo: "foo", 213 | ) 214 | 215 | #~# ORIGINAL multiple_comments_inside_method_call 216 | 217 | foo( 218 | # comment for foo 219 | foo: "foo", 220 | 221 | # comment for bar 222 | bar: "bar", 223 | ) 224 | 225 | #~# EXPECTED 226 | 227 | foo( 228 | # comment for foo 229 | foo: "foo", 230 | 231 | # comment for bar 232 | bar: "bar", 233 | ) 234 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/constants.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | Foo 4 | 5 | #~# EXPECTED 6 | 7 | Foo 8 | 9 | #~# ORIGINAL 10 | 11 | Foo::Bar::Baz 12 | 13 | #~# EXPECTED 14 | 15 | Foo::Bar::Baz 16 | 17 | #~# ORIGINAL 18 | 19 | Foo::Bar::Baz 20 | 21 | #~# EXPECTED 22 | 23 | Foo::Bar::Baz 24 | 25 | #~# ORIGINAL 26 | 27 | Foo:: Bar:: Baz 28 | 29 | #~# EXPECTED 30 | 31 | Foo::Bar::Baz 32 | 33 | #~# ORIGINAL 34 | 35 | Foo:: 36 | Bar 37 | 38 | #~# EXPECTED 39 | 40 | Foo::Bar 41 | 42 | #~# ORIGINAL 43 | 44 | ::Foo 45 | 46 | #~# EXPECTED 47 | 48 | ::Foo 49 | 50 | #~# ORIGINAL 51 | 52 | ::Foo::Bar 53 | 54 | #~# EXPECTED 55 | 56 | ::Foo::Bar 57 | 58 | #~# ORIGINAL 59 | 60 | ::Foo = 1 61 | 62 | #~# EXPECTED 63 | 64 | ::Foo = 1 65 | 66 | #~# ORIGINAL 67 | 68 | ::Foo::Bar = 1 69 | 70 | #~# EXPECTED 71 | 72 | ::Foo::Bar = 1 73 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/defined_rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | defined? 1 4 | 5 | #~# EXPECTED 6 | 7 | defined? 1 8 | 9 | #~# ORIGINAL 10 | 11 | defined? ( 1 ) 12 | 13 | #~# EXPECTED 14 | 15 | defined? (1) 16 | 17 | #~# ORIGINAL 18 | 19 | defined?(1) 20 | 21 | #~# EXPECTED 22 | 23 | defined?(1) 24 | 25 | #~# ORIGINAL 26 | 27 | defined?((a, b = 1, 2)) 28 | 29 | #~# EXPECTED 30 | 31 | defined?((a, b = 1, 2)) 32 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/double_newline_inside_type.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | class Foo 4 | 5 | 1 6 | 7 | end 8 | 9 | #~# EXPECTED 10 | 11 | class Foo 12 | 1 13 | end 14 | 15 | #~# ORIGINAL 16 | 17 | class Foo 18 | 19 | 20 | 1 21 | 22 | 23 | end 24 | 25 | #~# EXPECTED 26 | 27 | class Foo 28 | 1 29 | end 30 | 31 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/double_quotes.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | #~# quote_style: :double 3 | 4 | 'a great string' 5 | 6 | #~# EXPECTED 7 | 8 | "a great string" 9 | 10 | #~# ORIGINAL 11 | #~# quote_style: :double 12 | 13 | '🚀' 14 | 15 | #~# EXPECTED 16 | 17 | "🚀" 18 | 19 | #~# ORIGINAL 20 | #~# quote_style: :double 21 | 22 | '' 23 | 24 | #~# EXPECTED 25 | 26 | "" 27 | 28 | #~# ORIGINAL 29 | #~# quote_style: :double 30 | 31 | 'import \"quotes\"' 32 | 33 | #~# EXPECTED 34 | 35 | 'import \"quotes\"' 36 | 37 | #~# ORIGINAL 38 | #~# quote_style: :double 39 | 40 | "#{interpolation}" 41 | 42 | #~# EXPECTED 43 | 44 | "#{interpolation}" 45 | 46 | #~# ORIGINAL 47 | #~# quote_style: :double 48 | 49 | "\0 \x7e \e \n \r \t \u1f680 \'" 50 | 51 | #~# EXPECTED 52 | 53 | "\0 \x7e \e \n \r \t \u1f680 \'" 54 | 55 | #~# ORIGINAL 56 | #~# quote_style: :double 57 | 58 | %q(single) 59 | 60 | #~# EXPECTED 61 | 62 | %q(single) 63 | 64 | #~# ORIGINAL 65 | #~# quote_style: :double 66 | 67 | %Q(double) 68 | 69 | #~# EXPECTED 70 | 71 | %Q(double) 72 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/floats.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | 12.34 4 | 5 | #~# EXPECTED 6 | 7 | 12.34 8 | 9 | #~# ORIGINAL 10 | 11 | 12.34e-10 12 | 13 | #~# EXPECTED 14 | 15 | 12.34e-10 16 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/for.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | for x in y 4 | 2 5 | end 6 | 7 | #~# EXPECTED 8 | 9 | for x in y 10 | 2 11 | end 12 | 13 | #~# ORIGINAL 14 | 15 | for x , y in z 16 | 2 17 | end 18 | 19 | #~# EXPECTED 20 | 21 | for x, y in z 22 | 2 23 | end 24 | 25 | #~# ORIGINAL 26 | 27 | for x in y do 28 | 2 29 | end 30 | 31 | #~# EXPECTED 32 | 33 | for x in y 34 | 2 35 | end 36 | 37 | #~# ORIGINAL bug_45 38 | 39 | for i, in [[1,2]] 40 | i.should == 1 41 | end 42 | 43 | #~# EXPECTED 44 | 45 | for i, in [[1, 2]] 46 | i.should == 1 47 | end 48 | 49 | #~# ORIGINAL 50 | 51 | for i,j, in [[1,2]] 52 | i.should == 1 53 | end 54 | 55 | #~# EXPECTED 56 | 57 | for i, j, in [[1, 2]] 58 | i.should == 1 59 | end 60 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/global_variables.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | $abc 4 | 5 | #~# EXPECTED 6 | 7 | $abc 8 | 9 | #~# ORIGINAL 10 | 11 | $abc . d 12 | 13 | #~# EXPECTED 14 | 15 | $abc.d 16 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/hash_literal.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | { } 4 | 5 | #~# EXPECTED 6 | 7 | {} 8 | 9 | #~# ORIGINAL 10 | 11 | {:foo => 1 } 12 | 13 | #~# EXPECTED 14 | 15 | { :foo => 1 } 16 | 17 | #~# ORIGINAL 18 | 19 | {:foo => 1} 20 | 21 | #~# EXPECTED 22 | 23 | { :foo => 1 } 24 | 25 | #~# ORIGINAL 26 | 27 | { :foo => 1 } 28 | 29 | #~# EXPECTED 30 | 31 | { :foo => 1 } 32 | 33 | #~# ORIGINAL 34 | 35 | { :foo => 1 , 2 => 3 } 36 | 37 | #~# EXPECTED 38 | 39 | { :foo => 1, 2 => 3 } 40 | 41 | #~# ORIGINAL 42 | 43 | { 44 | :foo => 1 , 45 | 2 => 3 } 46 | 47 | #~# EXPECTED 48 | 49 | { 50 | :foo => 1, 51 | 2 => 3, 52 | } 53 | 54 | #~# ORIGINAL 55 | 56 | { **x } 57 | 58 | #~# EXPECTED 59 | 60 | { **x } 61 | 62 | #~# ORIGINAL 63 | 64 | {foo: 1} 65 | 66 | #~# EXPECTED 67 | 68 | { foo: 1 } 69 | 70 | #~# ORIGINAL 71 | 72 | { foo: 1 } 73 | 74 | #~# EXPECTED 75 | 76 | { foo: 1 } 77 | 78 | #~# ORIGINAL 79 | 80 | { :foo => 81 | 1 } 82 | 83 | #~# EXPECTED 84 | 85 | { :foo => 1 } 86 | 87 | #~# ORIGINAL 88 | 89 | { "foo": 1 } 90 | 91 | #~# EXPECTED 92 | 93 | { "foo": 1 } 94 | 95 | #~# ORIGINAL 96 | 97 | { "foo #{ 2 }": 1 } 98 | 99 | #~# EXPECTED 100 | 101 | { "foo #{2}": 1 } 102 | 103 | #~# ORIGINAL 104 | 105 | { :"one two" => 3 } 106 | 107 | #~# EXPECTED 108 | 109 | { :"one two" => 3 } 110 | 111 | #~# ORIGINAL 112 | 113 | { foo: 1, 114 | bar: 2 } 115 | 116 | #~# EXPECTED 117 | 118 | { foo: 1, 119 | bar: 2 } 120 | 121 | #~# ORIGINAL 122 | 123 | {foo: 1, bar: 2} 124 | 125 | #~# EXPECTED 126 | 127 | { foo: 1, bar: 2 } 128 | 129 | #~# ORIGINAL 130 | 131 | {1 => 132 | 2} 133 | 134 | #~# EXPECTED 135 | 136 | { 1 => 2 } 137 | 138 | #~# ORIGINAL 139 | 140 | { 1 => {} } 141 | 142 | #~# EXPECTED 143 | 144 | { 1 => {} } 145 | 146 | #~# ORIGINAL 147 | 148 | {1 => { }} 149 | 150 | #~# EXPECTED 151 | 152 | { 1 => {} } 153 | 154 | #~# ORIGINAL 155 | 156 | { 157 | 1 => { }} 158 | 159 | #~# EXPECTED 160 | 161 | { 162 | 1 => {}, 163 | } 164 | 165 | 166 | #~# ORIGINAL 167 | 168 | { 1 => 2 169 | } 170 | 171 | #~# EXPECTED 172 | 173 | { 1 => 2 } 174 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/heredoc.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL heredoc 2 | 3 | <<-EOF 4 | foo 5 | bar 6 | EOF 7 | 8 | #~# EXPECTED 9 | 10 | <<-EOF 11 | foo 12 | bar 13 | EOF 14 | 15 | #~# ORIGINAL heredoc_multiline 16 | 17 | foo 1 , <<-EOF , 2 18 | foo 19 | bar 20 | EOF 21 | 22 | #~# EXPECTED 23 | 24 | foo 1, <<-EOF, 2 25 | foo 26 | bar 27 | EOF 28 | 29 | #~# ORIGINAL heredoc_multiline_2 30 | 31 | foo 1 , <<-EOF1 , 2 , <<-EOF2 , 3 32 | foo 33 | bar 34 | EOF1 35 | baz 36 | EOF2 37 | 38 | #~# EXPECTED 39 | 40 | foo 1, <<-EOF1, 2, <<-EOF2, 3 41 | foo 42 | bar 43 | EOF1 44 | baz 45 | EOF2 46 | 47 | #~# ORIGINAL heredoc_multiline_3 48 | 49 | foo 1 , <<-EOF1 , 2 , <<-EOF2 50 | foo 51 | bar 52 | EOF1 53 | baz 54 | EOF2 55 | 56 | #~# EXPECTED 57 | 58 | foo 1, <<-EOF1, 2, <<-EOF2 59 | foo 60 | bar 61 | EOF1 62 | baz 63 | EOF2 64 | 65 | #~# ORIGINAL heredoc_inside_method_call 66 | 67 | foo(1 , <<-EOF , 2 ) 68 | foo 69 | bar 70 | EOF 71 | 72 | #~# EXPECTED 73 | 74 | foo(1, <<-EOF, 2) 75 | foo 76 | bar 77 | EOF 78 | 79 | #~# ORIGINAL heredoc_with_method_called 80 | 81 | <<-EOF.foo 82 | bar 83 | EOF 84 | 85 | #~# EXPECTED 86 | 87 | <<-EOF.foo 88 | bar 89 | EOF 90 | 91 | #~# ORIGINAL heredoc_assigned_to_variable 92 | 93 | x = <<-EOF.foo 94 | bar 95 | EOF 96 | 97 | #~# EXPECTED 98 | 99 | x = <<-EOF.foo 100 | bar 101 | EOF 102 | 103 | #~# ORIGINAL heredoc_assigned_to_multiple_variables 104 | 105 | x, y = <<-EOF.foo, 2 106 | bar 107 | EOF 108 | 109 | #~# EXPECTED 110 | 111 | x, y = <<-EOF.foo, 2 112 | bar 113 | EOF 114 | 115 | #~# ORIGINAL heredoc_as_method_argument 116 | 117 | call <<-EOF.foo, y 118 | bar 119 | EOF 120 | 121 | #~# EXPECTED 122 | 123 | call <<-EOF.foo, y 124 | bar 125 | EOF 126 | 127 | #~# ORIGINAL heredoc_as_method_argument_with_brackets 128 | 129 | foo(<<-EOF 130 | foo 131 | bar 132 | EOF 133 | ) 134 | 135 | #~# EXPECTED 136 | 137 | foo(<<-EOF 138 | foo 139 | bar 140 | EOF 141 | ) 142 | 143 | #~# ORIGINAL heredoc_with_trailing_comment 144 | 145 | <<-EOF 146 | foo 147 | EOF 148 | 149 | # comment 150 | 151 | #~# EXPECTED 152 | 153 | <<-EOF 154 | foo 155 | EOF 156 | 157 | # comment 158 | 159 | #~# ORIGINAL heredoc_as_strange_method_argument 160 | 161 | foo(<<-EOF) 162 | bar 163 | EOF 164 | 165 | #~# EXPECTED 166 | 167 | foo(<<-EOF) 168 | bar 169 | EOF 170 | 171 | #~# ORIGINAL heredoc_with_bizarre_syntax 172 | 173 | foo <<-EOF.bar if 1 174 | x 175 | EOF 176 | 177 | #~# EXPECTED 178 | 179 | foo <<-EOF.bar if 1 180 | x 181 | EOF 182 | 183 | #~# ORIGINAL heredoc_with_percent 184 | 185 | <<-EOF % 1 186 | bar 187 | EOF 188 | 189 | #~# EXPECTED 190 | 191 | <<-EOF % 1 192 | bar 193 | EOF 194 | 195 | #~# ORIGINAL heredoc_value_trailing_comma_already_present 196 | 197 | { 198 | content: <<-EOF, 199 | This is a heredoc 200 | EOF 201 | } 202 | 203 | #~# EXPECTED 204 | 205 | { 206 | content: <<-EOF, 207 | This is a heredoc 208 | EOF 209 | } 210 | 211 | #~# ORIGINAL heredoc_value_trailing_comma_already_present 212 | #~# trailing_commas: false 213 | 214 | { 215 | content: <<-EOF, 216 | This is a heredoc 217 | EOF 218 | } 219 | 220 | #~# EXPECTED 221 | 222 | { 223 | content: <<-EOF 224 | This is a heredoc 225 | EOF 226 | } 227 | 228 | #~# ORIGINAL heredoc_value_trailing_comma_not_present 229 | #~# trailing_commas: false 230 | 231 | { 232 | content: <<-EOF 233 | This is a heredoc 234 | EOF 235 | } 236 | 237 | #~# EXPECTED 238 | 239 | { 240 | content: <<-EOF 241 | This is a heredoc 242 | EOF 243 | } 244 | 245 | #~# ORIGINAL heredoc_value_trailing_comma_already_present 246 | #~# trailing_commas: true 247 | 248 | { 249 | content: <<-EOF, 250 | This is a heredoc 251 | EOF 252 | } 253 | 254 | #~# EXPECTED 255 | 256 | { 257 | content: <<-EOF, 258 | This is a heredoc 259 | EOF 260 | } 261 | 262 | #~# ORIGINAL heredoc_value_trailing_comma_not_present 263 | #~# trailing_commas: true 264 | 265 | { 266 | content: <<-EOF 267 | This is a heredoc 268 | EOF 269 | } 270 | 271 | #~# EXPECTED 272 | 273 | { 274 | content: <<-EOF, 275 | This is a heredoc 276 | EOF 277 | } 278 | 279 | #~# ORIGINAL heredoc_as_hash_value 280 | 281 | {1 => < 3} 285 | 286 | #~# EXPECTED 287 | 288 | { 1 => < 3 } 292 | 293 | #~# ORIGINAL heredoc_in_parens 294 | 295 | (<<-E 296 | abc 297 | E 298 | ) 299 | 300 | #~# EXPECTED 301 | 302 | (<<-E 303 | abc 304 | E 305 | ) 306 | 307 | #~# ORIGINAL heredoc_in_parens_following_space_and_command_issue_83 308 | 309 | puts (<<-HELLO 310 | hello world 311 | HELLO 312 | ) 313 | 314 | #~# EXPECTED 315 | 316 | puts (<<-HELLO 317 | hello world 318 | HELLO 319 | ) 320 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/if.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | if 1 4 | 2 5 | end 6 | 7 | #~# EXPECTED 8 | 9 | if 1 10 | 2 11 | end 12 | 13 | #~# ORIGINAL 14 | 15 | if 1 16 | 17 | 2 18 | 19 | end 20 | 21 | #~# EXPECTED 22 | 23 | if 1 24 | 2 25 | end 26 | 27 | #~# ORIGINAL 28 | 29 | if 1 30 | 31 | end 32 | 33 | #~# EXPECTED 34 | 35 | if 1 36 | end 37 | 38 | #~# ORIGINAL 39 | 40 | if 1;end 41 | 42 | #~# EXPECTED 43 | 44 | if 1; end 45 | 46 | #~# ORIGINAL 47 | 48 | if 1 # hello 49 | end 50 | 51 | #~# EXPECTED 52 | 53 | if 1 # hello 54 | end 55 | 56 | #~# ORIGINAL 57 | 58 | if 1 # hello 59 | 60 | end 61 | 62 | #~# EXPECTED 63 | 64 | if 1 # hello 65 | end 66 | 67 | #~# ORIGINAL 68 | 69 | if 1 # hello 70 | 1 71 | end 72 | 73 | #~# EXPECTED 74 | 75 | if 1 # hello 76 | 1 77 | end 78 | 79 | #~# ORIGINAL 80 | 81 | if 1;# hello 82 | 1 83 | end 84 | 85 | #~# EXPECTED 86 | 87 | if 1 # hello 88 | 1 89 | end 90 | 91 | #~# ORIGINAL 92 | 93 | if 1 # hello 94 | # bye 95 | end 96 | 97 | #~# EXPECTED 98 | 99 | if 1 # hello 100 | # bye 101 | end 102 | 103 | #~# ORIGINAL 104 | 105 | if 1; 2; else; end 106 | 107 | #~# EXPECTED 108 | 109 | if 1; 2; else; end 110 | 111 | #~# ORIGINAL 112 | 113 | if 1; 2; else; 3; end 114 | 115 | #~# EXPECTED 116 | 117 | if 1; 2; else; 3; end 118 | 119 | #~# ORIGINAL 120 | 121 | if 1; 2; else # comment 122 | 3; end 123 | 124 | #~# EXPECTED 125 | 126 | if 1; 2; else # comment 127 | 3 128 | end 129 | 130 | #~# ORIGINAL 131 | 132 | begin 133 | if 1 134 | 2 135 | else 136 | 3 137 | end 138 | end 139 | 140 | #~# EXPECTED 141 | 142 | begin 143 | if 1 144 | 2 145 | else 146 | 3 147 | end 148 | end 149 | 150 | #~# ORIGINAL 151 | 152 | if 1 then 2 else 3 end 153 | 154 | #~# EXPECTED 155 | 156 | if 1 then 2 else 3 end 157 | 158 | #~# ORIGINAL 159 | 160 | if 1 161 | 2 162 | elsif 3 163 | 4 164 | end 165 | 166 | #~# EXPECTED 167 | 168 | if 1 169 | 2 170 | elsif 3 171 | 4 172 | end 173 | 174 | #~# ORIGINAL 175 | 176 | if 1 177 | then 2 178 | end 179 | 180 | #~# EXPECTED 181 | 182 | if 1 183 | 2 184 | end 185 | 186 | #~# ORIGINAL 187 | 188 | if 1 189 | if 2 then 3 else 4 end 190 | end 191 | 192 | #~# EXPECTED 193 | 194 | if 1 195 | if 2 then 3 else 4 end 196 | end 197 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/imaginaries.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | 3.141592i 4 | 5 | #~# EXPECTED 6 | 7 | 3.141592i 8 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/inline_classes.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL multi_inline_definitions 2 | 3 | class A end; class B end 4 | 5 | #~# EXPECTED 6 | 7 | class A end 8 | class B end 9 | 10 | #~# ORIGINAL multi_inline_definitions_with_comment 11 | 12 | class A end; class B end; class C end # comment 13 | 14 | #~# EXPECTED 15 | 16 | class A end 17 | class B end 18 | class C end # comment 19 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/integers.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 123 2 | 3 | 123 4 | 5 | #~# EXPECTED 6 | 7 | 123 8 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/junk_drawer.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | def foo 4 | end 5 | def bar 6 | end 7 | 8 | #~# EXPECTED 9 | 10 | def foo 11 | end 12 | 13 | def bar 14 | end 15 | 16 | #~# ORIGINAL 17 | 18 | class Foo 19 | end 20 | class Bar 21 | end 22 | 23 | #~# EXPECTED 24 | 25 | class Foo 26 | end 27 | 28 | class Bar 29 | end 30 | 31 | #~# ORIGINAL 32 | 33 | module Foo 34 | end 35 | module Bar 36 | end 37 | 38 | #~# EXPECTED 39 | 40 | module Foo 41 | end 42 | 43 | module Bar 44 | end 45 | 46 | #~# ORIGINAL 47 | 48 | 1 49 | def foo 50 | end 51 | 52 | #~# EXPECTED 53 | 54 | 1 55 | 56 | def foo 57 | end 58 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/keyword_arguments.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | def meth(fallback: nil) 4 | end 5 | 6 | #~# EXPECTED 7 | 8 | def meth(fallback: nil) 9 | end 10 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/lambdas.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | -> { } 4 | 5 | #~# EXPECTED 6 | 7 | -> { } 8 | 9 | #~# ORIGINAL 10 | 11 | ->{ } 12 | 13 | #~# EXPECTED 14 | 15 | -> { } 16 | 17 | #~# ORIGINAL 18 | 19 | ->{ 1 } 20 | 21 | #~# EXPECTED 22 | 23 | -> { 1 } 24 | 25 | #~# ORIGINAL 26 | 27 | ->{ 1 ; 2 } 28 | 29 | #~# EXPECTED 30 | 31 | -> { 1; 2 } 32 | 33 | #~# ORIGINAL 34 | 35 | ->{ 1 36 | 2 } 37 | 38 | #~# EXPECTED 39 | 40 | -> { 41 | 1 42 | 2 43 | } 44 | 45 | #~# ORIGINAL 46 | 47 | -> do 1 48 | 2 end 49 | 50 | #~# EXPECTED 51 | 52 | -> do 53 | 1 54 | 2 55 | end 56 | 57 | #~# ORIGINAL 58 | 59 | ->do 1 60 | 2 end 61 | 62 | #~# EXPECTED 63 | 64 | -> do 65 | 1 66 | 2 67 | end 68 | 69 | #~# ORIGINAL 70 | 71 | ->( x ){ } 72 | 73 | #~# EXPECTED 74 | 75 | ->(x) { } 76 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/lonely.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | foo &. bar 4 | 5 | #~# EXPECTED 6 | 7 | foo&.bar 8 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/lonely_operator.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | foo&. bar 4 | 5 | #~# EXPECTED 6 | 7 | foo&.bar 8 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/lonely_property_setters.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | foo&. bar = 1 4 | 5 | #~# EXPECTED 6 | 7 | foo&.bar = 1 8 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/lonely_receiver_and_block.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | foo&.bar 1 do 4 | end 5 | 6 | #~# EXPECTED 7 | 8 | foo&.bar 1 do 9 | end 10 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/method_definition.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | def foo 4 | end 5 | 6 | #~# EXPECTED 7 | 8 | def foo 9 | end 10 | 11 | #~# ORIGINAL 12 | 13 | def foo ; end 14 | 15 | #~# EXPECTED 16 | 17 | def foo; end 18 | 19 | #~# ORIGINAL 20 | 21 | def foo() 22 | end 23 | 24 | #~# EXPECTED 25 | 26 | def foo() 27 | end 28 | 29 | #~# ORIGINAL 30 | 31 | def foo() 1 end 32 | 33 | #~# EXPECTED 34 | 35 | def foo() 1 end 36 | 37 | #~# ORIGINAL 38 | 39 | def foo( 40 | ) 41 | end 42 | 43 | #~# EXPECTED 44 | 45 | def foo() 46 | end 47 | 48 | #~# ORIGINAL 49 | 50 | def foo( x ) 51 | end 52 | 53 | #~# EXPECTED 54 | 55 | def foo(x) 56 | end 57 | 58 | #~# ORIGINAL 59 | 60 | def foo( x , y ) 61 | end 62 | 63 | #~# EXPECTED 64 | 65 | def foo(x, y) 66 | end 67 | 68 | #~# ORIGINAL 69 | 70 | def foo x 71 | end 72 | 73 | #~# EXPECTED 74 | 75 | def foo(x) 76 | end 77 | 78 | #~# ORIGINAL 79 | 80 | def foo x , y 81 | end 82 | 83 | #~# EXPECTED 84 | 85 | def foo(x, y) 86 | end 87 | 88 | #~# ORIGINAL 89 | 90 | def foo 91 | 1 92 | end 93 | 94 | #~# EXPECTED 95 | 96 | def foo 97 | 1 98 | end 99 | 100 | #~# ORIGINAL 101 | 102 | def foo( * x ) 103 | 1 104 | end 105 | 106 | #~# EXPECTED 107 | 108 | def foo(*x) 109 | 1 110 | end 111 | 112 | #~# ORIGINAL 113 | 114 | def foo( a , * x ) 115 | 1 116 | end 117 | 118 | #~# EXPECTED 119 | 120 | def foo(a, *x) 121 | 1 122 | end 123 | 124 | #~# ORIGINAL 125 | 126 | def foo( a , * x, b ) 127 | 1 128 | end 129 | 130 | #~# EXPECTED 131 | 132 | def foo(a, *x, b) 133 | 1 134 | end 135 | 136 | #~# ORIGINAL 137 | 138 | def foo( x = 1 ) 139 | end 140 | 141 | #~# EXPECTED 142 | 143 | def foo(x = 1) 144 | end 145 | 146 | #~# ORIGINAL 147 | 148 | def foo( x = 1, * y ) 149 | end 150 | 151 | #~# EXPECTED 152 | 153 | def foo(x = 1, *y) 154 | end 155 | 156 | #~# ORIGINAL 157 | 158 | def foo( & block ) 159 | end 160 | 161 | #~# EXPECTED 162 | 163 | def foo(&block) 164 | end 165 | 166 | #~# ORIGINAL 167 | 168 | def foo( a: , b: ) 169 | end 170 | 171 | #~# EXPECTED 172 | 173 | def foo(a:, b:) 174 | end 175 | 176 | #~# ORIGINAL 177 | 178 | def foo( a: 1 , b: 2 ) 179 | end 180 | 181 | #~# EXPECTED 182 | 183 | def foo(a: 1, b: 2) 184 | end 185 | 186 | #~# ORIGINAL 187 | 188 | def foo( x, 189 | y ) 190 | end 191 | 192 | #~# EXPECTED 193 | 194 | def foo(x, 195 | y) 196 | end 197 | 198 | #~# ORIGINAL 199 | 200 | def foo( a: 1, 201 | b: 2 ) 202 | end 203 | 204 | #~# EXPECTED 205 | 206 | def foo(a: 1, 207 | b: 2) 208 | end 209 | 210 | #~# ORIGINAL 211 | 212 | def foo( 213 | x, 214 | y ) 215 | end 216 | 217 | #~# EXPECTED 218 | 219 | def foo( 220 | x, 221 | y) 222 | end 223 | 224 | #~# ORIGINAL 225 | 226 | def foo( a: 1, &block ) 227 | end 228 | 229 | #~# EXPECTED 230 | 231 | def foo(a: 1, &block) 232 | end 233 | 234 | #~# ORIGINAL 235 | 236 | def foo( a: 1, 237 | &block ) 238 | end 239 | 240 | #~# EXPECTED 241 | 242 | def foo(a: 1, 243 | &block) 244 | end 245 | 246 | #~# ORIGINAL 247 | 248 | def foo(*) 249 | end 250 | 251 | #~# EXPECTED 252 | 253 | def foo(*) 254 | end 255 | 256 | #~# ORIGINAL 257 | 258 | def foo(**) 259 | end 260 | 261 | #~# EXPECTED 262 | 263 | def foo(**) 264 | end 265 | 266 | #~# ORIGINAL 267 | 268 | def `(cmd) 269 | end 270 | 271 | #~# EXPECTED 272 | 273 | def `(cmd) 274 | end 275 | 276 | #~# ORIGINAL 277 | 278 | module_function def foo 279 | 1 280 | end 281 | 282 | #~# EXPECTED 283 | 284 | module_function def foo 285 | 1 286 | end 287 | 288 | #~# ORIGINAL 289 | 290 | private def foo 291 | 1 292 | end 293 | 294 | #~# EXPECTED 295 | 296 | private def foo 297 | 1 298 | end 299 | 300 | #~# ORIGINAL 301 | 302 | some class Foo 303 | 1 304 | end 305 | 306 | #~# EXPECTED 307 | 308 | some class Foo 309 | 1 310 | end 311 | 312 | #~# ORIGINAL 313 | 314 | def foo; 1; end 315 | def bar; 2; end 316 | 317 | #~# EXPECTED 318 | 319 | def foo; 1; end 320 | def bar; 2; end 321 | 322 | #~# ORIGINAL 323 | 324 | def foo; 1; end 325 | 326 | def bar; 2; end 327 | 328 | #~# EXPECTED 329 | 330 | def foo; 1; end 331 | 332 | def bar; 2; end 333 | 334 | #~# ORIGINAL multi_inline_definitions 335 | 336 | def foo; end; def bar; end 337 | 338 | #~# EXPECTED 339 | 340 | def foo; end 341 | def bar; end 342 | 343 | #~# ORIGINAL multi_inline_definitions_2 344 | 345 | def foo; 1 end; def bar; 2 end 346 | 347 | #~# EXPECTED 348 | 349 | def foo; 1 end 350 | def bar; 2 end 351 | 352 | #~# ORIGINAL multi_inline_definitions_with_comment 353 | 354 | def a;1 end;def b;2 end;def c;3 end # comment 355 | 356 | #~# EXPECTED 357 | 358 | def a; 1 end 359 | def b; 2 end 360 | def c; 3 end # comment 361 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/method_definition_with_receiver.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | def foo . 4 | bar; end 5 | 6 | #~# EXPECTED 7 | 8 | def foo.bar; end 9 | 10 | #~# ORIGINAL 11 | 12 | def foo :: 13 | bar; end 14 | 15 | #~# EXPECTED 16 | 17 | def foo::bar; end 18 | 19 | #~# ORIGINAL 20 | 21 | def self . 22 | bar; end 23 | 24 | #~# EXPECTED 25 | 26 | def self.bar; end 27 | 28 | #~# ORIGINAL 29 | 30 | def self :: 31 | bar; end 32 | 33 | #~# EXPECTED 34 | 35 | def self::bar; end 36 | 37 | #~# ORIGINAL 38 | 39 | module Foo 40 | def Foo :: 41 | bar; end; end 42 | 43 | #~# EXPECTED 44 | 45 | module Foo 46 | def Foo::bar; end 47 | end 48 | 49 | #~# ORIGINAL multi_inline_definitions 50 | 51 | def foo(x); end; def bar(y); end 52 | 53 | #~# EXPECTED 54 | 55 | def foo(x); end 56 | def bar(y); end 57 | 58 | #~# ORIGINAL multi_inline_definitions_2 59 | 60 | def foo(x); x end; def bar(y); y end 61 | 62 | #~# EXPECTED 63 | 64 | def foo(x); x end 65 | def bar(y); y end 66 | 67 | #~# ORIGINAL multi_inline_definitions_with_comment 68 | 69 | def a x;x end;def b y;y end;def c z;z end # comment 70 | 71 | #~# EXPECTED 72 | 73 | def a(x); x end 74 | def b(y); y end 75 | def c(z); z end # comment 76 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/module.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | module Foo 4 | end 5 | 6 | #~# EXPECTED 7 | 8 | module Foo 9 | end 10 | 11 | #~# ORIGINAL 12 | 13 | module Foo ; end 14 | 15 | #~# EXPECTED 16 | 17 | module Foo; end 18 | 19 | #~# ORIGINAL 20 | 21 | module Foo; 1; end 22 | module Bar; 2; end 23 | 24 | #~# EXPECTED 25 | 26 | module Foo; 1; end 27 | module Bar; 2; end 28 | 29 | #~# ORIGINAL 30 | 31 | module Foo; 1; end 32 | 33 | module Bar; 2; end 34 | 35 | #~# EXPECTED 36 | 37 | module Foo; 1; end 38 | 39 | module Bar; 2; end 40 | 41 | #~# ORIGINAL multi_inline_definitions 42 | 43 | module A; end; module B; end 44 | 45 | #~# EXPECTED 46 | 47 | module A; end 48 | module B; end 49 | 50 | #~# ORIGINAL multi_inline_definitions_2 51 | 52 | module A a end; module B b end; module C c end 53 | 54 | #~# EXPECTED 55 | 56 | module A a end 57 | module B b end 58 | module C c end 59 | 60 | #~# ORIGINAL multi_inline_definitions_3 61 | 62 | module A end; module B end 63 | 64 | #~# EXPECTED 65 | 66 | module A end 67 | module B end 68 | 69 | #~# ORIGINAL multi_inline_definitions_4 70 | 71 | module A a end; module B b end; module C c end 72 | 73 | #~# EXPECTED 74 | 75 | module A a end 76 | module B b end 77 | module C c end 78 | 79 | #~# ORIGINAL multi_inline_definitions_with_comment 80 | 81 | module A end; module B end; module C end # comment 82 | 83 | #~# EXPECTED 84 | 85 | module A end 86 | module B end 87 | module C end # comment 88 | 89 | #~# ORIGINAL multi_inline_definitions_with_comment_2 90 | 91 | module A;a end; module B;b end; module C;c end # comment 92 | 93 | #~# EXPECTED 94 | 95 | module A; a end 96 | module B; b end 97 | module C; c end # comment 98 | 99 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/multiline_comments.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL multiline_comment 2 | 3 | =begin 4 | foo 5 | bar 6 | =end 7 | 8 | #~# EXPECTED 9 | 10 | =begin 11 | foo 12 | bar 13 | =end 14 | 15 | #~# ORIGINAL multiline_comment_2 16 | 17 | 1 18 | 19 | =begin 20 | foo 21 | bar 22 | =end 23 | 24 | 2 25 | 26 | #~# EXPECTED 27 | 28 | 1 29 | 30 | =begin 31 | foo 32 | bar 33 | =end 34 | 35 | 2 36 | 37 | #~# ORIGINAL multiline_comment_3 38 | 39 | # foo 40 | =begin 41 | bar 42 | =end 43 | 44 | #~# EXPECTED 45 | 46 | # foo 47 | =begin 48 | bar 49 | =end 50 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/multiple_assignments.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | a = 1 , 2 4 | 5 | #~# EXPECTED 6 | 7 | a = 1, 2 8 | 9 | #~# ORIGINAL 10 | 11 | a , b = 2 12 | 13 | #~# EXPECTED 14 | 15 | a, b = 2 16 | 17 | #~# ORIGINAL 18 | 19 | a , b, ( c, d ) = 2 20 | 21 | #~# EXPECTED 22 | 23 | a, b, (c, d) = 2 24 | 25 | #~# ORIGINAL 26 | 27 | *x = 1 28 | 29 | #~# EXPECTED 30 | 31 | *x = 1 32 | 33 | #~# ORIGINAL 34 | 35 | a , b , *x = 1 36 | 37 | #~# EXPECTED 38 | 39 | a, b, *x = 1 40 | 41 | #~# ORIGINAL 42 | 43 | *x , a , b = 1 44 | 45 | #~# EXPECTED 46 | 47 | *x, a, b = 1 48 | 49 | #~# ORIGINAL 50 | 51 | a, b, *x, c, d = 1 52 | 53 | #~# EXPECTED 54 | 55 | a, b, *x, c, d = 1 56 | 57 | #~# ORIGINAL 58 | 59 | a, b, = 1 60 | 61 | #~# EXPECTED 62 | 63 | a, b, = 1 64 | 65 | #~# ORIGINAL 66 | 67 | a = b, *c 68 | 69 | #~# EXPECTED 70 | 71 | a = b, *c 72 | 73 | #~# ORIGINAL 74 | 75 | a = b, *c, *d 76 | 77 | #~# EXPECTED 78 | 79 | a = b, *c, *d 80 | 81 | #~# ORIGINAL 82 | 83 | a, = b 84 | 85 | #~# EXPECTED 86 | 87 | a, = b 88 | 89 | #~# ORIGINAL 90 | 91 | a = b, c, *d 92 | 93 | #~# EXPECTED 94 | 95 | a = b, c, *d 96 | 97 | #~# ORIGINAL 98 | 99 | a = b, c, *d, e 100 | 101 | #~# EXPECTED 102 | 103 | a = b, c, *d, e 104 | 105 | #~# ORIGINAL 106 | 107 | *, y = z 108 | 109 | #~# EXPECTED 110 | 111 | *, y = z 112 | 113 | #~# ORIGINAL 114 | 115 | w, (x,), y = z 116 | 117 | #~# EXPECTED 118 | 119 | w, (x,), y = z 120 | 121 | #~# ORIGINAL 122 | 123 | a, b=1, 2 124 | 125 | #~# EXPECTED 126 | 127 | a, b = 1, 2 128 | 129 | #~# ORIGINAL 130 | 131 | * = 1 132 | 133 | #~# EXPECTED 134 | 135 | * = 1 136 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/next.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL next 2 | 3 | next 4 | 5 | #~# EXPECTED 6 | 7 | next 8 | 9 | #~# ORIGINAL 10 | 11 | next 1 12 | 13 | #~# EXPECTED 14 | 15 | next 1 16 | 17 | #~# ORIGINAL 18 | 19 | next 1 , 2 20 | 21 | #~# EXPECTED 22 | 23 | next 1, 2 24 | 25 | #~# ORIGINAL 26 | 27 | next 1 , 28 | 2 29 | 30 | #~# EXPECTED 31 | 32 | next 1, 33 | 2 34 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/nil.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL nil 2 | 3 | nil 4 | 5 | #~# EXPECTED 6 | 7 | nil 8 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/parens.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | ( 1 ) 4 | 5 | #~# EXPECTED 6 | 7 | (1) 8 | 9 | #~# ORIGINAL 10 | 11 | ( 1 ; 2 ) 12 | 13 | #~# EXPECTED 14 | 15 | (1; 2) 16 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/parens_in_def.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | #~# parens_in_def: :dynamic 3 | 4 | def foo(x); end 5 | 6 | #~# EXPECTED 7 | 8 | def foo(x); end 9 | 10 | #~# ORIGINAL 11 | #~# parens_in_def: :dynamic 12 | 13 | def foo x; end 14 | 15 | #~# EXPECTED 16 | 17 | def foo x; end 18 | 19 | #~# ORIGINAL 20 | #~# parens_in_def: :yes 21 | 22 | def foo(x); end 23 | 24 | #~# EXPECTED 25 | 26 | def foo(x); end 27 | 28 | #~# ORIGINAL 29 | #~# parens_in_def: :yes 30 | 31 | def foo x; end 32 | 33 | #~# EXPECTED 34 | 35 | def foo(x); end 36 | 37 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/percent_array_literal.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | %w() 4 | 5 | #~# EXPECTED 6 | 7 | %w() 8 | 9 | #~# ORIGINAL 10 | 11 | %w( ) 12 | 13 | #~# EXPECTED 14 | 15 | %w() 16 | 17 | #~# ORIGINAL 18 | 19 | %w(one) 20 | 21 | #~# EXPECTED 22 | 23 | %w(one) 24 | 25 | #~# ORIGINAL 26 | 27 | %w( one ) 28 | 29 | #~# EXPECTED 30 | 31 | %w( one ) 32 | 33 | #~# ORIGINAL 34 | 35 | %w(one two 36 | three ) 37 | 38 | #~# EXPECTED 39 | 40 | %w(one two 41 | three) 42 | 43 | #~# ORIGINAL 44 | 45 | %w( one two 46 | three ) 47 | 48 | #~# EXPECTED 49 | 50 | %w( one two 51 | three ) 52 | 53 | #~# ORIGINAL 54 | 55 | %w( 56 | one ) 57 | 58 | #~# EXPECTED 59 | 60 | %w( 61 | one) 62 | 63 | #~# ORIGINAL 64 | 65 | %w( 66 | one 67 | ) 68 | 69 | #~# EXPECTED 70 | 71 | %w( 72 | one 73 | ) 74 | 75 | #~# ORIGINAL 76 | 77 | %w[ one ] 78 | 79 | #~# EXPECTED 80 | 81 | %w[ one ] 82 | 83 | #~# ORIGINAL 84 | 85 | begin 86 | %w( 87 | one 88 | ) 89 | end 90 | 91 | #~# EXPECTED 92 | 93 | begin 94 | %w( 95 | one 96 | ) 97 | end 98 | 99 | #~# ORIGINAL 100 | 101 | %i( ) 102 | 103 | #~# EXPECTED 104 | 105 | %i() 106 | 107 | #~# ORIGINAL 108 | 109 | %i( one ) 110 | 111 | #~# EXPECTED 112 | 113 | %i( one ) 114 | 115 | #~# ORIGINAL 116 | 117 | %i( one two 118 | three ) 119 | 120 | #~# EXPECTED 121 | 122 | %i( one two 123 | three ) 124 | 125 | #~# ORIGINAL 126 | 127 | %i[ one ] 128 | 129 | #~# EXPECTED 130 | 131 | %i[ one ] 132 | 133 | #~# ORIGINAL 134 | 135 | %W( ) 136 | 137 | #~# EXPECTED 138 | 139 | %W() 140 | 141 | #~# ORIGINAL 142 | 143 | %W( one ) 144 | 145 | #~# EXPECTED 146 | 147 | %W( one ) 148 | 149 | #~# ORIGINAL 150 | 151 | %W( one two ) 152 | 153 | #~# EXPECTED 154 | 155 | %W( one two ) 156 | 157 | #~# ORIGINAL 158 | 159 | %W( one two #{ 1 } ) 160 | 161 | #~# EXPECTED 162 | 163 | %W( one two #{1} ) 164 | 165 | #~# ORIGINAL 166 | 167 | %W(#{1}2) 168 | 169 | #~# EXPECTED 170 | 171 | %W(#{1}2) 172 | 173 | #~# ORIGINAL 174 | 175 | %I( ) 176 | 177 | #~# EXPECTED 178 | 179 | %I() 180 | 181 | #~# ORIGINAL 182 | 183 | %I( one two #{ 1 } ) 184 | 185 | #~# EXPECTED 186 | 187 | %I( one two #{1} ) 188 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/property_setters.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | foo . bar = 1 4 | 5 | #~# EXPECTED 6 | 7 | foo.bar = 1 8 | 9 | #~# ORIGINAL 10 | 11 | foo . bar = 12 | 1 13 | 14 | #~# EXPECTED 15 | 16 | foo.bar = 17 | 1 18 | 19 | #~# ORIGINAL 20 | 21 | foo . 22 | bar = 23 | 1 24 | 25 | #~# EXPECTED 26 | 27 | foo. 28 | bar = 29 | 1 30 | 31 | #~# ORIGINAL 32 | 33 | foo:: bar = 1 34 | 35 | #~# EXPECTED 36 | 37 | foo::bar = 1 38 | 39 | #~# ORIGINAL 40 | 41 | foo:: bar = 42 | 1 43 | 44 | #~# EXPECTED 45 | 46 | foo::bar = 47 | 1 48 | 49 | #~# ORIGINAL 50 | 51 | foo:: 52 | bar = 53 | 1 54 | 55 | #~# EXPECTED 56 | 57 | foo:: 58 | bar = 59 | 1 60 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/range.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | 1 .. 2 4 | 5 | #~# EXPECTED 6 | 7 | 1..2 8 | 9 | #~# ORIGINAL 10 | 11 | 1 ... 2 12 | 13 | #~# EXPECTED 14 | 15 | 1...2 16 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/rationals.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | 3.141592r 4 | 5 | #~# EXPECTED 6 | 7 | 3.141592r 8 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/received_and_block.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | foo.bar baz, 2 do 4 | end 5 | 6 | #~# EXPECTED 7 | 8 | foo.bar baz, 2 do 9 | end 10 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/receiver_and_block.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | foo.bar 1 do 4 | end 5 | 6 | #~# EXPECTED 7 | 8 | foo.bar 1 do 9 | end 10 | 11 | #~# ORIGINAL 12 | 13 | foo::bar 1 do 14 | end 15 | 16 | #~# EXPECTED 17 | 18 | foo::bar 1 do 19 | end 20 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/redo.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL redo 2 | 3 | redo 4 | 5 | #~# EXPECTED 6 | 7 | redo 8 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/regex.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | // 4 | 5 | #~# EXPECTED 6 | 7 | // 8 | 9 | #~# ORIGINAL 10 | 11 | //ix 12 | 13 | #~# EXPECTED 14 | 15 | //ix 16 | 17 | #~# ORIGINAL 18 | 19 | /foo/ 20 | 21 | #~# EXPECTED 22 | 23 | /foo/ 24 | 25 | #~# ORIGINAL 26 | 27 | /foo #{1 + 2} / 28 | 29 | #~# EXPECTED 30 | 31 | /foo #{1 + 2} / 32 | 33 | #~# ORIGINAL 34 | 35 | %r( foo ) 36 | 37 | #~# EXPECTED 38 | 39 | %r( foo ) 40 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/retry.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL retry 2 | 3 | retry 4 | 5 | #~# EXPECTED 6 | 7 | retry 8 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/return.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL return 2 | 3 | return 4 | 5 | #~# EXPECTED 6 | 7 | return 8 | 9 | #~# ORIGINAL 10 | 11 | return 1 12 | 13 | #~# EXPECTED 14 | 15 | return 1 16 | 17 | #~# ORIGINAL 18 | 19 | return 1 , 2 20 | 21 | #~# EXPECTED 22 | 23 | return 1, 2 24 | 25 | #~# ORIGINAL 26 | 27 | return 1 , 28 | 2 29 | 30 | #~# EXPECTED 31 | 32 | return 1, 33 | 2 34 | 35 | #~# ORIGINAL 36 | 37 | return a b 38 | 39 | #~# EXPECTED 40 | 41 | return a b 42 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/semicolons.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | 123; 4 | 5 | #~# EXPECTED 6 | 7 | 123 8 | 9 | #~# ORIGINAL 10 | 11 | 1 ; 2 12 | 13 | #~# EXPECTED 14 | 15 | 1; 2 16 | 17 | #~# ORIGINAL 18 | 19 | 1 ; ; 2 20 | 21 | #~# EXPECTED 22 | 23 | 1; 2 24 | 25 | #~# ORIGINAL 26 | 27 | 1 28 | 2 29 | 30 | #~# EXPECTED 31 | 32 | 1 33 | 2 34 | 35 | #~# ORIGINAL 36 | 37 | 1 38 | 39 | 2 40 | 41 | #~# EXPECTED 42 | 43 | 1 44 | 45 | 2 46 | 47 | #~# ORIGINAL 48 | 49 | 1 50 | ; ; ; 51 | 2 52 | 53 | #~# EXPECTED 54 | 55 | 1 56 | 57 | 2 58 | 59 | #~# ORIGINAL 60 | 61 | 1 ; 62 | ; 63 | ; ; 64 | 2 65 | 66 | #~# EXPECTED 67 | 68 | 1 69 | 70 | 2 71 | 72 | #~# ORIGINAL 73 | 74 | 123; # hello 75 | 76 | #~# EXPECTED 77 | 78 | 123 # hello 79 | 80 | #~# ORIGINAL 81 | 82 | 1; 83 | 2 84 | 85 | #~# EXPECTED 86 | 87 | 1 88 | 2 89 | 90 | #~# ORIGINAL 91 | 92 | begin 93 | 1 ; 2 94 | end 95 | 96 | #~# EXPECTED 97 | 98 | begin 99 | 1; 2 100 | end 101 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/single_quotes.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | #~# quote_style: :single 3 | 4 | "a great string" 5 | 6 | #~# EXPECTED 7 | 8 | 'a great string' 9 | 10 | #~# ORIGINAL 11 | #~# quote_style: :single 12 | 13 | "🚀" 14 | 15 | #~# EXPECTED 16 | 17 | '🚀' 18 | 19 | #~# ORIGINAL 20 | #~# quote_style: :single 21 | 22 | "" 23 | 24 | #~# EXPECTED 25 | 26 | '' 27 | 28 | #~# ORIGINAL 29 | #~# quote_style: :single 30 | 31 | "it's ok" 32 | 33 | #~# EXPECTED 34 | 35 | "it's ok" 36 | 37 | #~# ORIGINAL 38 | #~# quote_style: :single 39 | 40 | "#{interpolation}" 41 | 42 | #~# EXPECTED 43 | 44 | "#{interpolation}" 45 | 46 | #~# ORIGINAL 47 | #~# quote_style: :double 48 | 49 | '#{interpolation}' 50 | 51 | #~# EXPECTED 52 | 53 | '#{interpolation}' 54 | 55 | #~# ORIGINAL 56 | #~# quote_style: :single 57 | 58 | "\0 \x7e \e \n \r \t \u1f680 \'" 59 | 60 | #~# EXPECTED 61 | 62 | "\0 \x7e \e \n \r \t \u1f680 \'" 63 | 64 | #~# ORIGINAL 65 | #~# quote_style: :double 66 | 67 | '\0 \x7e \e \n \r \t \u1f680 \'' 68 | 69 | #~# EXPECTED 70 | 71 | '\0 \x7e \e \n \r \t \u1f680 \'' 72 | 73 | #~# ORIGINAL 74 | #~# quote_style: :double 75 | 76 | '"' 77 | 78 | #~# EXPECTED 79 | 80 | '"' 81 | 82 | #~# ORIGINAL 83 | #~# quote_style: :double 84 | 85 | '#$foo' 86 | 87 | #~# EXPECTED 88 | 89 | '#$foo' 90 | 91 | #~# ORIGINAL 92 | #~# quote_style: :double 93 | 94 | '#$' 95 | 96 | #~# EXPECTED 97 | 98 | '#$' 99 | 100 | #~# ORIGINAL 101 | #~# quote_style: :double 102 | 103 | '#' 104 | 105 | #~# EXPECTED 106 | 107 | "#" 108 | 109 | 110 | #~# ORIGINAL 111 | #~# quote_style: :single 112 | 113 | %q(single) 114 | 115 | #~# EXPECTED 116 | 117 | %q(single) 118 | 119 | #~# ORIGINAL 120 | #~# quote_style: :single 121 | 122 | %Q(double) 123 | 124 | #~# EXPECTED 125 | 126 | %Q(double) 127 | 128 | #~# ORIGINAL 129 | #~# quote_style: :single 130 | 131 | foobar 1, 132 | "foo 133 | bar" 134 | 135 | #~# EXPECTED 136 | 137 | foobar 1, 138 | 'foo 139 | bar' 140 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/spaces_after_comma.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | foo 1, 2, 3 4 | 5 | #~# EXPECTED 6 | 7 | foo 1, 2, 3 8 | 9 | #~# ORIGINAL 10 | 11 | foo(1, 2, 3) 12 | 13 | #~# EXPECTED 14 | 15 | foo(1, 2, 3) 16 | 17 | #~# ORIGINAL 18 | 19 | foo(1,2,3,x:1,y:2) 20 | 21 | #~# EXPECTED 22 | 23 | foo(1, 2, 3, x: 1, y: 2) 24 | 25 | #~# ORIGINAL 26 | 27 | def foo(x,y) 28 | end 29 | 30 | #~# EXPECTED 31 | 32 | def foo(x, y) 33 | end 34 | 35 | #~# ORIGINAL 36 | 37 | [1, 2, 3] 38 | 39 | #~# EXPECTED 40 | 41 | [1, 2, 3] 42 | 43 | #~# ORIGINAL 44 | 45 | [1,2,3] 46 | 47 | #~# EXPECTED 48 | 49 | [1, 2, 3] 50 | 51 | #~# ORIGINAL 52 | 53 | a , b = 1, 2 54 | 55 | #~# EXPECTED 56 | 57 | a, b = 1, 2 58 | 59 | #~# ORIGINAL 60 | 61 | a,b = 1,2 62 | 63 | #~# EXPECTED 64 | 65 | a, b = 1, 2 66 | 67 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/spaces_after_lambda_arrow.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | -> { } 4 | 5 | #~# EXPECTED 6 | 7 | -> { } 8 | 9 | #~# ORIGINAL 10 | 11 | ->{ } 12 | 13 | #~# EXPECTED 14 | 15 | -> { } 16 | 17 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/spaces_after_method_name.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | def foo (x) 4 | end 5 | 6 | #~# EXPECTED 7 | 8 | def foo(x) 9 | end 10 | 11 | 12 | #~# ORIGINAL 13 | 14 | def self.foo (x) 15 | end 16 | 17 | #~# EXPECTED 18 | 19 | def self.foo(x) 20 | end 21 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/spaces_around_binary.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | 1+2 4 | 5 | #~# EXPECTED 6 | 7 | 1 + 2 8 | 9 | #~# ORIGINAL 10 | 11 | 1+2 12 | 13 | #~# EXPECTED 14 | 15 | 1 + 2 16 | 17 | #~# ORIGINAL 18 | 19 | 1 + 2 20 | 21 | #~# EXPECTED 22 | 23 | 1 + 2 24 | 25 | #~# ORIGINAL 26 | 27 | 1+ 2 28 | 29 | #~# EXPECTED 30 | 31 | 1 + 2 32 | 33 | #~# ORIGINAL 34 | 35 | 1 +2 36 | 37 | #~# EXPECTED 38 | 39 | 1 + 2 40 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/spaces_around_block_brace.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | foo{1} 4 | 5 | #~# EXPECTED 6 | 7 | foo { 1 } 8 | 9 | #~# ORIGINAL 10 | 11 | foo{|x|1} 12 | 13 | #~# EXPECTED 14 | 15 | foo { |x| 1 } 16 | 17 | #~# ORIGINAL 18 | 19 | foo { 1 } 20 | 21 | #~# EXPECTED 22 | 23 | foo { 1 } 24 | 25 | #~# ORIGINAL 26 | 27 | ->{1} 28 | 29 | #~# EXPECTED 30 | 31 | -> { 1 } 32 | 33 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/spaces_around_dot.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | foo . bar 4 | 5 | #~# EXPECTED 6 | 7 | foo.bar 8 | 9 | #~# ORIGINAL 10 | 11 | foo . bar = 1 12 | 13 | #~# EXPECTED 14 | 15 | foo.bar = 1 16 | 17 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/spaces_around_equal.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | a=1 4 | 5 | #~# EXPECTED 6 | 7 | a = 1 8 | 9 | #~# ORIGINAL 10 | 11 | a = 1 12 | 13 | #~# EXPECTED 14 | 15 | a = 1 16 | 17 | #~# ORIGINAL 18 | 19 | a = 1 20 | 21 | #~# EXPECTED 22 | 23 | a = 1 24 | 25 | #~# ORIGINAL 26 | 27 | a+=1 28 | 29 | #~# EXPECTED 30 | 31 | a += 1 32 | 33 | #~# ORIGINAL 34 | 35 | a += 1 36 | 37 | #~# EXPECTED 38 | 39 | a += 1 40 | 41 | #~# ORIGINAL 42 | 43 | a += 1 44 | 45 | #~# EXPECTED 46 | 47 | a += 1 48 | 49 | #~# ORIGINAL 50 | 51 | def foo(x = 1) 52 | end 53 | 54 | #~# EXPECTED 55 | 56 | def foo(x = 1) 57 | end 58 | 59 | #~# ORIGINAL 60 | 61 | def foo(x=1) 62 | end 63 | 64 | #~# EXPECTED 65 | 66 | def foo(x = 1) 67 | end 68 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/spaces_around_hash_arrow.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | {1 => 2} 4 | 5 | #~# EXPECTED 6 | 7 | { 1 => 2 } 8 | 9 | #~# ORIGINAL 10 | 11 | {1=>2} 12 | 13 | #~# EXPECTED 14 | 15 | { 1 => 2 } 16 | 17 | #~# ORIGINAL 18 | 19 | {foo: 2} 20 | 21 | #~# EXPECTED 22 | 23 | { foo: 2 } 24 | 25 | #~# ORIGINAL 26 | 27 | {foo:2} 28 | 29 | #~# EXPECTED 30 | 31 | { foo: 2 } 32 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/spaces_around_unary.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | - x 4 | 5 | #~# EXPECTED 6 | 7 | -x 8 | 9 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/spaces_around_when.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | case 1 4 | when 2 then 3 5 | else 4 6 | end 7 | 8 | #~# EXPECTED 9 | 10 | case 1 11 | when 2 then 3 12 | else 4 13 | end 14 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/spaces_in_commands.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | foo 1 4 | 5 | #~# EXPECTED 6 | 7 | foo 1 8 | 9 | #~# ORIGINAL 10 | 11 | foo.bar 1 12 | 13 | #~# EXPECTED 14 | 15 | foo.bar 1 16 | 17 | #~# ORIGINAL 18 | 19 | not x 20 | 21 | #~# EXPECTED 22 | 23 | !x 24 | 25 | #~# ORIGINAL 26 | 27 | not x 28 | 29 | #~# EXPECTED 30 | 31 | !x 32 | 33 | #~# ORIGINAL 34 | 35 | defined? 1 36 | 37 | #~# EXPECTED 38 | 39 | defined? 1 40 | 41 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/spaces_in_inline_expressions.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | begin end 4 | 5 | #~# EXPECTED 6 | 7 | begin end 8 | 9 | #~# ORIGINAL 10 | 11 | begin 1 end 12 | 13 | #~# EXPECTED 14 | 15 | begin 1 end 16 | 17 | #~# ORIGINAL 18 | 19 | def foo() 1 end 20 | 21 | #~# EXPECTED 22 | 23 | def foo() 1 end 24 | 25 | #~# ORIGINAL 26 | 27 | def foo(x) 1 end 28 | 29 | #~# EXPECTED 30 | 31 | def foo(x) 1 end 32 | 33 | #~# ORIGINAL 34 | 35 | def foo1(x) 1 end 36 | def foo2(x) 2 end 37 | def foo3(x) 3 end 38 | 39 | #~# EXPECTED 40 | 41 | def foo1(x) 1 end 42 | def foo2(x) 2 end 43 | def foo3(x) 3 end 44 | 45 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/spaces_in_suffix.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | 1 if 2 4 | 5 | #~# EXPECTED 6 | 7 | 1 if 2 8 | 9 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/spaces_in_ternary.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | 1?2:3 4 | 5 | #~# EXPECTED 6 | 7 | 1 ? 2 : 3 8 | 9 | #~# ORIGINAL 10 | 11 | 1 ? 2 : 3 12 | 13 | #~# EXPECTED 14 | 15 | 1 ? 2 : 3 16 | 17 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/spaces_inside_array_bracket.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | [ 1 ] 4 | 5 | #~# EXPECTED 6 | 7 | [1] 8 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/spaces_inside_hash_brace.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | { 1 => 2 } 4 | 5 | #~# EXPECTED 6 | 7 | { 1 => 2 } 8 | 9 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/special_global_variables.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | $~ 4 | 5 | #~# EXPECTED 6 | 7 | $~ 8 | 9 | #~# ORIGINAL 10 | 11 | $1 12 | 13 | #~# EXPECTED 14 | 15 | $1 16 | 17 | #~# ORIGINAL 18 | 19 | $! 20 | 21 | #~# EXPECTED 22 | 23 | $! 24 | 25 | #~# ORIGINAL 26 | 27 | $@ 28 | 29 | #~# EXPECTED 30 | 31 | $@ 32 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/squiggly_heredoc.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | [ 4 | [<<~'},'] # comment 5 | }, 6 | ] 7 | 8 | #~# EXPECTED 9 | 10 | [ 11 | [<<~'},'], # comment 12 | }, 13 | ] 14 | 15 | #~# ORIGINAL 16 | 17 | [ 18 | [<<~'},'], # comment 19 | }, 20 | ] 21 | 22 | #~# EXPECTED 23 | 24 | [ 25 | [<<~'},'], # comment 26 | }, 27 | ] 28 | 29 | #~# ORIGINAL 30 | 31 | [ 32 | [<<~'},'], # comment 33 | }, 34 | 2, 35 | ] 36 | 37 | #~# EXPECTED 38 | 39 | [ 40 | [<<~'},'], # comment 41 | }, 42 | 2, 43 | ] 44 | 45 | #~# ORIGINAL 46 | 47 | [ 48 | [<<~EOF] # comment 49 | EOF 50 | ] 51 | 52 | #~# EXPECTED 53 | 54 | [ 55 | [<<~EOF], # comment 56 | EOF 57 | ] 58 | 59 | #~# ORIGINAL 60 | 61 | begin 62 | foo = <<~STR 63 | some 64 | 65 | thing 66 | STR 67 | end 68 | 69 | #~# EXPECTED 70 | 71 | begin 72 | foo = <<~STR 73 | some 74 | 75 | thing 76 | STR 77 | end 78 | 79 | #~# ORIGINAL 80 | 81 | <<~EOF 82 | foo 83 | bar 84 | EOF 85 | 86 | #~# EXPECTED 87 | 88 | <<~EOF 89 | foo 90 | bar 91 | EOF 92 | 93 | #~# ORIGINAL 94 | 95 | <<~EOF 96 | #{1} 97 | #{2} 98 | bar 99 | baz 100 | EOF 101 | 102 | #~# EXPECTED 103 | 104 | <<~EOF 105 | #{1} 106 | #{2} 107 | bar 108 | baz 109 | EOF 110 | 111 | #~# ORIGINAL 112 | 113 | <<~EOF 114 | #{1} 115 | #{2} 116 | bar 117 | baz 118 | EOF 119 | 120 | #~# EXPECTED 121 | 122 | <<~EOF 123 | #{1} 124 | #{2} 125 | bar 126 | baz 127 | EOF 128 | 129 | #~# ORIGINAL 130 | 131 | <<~EOF 132 | #{1} 133 | foo 134 | #{2} 135 | bar 136 | #{3} 137 | baz 138 | EOF 139 | 140 | #~# EXPECTED 141 | 142 | <<~EOF 143 | #{1} 144 | foo 145 | #{2} 146 | bar 147 | #{3} 148 | baz 149 | EOF 150 | 151 | #~# ORIGINAL 152 | 153 | <<~EOF 154 | #{1} 155 | foo 156 | #{2} 157 | bar 158 | #{3} 159 | baz 160 | EOF 161 | 162 | #~# EXPECTED 163 | 164 | <<~EOF 165 | #{1} 166 | foo 167 | #{2} 168 | bar 169 | #{3} 170 | baz 171 | EOF 172 | 173 | #~# ORIGINAL 174 | 175 | begin 176 | <<~EOF 177 | foo 178 | bar 179 | EOF 180 | end 181 | 182 | #~# EXPECTED 183 | 184 | begin 185 | <<~EOF 186 | foo 187 | bar 188 | EOF 189 | end 190 | 191 | #~# ORIGINAL heredoc_squiggly_no_leading_space 192 | 193 | <<~EOF 194 | a 195 | EOF 196 | 197 | #~# EXPECTED 198 | 199 | <<~EOF 200 | a 201 | EOF 202 | 203 | #~# ORIGINAL heredoc_squiggly_extra_spaces 204 | 205 | <<~EOF 206 | #{1} #{2} 207 | EOF 208 | 209 | #~# EXPECTED 210 | 211 | <<~EOF 212 | #{1} #{2} 213 | EOF 214 | 215 | #~# ORIGINAL heredoc_squiggly_extra_spaces_2 216 | 217 | <<~EOF 218 | #{1} #{2} 219 | EOF 220 | 221 | #~# EXPECTED 222 | 223 | <<~EOF 224 | #{1} #{2} 225 | EOF 226 | 227 | #~# ORIGINAL heredoc_squiggly_extra_spaces_3 228 | 229 | <<~EOF 230 | #{1}#{2} 231 | EOF 232 | 233 | #~# EXPECTED 234 | 235 | <<~EOF 236 | #{1}#{2} 237 | EOF 238 | 239 | #~# ORIGINAL heredoc_squiggly_extra_spaces_4 240 | 241 | <<~EOF 242 | #{1}#{2} 243 | EOF 244 | 245 | #~# EXPECTED 246 | 247 | <<~EOF 248 | #{1}#{2} 249 | EOF 250 | 251 | #~# ORIGINAL heredoc_squiggly_extra_spaces_5 252 | 253 | <<~EOF 254 | #{1} 255 | #{2} 256 | EOF 257 | 258 | #~# EXPECTED 259 | 260 | <<~EOF 261 | #{1} 262 | #{2} 263 | EOF 264 | 265 | #~# ORIGINAL heredoc_squiggly_extra_spaces_6 266 | 267 | <<~EOF 268 | #{1} 269 | #{2} 270 | EOF 271 | 272 | #~# EXPECTED 273 | 274 | <<~EOF 275 | #{1} 276 | #{2} 277 | EOF 278 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/string_literal_concatenation.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | "foo" "bar" 4 | 5 | #~# EXPECTED 6 | 7 | "foo" "bar" 8 | 9 | #~# ORIGINAL 10 | 11 | "foo" \ 12 | "bar" 13 | 14 | #~# EXPECTED 15 | 16 | "foo" \ 17 | "bar" 18 | 19 | #~# ORIGINAL 20 | 21 | x 1, "foo" \ 22 | "bar" 23 | 24 | #~# EXPECTED 25 | 26 | x 1, "foo" \ 27 | "bar" 28 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/string_literals.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL single_quote_string_literal 2 | 3 | 'hello' 4 | 5 | #~# EXPECTED 6 | 7 | "hello" 8 | 9 | #~# ORIGINAL double_quote_string_literal 10 | 11 | "hello" 12 | 13 | #~# EXPECTED 14 | 15 | "hello" 16 | 17 | #~# ORIGINAL percent_q_string_literal 18 | 19 | "hello" 20 | 21 | #~# EXPECTED 22 | 23 | "hello" 24 | 25 | #~# ORIGINAL percent_string_literal 26 | 27 | "\n" 28 | 29 | #~# EXPECTED 30 | 31 | "\n" 32 | 33 | #~# ORIGINAL percent_string_literal_1 34 | 35 | "hello #{1} foo" 36 | 37 | #~# EXPECTED 38 | 39 | "hello #{1} foo" 40 | 41 | #~# ORIGINAL percent_string_literal_2 42 | 43 | "hello #{ 1 } foo" 44 | 45 | #~# EXPECTED 46 | 47 | "hello #{1} foo" 48 | 49 | #~# ORIGINAL percent_string_literal_3 50 | 51 | "hello #{ 52 | 1} foo" 53 | 54 | #~# EXPECTED 55 | 56 | "hello #{1} foo" 57 | 58 | #~# ORIGINAL percent_string_literal_4 59 | 60 | "#@foo" 61 | 62 | #~# EXPECTED 63 | 64 | "#@foo" 65 | 66 | #~# ORIGINAL percent_string_literal_5 67 | 68 | "#@@foo" 69 | 70 | #~# EXPECTED 71 | 72 | "#@@foo" 73 | 74 | #~# ORIGINAL percent_string_literal_6 75 | 76 | "#$foo" 77 | 78 | #~# EXPECTED 79 | 80 | "#$foo" 81 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/suffix_if.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | 1 if 2 4 | 5 | #~# EXPECTED 6 | 7 | 1 if 2 8 | 9 | #~# ORIGINAL 10 | 11 | 1 unless 2 12 | 13 | #~# EXPECTED 14 | 15 | 1 unless 2 16 | 17 | #~# ORIGINAL 18 | 19 | 1 rescue 2 20 | 21 | #~# EXPECTED 22 | 23 | 1 rescue 2 24 | 25 | #~# ORIGINAL 26 | 27 | 1 while 2 28 | 29 | #~# EXPECTED 30 | 31 | 1 while 2 32 | 33 | #~# ORIGINAL 34 | 35 | 1 until 2 36 | 37 | #~# EXPECTED 38 | 39 | 1 until 2 40 | 41 | #~# ORIGINAL 42 | 43 | x.y rescue z 44 | 45 | #~# EXPECTED 46 | 47 | x.y rescue z 48 | 49 | #~# ORIGINAL 50 | 51 | 1 if 2 52 | 53 | #~# EXPECTED 54 | 55 | 1 if 2 56 | 57 | #~# ORIGINAL 58 | 59 | foo bar(1) if 2 60 | 61 | #~# EXPECTED 62 | 63 | foo bar(1) if 2 64 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/suffix_rescue.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | URI(string) rescue return 4 | 5 | #~# EXPECTED 6 | 7 | URI(string) rescue return 8 | 9 | #~# ORIGINAL 10 | 11 | URI(string) while return 12 | 13 | #~# EXPECTED 14 | 15 | URI(string) while return 16 | 17 | #~# ORIGINAL 18 | 19 | URI(string) if return 20 | 21 | #~# EXPECTED 22 | 23 | URI(string) if return 24 | 25 | #~# ORIGINAL 26 | 27 | URI(string) unless return 28 | 29 | #~# EXPECTED 30 | 31 | URI(string) unless return 32 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/super.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL super 2 | 3 | super 4 | 5 | #~# EXPECTED 6 | 7 | super 8 | 9 | #~# ORIGINAL 10 | 11 | super 1 12 | 13 | #~# EXPECTED 14 | 15 | super 1 16 | 17 | #~# ORIGINAL 18 | 19 | super 1, 20 | 2 21 | 22 | #~# EXPECTED 23 | 24 | super 1, 25 | 2 26 | 27 | #~# ORIGINAL 28 | 29 | super( 1 ) 30 | 31 | #~# EXPECTED 32 | 33 | super(1) 34 | 35 | #~# ORIGINAL 36 | 37 | super( 1 , 2 ) 38 | 39 | #~# EXPECTED 40 | 41 | super(1, 2) 42 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/symbol_literals.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | :foo 4 | 5 | #~# EXPECTED 6 | 7 | :foo 8 | 9 | #~# ORIGINAL 10 | 11 | :"foo" 12 | 13 | #~# EXPECTED 14 | 15 | :"foo" 16 | 17 | #~# ORIGINAL 18 | 19 | :"foo#{1}" 20 | 21 | #~# EXPECTED 22 | 23 | :"foo#{1}" 24 | 25 | #~# ORIGINAL 26 | 27 | :* 28 | 29 | #~# EXPECTED 30 | 31 | :* 32 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/ternaries.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | 1 ? 2 : 3 4 | 5 | #~# EXPECTED 6 | 7 | 1 ? 2 : 3 8 | 9 | #~# ORIGINAL 10 | 11 | 1 ? 12 | 2 : 3 13 | 14 | #~# EXPECTED 15 | 16 | 1 ? 17 | 2 : 3 18 | 19 | #~# ORIGINAL 20 | 21 | 1 ? 2 : 22 | 3 23 | 24 | #~# EXPECTED 25 | 26 | 1 ? 2 : 27 | 3 28 | 29 | #~# ORIGINAL 30 | 31 | 1?2:3 32 | 33 | #~# EXPECTED 34 | 35 | 1 ? 2 : 3 36 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/trailing_commas.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | #~# trailing_commas: true 3 | 4 | [ 5 | 1, 6 | 2, 7 | ] 8 | 9 | #~# EXPECTED 10 | 11 | [ 12 | 1, 13 | 2, 14 | ] 15 | 16 | #~# ORIGINAL 17 | #~# trailing_commas: false 18 | 19 | [ 20 | 1, 21 | 2, 22 | ] 23 | 24 | #~# EXPECTED 25 | 26 | [ 27 | 1, 28 | 2 29 | ] 30 | 31 | #~# ORIGINAL 32 | #~# trailing_commas: true 33 | 34 | [ 35 | 1, 36 | 2 37 | ] 38 | 39 | #~# EXPECTED 40 | 41 | [ 42 | 1, 43 | 2, 44 | ] 45 | 46 | #~# ORIGINAL 47 | #~# trailing_commas: false 48 | 49 | [ 50 | 1, 51 | 2 52 | ] 53 | 54 | #~# EXPECTED 55 | 56 | [ 57 | 1, 58 | 2 59 | ] 60 | 61 | #~# ORIGINAL 62 | #~# trailing_commas: true 63 | 64 | { 65 | foo: 1, 66 | bar: 2, 67 | } 68 | 69 | #~# EXPECTED 70 | 71 | { 72 | foo: 1, 73 | bar: 2, 74 | } 75 | 76 | #~# ORIGINAL 77 | #~# trailing_commas: false 78 | 79 | { 80 | foo: 1, 81 | bar: 2, 82 | } 83 | 84 | #~# EXPECTED 85 | 86 | { 87 | foo: 1, 88 | bar: 2 89 | } 90 | 91 | #~# ORIGINAL 92 | #~# trailing_commas: true 93 | 94 | { 95 | foo: 1, 96 | bar: 2 97 | } 98 | 99 | #~# EXPECTED 100 | 101 | { 102 | foo: 1, 103 | bar: 2, 104 | } 105 | 106 | #~# ORIGINAL 107 | #~# trailing_commas: false 108 | 109 | { 110 | foo: 1, 111 | bar: 2 112 | } 113 | 114 | #~# EXPECTED 115 | 116 | { 117 | foo: 1, 118 | bar: 2 119 | } 120 | 121 | #~# ORIGINAL 122 | #~# trailing_commas: true 123 | 124 | foo( 125 | one: 1, 126 | two: 2, 127 | three: 3, 128 | ) 129 | 130 | #~# EXPECTED 131 | 132 | foo( 133 | one: 1, 134 | two: 2, 135 | three: 3, 136 | ) 137 | 138 | #~# ORIGINAL 139 | #~# trailing_commas: false 140 | 141 | foo( 142 | one: 1, 143 | two: 2, 144 | three: 3, 145 | ) 146 | 147 | #~# EXPECTED 148 | 149 | foo( 150 | one: 1, 151 | two: 2, 152 | three: 3 153 | ) 154 | 155 | #~# ORIGINAL 156 | #~# trailing_commas: true 157 | 158 | foo( 159 | one: 1, 160 | two: 2, 161 | three: 3 162 | ) 163 | 164 | #~# EXPECTED 165 | 166 | foo( 167 | one: 1, 168 | two: 2, 169 | three: 3, 170 | ) 171 | 172 | #~# ORIGINAL 173 | #~# trailing_commas: false 174 | 175 | foo( 176 | one: 1, 177 | two: 2, 178 | three: 3 179 | ) 180 | 181 | #~# EXPECTED 182 | 183 | foo( 184 | one: 1, 185 | two: 2, 186 | three: 3 187 | ) 188 | 189 | #~# ORIGINAL 190 | #~# trailing_commas: true 191 | 192 | foo( 193 | one: 1) 194 | 195 | #~# EXPECTED 196 | 197 | foo( 198 | one: 1, 199 | ) 200 | 201 | #~# ORIGINAL 202 | #~# trailing_commas: false 203 | 204 | foo( 205 | one: 1) 206 | 207 | #~# EXPECTED 208 | 209 | foo( 210 | one: 1 211 | ) 212 | 213 | #~# ORIGINAL 214 | #~# trailing_commas: true 215 | 216 | foo( 217 | one: 1,) 218 | 219 | #~# EXPECTED 220 | 221 | foo( 222 | one: 1, 223 | ) 224 | 225 | #~# ORIGINAL 226 | #~# trailing_commas: false 227 | 228 | foo( 229 | one: 1,) 230 | 231 | #~# EXPECTED 232 | 233 | foo( 234 | one: 1 235 | ) 236 | 237 | #~# ORIGINAL 238 | #~# trailing_commas: true 239 | 240 | [ 241 | 1 , 2 ] 242 | 243 | #~# EXPECTED 244 | 245 | [ 246 | 1, 2, 247 | ] 248 | 249 | #~# ORIGINAL 250 | #~# trailing_commas: true 251 | 252 | [ 253 | 1 , 2, ] 254 | 255 | #~# EXPECTED 256 | 257 | [ 258 | 1, 2, 259 | ] 260 | 261 | #~# ORIGINAL 262 | #~# trailing_commas: true 263 | 264 | [ 265 | 1 , 2 , 266 | 3 , 4 ] 267 | 268 | #~# EXPECTED 269 | 270 | [ 271 | 1, 2, 272 | 3, 4, 273 | ] 274 | 275 | #~# ORIGINAL 276 | #~# trailing_commas: true 277 | 278 | [ 279 | 1 , 280 | 2] 281 | 282 | #~# EXPECTED 283 | 284 | [ 285 | 1, 286 | 2, 287 | ] 288 | 289 | #~# ORIGINAL 290 | #~# trailing_commas: true 291 | 292 | [ # comment 293 | 1 , 294 | 2] 295 | 296 | #~# EXPECTED 297 | 298 | [ # comment 299 | 1, 300 | 2, 301 | ] 302 | 303 | #~# ORIGINAL 304 | #~# trailing_commas: true 305 | 306 | [ 307 | 1 , # comment 308 | 2] 309 | 310 | #~# EXPECTED 311 | 312 | [ 313 | 1, # comment 314 | 2, 315 | ] 316 | 317 | #~# ORIGINAL 318 | #~# trailing_commas: true 319 | 320 | [ 1 , 321 | 2, 3, 322 | 4 ] 323 | 324 | #~# EXPECTED 325 | 326 | [1, 327 | 2, 3, 328 | 4] 329 | 330 | #~# ORIGINAL 331 | #~# trailing_commas: true 332 | 333 | [ 1 , 334 | 2, 3, 335 | 4, ] 336 | 337 | #~# EXPECTED 338 | 339 | [1, 340 | 2, 3, 341 | 4] 342 | 343 | #~# ORIGINAL 344 | #~# trailing_commas: true 345 | 346 | [ 1 , 347 | 2, 3, 348 | 4, 349 | ] 350 | 351 | #~# EXPECTED 352 | 353 | [1, 354 | 2, 3, 355 | 4] 356 | 357 | #~# ORIGINAL 358 | #~# trailing_commas: true 359 | 360 | [ 1 , 361 | 2, 3, 362 | 4, # foo 363 | ] 364 | 365 | #~# EXPECTED 366 | 367 | [1, 368 | 2, 3, 369 | 4 # foo 370 | ] 371 | 372 | #~# ORIGINAL 373 | #~# trailing_commas: true 374 | 375 | begin 376 | [ 377 | 1 , 2 ] 378 | end 379 | 380 | #~# EXPECTED 381 | 382 | begin 383 | [ 384 | 1, 2, 385 | ] 386 | end 387 | 388 | #~# ORIGINAL 389 | #~# trailing_commas: true 390 | 391 | [ 392 | 1 # foo 393 | ] 394 | 395 | #~# EXPECTED 396 | 397 | [ 398 | 1, # foo 399 | ] 400 | 401 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/unary_operators.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | - x 4 | 5 | #~# EXPECTED 6 | 7 | -x 8 | 9 | #~# ORIGINAL 10 | 11 | + x 12 | 13 | #~# EXPECTED 14 | 15 | +x 16 | 17 | #~# ORIGINAL 18 | 19 | +x 20 | 21 | #~# EXPECTED 22 | 23 | +x 24 | 25 | #~# ORIGINAL 26 | 27 | +(x) 28 | 29 | #~# EXPECTED 30 | 31 | +(x) 32 | 33 | #~# ORIGINAL 34 | 35 | + (x) 36 | 37 | #~# EXPECTED 38 | 39 | +(x) 40 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/undef.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | undef foo 4 | 5 | #~# EXPECTED 6 | 7 | undef foo 8 | 9 | #~# ORIGINAL 10 | 11 | undef foo , bar 12 | 13 | #~# EXPECTED 14 | 15 | undef foo, bar 16 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/unless.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | unless 1 4 | 2 5 | end 6 | 7 | #~# EXPECTED 8 | 9 | unless 1 10 | 2 11 | end 12 | 13 | #~# ORIGINAL 14 | 15 | unless 1 16 | 2 17 | else 18 | end 19 | 20 | #~# EXPECTED 21 | 22 | unless 1 23 | 2 24 | else 25 | end 26 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/until.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | until 1 ; end 4 | 5 | #~# EXPECTED 6 | 7 | until 1; end 8 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/variables.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | a = 1 4 | a 5 | 6 | #~# EXPECTED 7 | 8 | a = 1 9 | a 10 | 11 | #~# ORIGINAL 12 | 13 | @foo 14 | 15 | #~# EXPECTED 16 | 17 | @foo 18 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/visibility_indent.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | private 4 | 5 | foo 6 | bar 7 | 8 | #~# EXPECTED 9 | 10 | private 11 | 12 | foo 13 | bar 14 | 15 | #~# ORIGINAL 16 | 17 | private 18 | 19 | foo 20 | bar 21 | 22 | #~# EXPECTED 23 | 24 | private 25 | 26 | foo 27 | bar 28 | 29 | #~# ORIGINAL 30 | 31 | private 32 | 33 | foo 34 | bar 35 | 36 | protected 37 | 38 | baz 39 | 40 | #~# EXPECTED 41 | 42 | private 43 | 44 | foo 45 | bar 46 | 47 | protected 48 | 49 | baz 50 | 51 | #~# ORIGINAL 52 | 53 | private 54 | 55 | foo 56 | bar 57 | 58 | protected 59 | 60 | baz 61 | 62 | #~# EXPECTED 63 | 64 | private 65 | 66 | foo 67 | bar 68 | 69 | protected 70 | 71 | baz 72 | 73 | #~# ORIGINAL 74 | 75 | class Foo 76 | private 77 | 78 | foo 79 | end 80 | 81 | #~# EXPECTED 82 | 83 | class Foo 84 | private 85 | 86 | foo 87 | end 88 | 89 | #~# ORIGINAL 90 | 91 | class << self 92 | private 93 | 94 | foo 95 | end 96 | 97 | #~# EXPECTED 98 | 99 | class << self 100 | private 101 | 102 | foo 103 | end 104 | 105 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/visibility_markers.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | private 4 | # comment 5 | 1 6 | 7 | #~# EXPECTED 8 | 9 | private 10 | 11 | # comment 12 | 1 13 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/while.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL 2 | 3 | while 1 ; end 4 | 5 | #~# EXPECTED 6 | 7 | while 1; end 8 | 9 | #~# ORIGINAL 10 | 11 | while 1 ; 2 ; end 12 | 13 | #~# EXPECTED 14 | 15 | while 1; 2; end 16 | 17 | #~# ORIGINAL 18 | 19 | while 1 20 | end 21 | 22 | #~# EXPECTED 23 | 24 | while 1 25 | end 26 | 27 | #~# ORIGINAL 28 | 29 | while 1 30 | 2 31 | 3 32 | end 33 | 34 | #~# EXPECTED 35 | 36 | while 1 37 | 2 38 | 3 39 | end 40 | 41 | #~# ORIGINAL 42 | 43 | while 1 # foo 44 | 2 45 | 3 46 | end 47 | 48 | #~# EXPECTED 49 | 50 | while 1 # foo 51 | 2 52 | 3 53 | end 54 | 55 | #~# ORIGINAL 56 | 57 | while 1 do end 58 | 59 | #~# EXPECTED 60 | 61 | while 1 do end 62 | 63 | #~# ORIGINAL 64 | 65 | while 1 do 2 end 66 | 67 | #~# EXPECTED 68 | 69 | while 1 do 2 end 70 | 71 | #~# ORIGINAL 72 | 73 | begin 74 | while 1 do 2 end 75 | end 76 | 77 | #~# EXPECTED 78 | 79 | begin 80 | while 1 do 2 end 81 | end 82 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_source_specs/yield.rb.spec: -------------------------------------------------------------------------------- 1 | #~# ORIGINAL yield 2 | 3 | yield 4 | 5 | #~# EXPECTED 6 | 7 | yield 8 | 9 | #~# ORIGINAL 10 | 11 | yield 1 12 | 13 | #~# EXPECTED 14 | 15 | yield 1 16 | 17 | #~# ORIGINAL 18 | 19 | yield 1 , 2 20 | 21 | #~# EXPECTED 22 | 23 | yield 1, 2 24 | 25 | #~# ORIGINAL 26 | 27 | yield 1 , 28 | 2 29 | 30 | #~# EXPECTED 31 | 32 | yield 1, 33 | 2 34 | 35 | #~# ORIGINAL 36 | 37 | yield( 1 , 2 ) 38 | 39 | #~# EXPECTED 40 | 41 | yield(1, 2) 42 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/formatter_spec.rb: -------------------------------------------------------------------------------- 1 | require "spec_helper" 2 | require "fileutils" 3 | 4 | VERSION = Gem::Version.new(RUBY_VERSION) 5 | FILE_PATH = Pathname.new(File.dirname(__FILE__)) 6 | 7 | def assert_source_specs(source_spec_path) 8 | relative_path = Pathname.new(source_spec_path).relative_path_from(FILE_PATH).to_s 9 | 10 | describe relative_path do 11 | tests = [] 12 | current_test = nil 13 | 14 | File.foreach(source_spec_path).with_index do |line, index| 15 | begin 16 | case 17 | when line =~ /^#~# ORIGINAL ?([\w\s]+)$/ 18 | # save old test 19 | tests.push current_test if current_test 20 | 21 | # start a new test 22 | 23 | name = $~[1].strip 24 | name = "unnamed test" if name.empty? 25 | 26 | current_test = { 27 | name: name, 28 | line: index + 1, 29 | options: {}, 30 | original: "", 31 | source: source_spec_path, 32 | } 33 | when !current_test 34 | next 35 | when line =~ /^#~# EXPECTED$/ 36 | current_test[:expected] = "" 37 | when line =~ /^#~# PENDING$/ 38 | current_test[:pending] = true 39 | when line =~ /^#~# ERRORS$/ 40 | current_test[:errors] = [] 41 | when line =~ /^#~# (.+)$/ 42 | current_test[:options] = eval("{ #{$~[1]} }") 43 | when current_test[:errors] 44 | # Remove any quotes around the string (just to fix syntax highlighting in VS Code) 45 | if line.strip != "" 46 | current_test[:errors] << line 47 | end 48 | when current_test[:expected] 49 | current_test[:expected] += line 50 | when current_test[:original] 51 | current_test[:original] += line 52 | end 53 | rescue StandardError => ex 54 | puts "Error in #{source_spec_path}:" 55 | raise ex 56 | end 57 | end 58 | 59 | tests.concat([current_test]).each do |test| 60 | it "formats #{test[:name]} (line: #{test[:line]})" do 61 | pending if test[:pending] 62 | options = test[:options] || {} 63 | options[:store_logs] = true 64 | 65 | formatter = described_class.new( 66 | test[:original], 67 | test[:source], 68 | File.dirname(test[:source]), 69 | **options, 70 | ) 71 | expect(formatter.logs).to eq [] 72 | formatter.format 73 | formatted = formatter.result 74 | expected = test[:expected].rstrip + "\n" 75 | expect(formatted).to eq(expected) 76 | 77 | if test[:errors] 78 | all_logs = formatter.logs.join("\n") 79 | test[:errors].each do |expected_error| 80 | if expected_error.match?(/^["']|["']$/) 81 | error_string = expected_error.strip.gsub(/^["']|["']$/, "") 82 | elsif expected_error.match?(/^\/.*\/$/) 83 | error_regex = Regexp.new(expected_error.strip.gsub(/^\/|\/$/, ""), Regexp::MULTILINE) 84 | else 85 | error_string = expected_error.strip 86 | end 87 | if error_string 88 | expect(all_logs).to include(error_string) 89 | else 90 | expect(all_logs).to match(error_regex) 91 | end 92 | end 93 | end 94 | 95 | # Ruby => Crystal can't be idempotent! 96 | # (Surprisingly, this test was passing until I added &: => &. for the block shorthand) 97 | # idempotency_check = described_class.format(formatted, "example_dir/example_file.rb", "example_dir", **options) 98 | # expect(idempotency_check).to eq(formatted) 99 | end 100 | end 101 | end 102 | end 103 | 104 | def assert_format(code, expected = code, **options) 105 | expected = expected.rstrip + "\n" 106 | 107 | line = caller_locations[0].lineno 108 | 109 | ex = it "formats #{code.inspect} (line: #{line})" do 110 | actual = RubyCrystalCodemod.format(code, "example_dir/example_file.rb", "example_dir", **options) 111 | if actual != expected 112 | fail "Expected\n\n~~~\n#{code}\n~~~\nto format to:\n\n~~~\n#{expected}\n~~~\n\nbut got:\n\n~~~\n#{actual}\n~~~\n\n diff = #{expected.inspect}\n #{actual.inspect}" 113 | end 114 | 115 | second = RubyCrystalCodemod.format(actual, "example_dir/example_file.rb", "example_dir", **options) 116 | if second != actual 117 | fail "Idempotency check failed. Expected\n\n~~~\n#{actual}\n~~~\nto format to:\n\n~~~\n#{actual}\n~~~\n\nbut got:\n\n~~~\n#{second}\n~~~\n\n diff = #{second.inspect}\n #{actual.inspect}" 118 | end 119 | end 120 | 121 | # This is so we can do `rspec spec/ruby_crystal_codemod_spec.rb:26` and 122 | # refer to line numbers for assert_format 123 | ex.metadata[:line_number] = line 124 | end 125 | 126 | RSpec.describe RubyCrystalCodemod::Formatter do 127 | source_specs = Dir[File.join(FILE_PATH, "/formatter_source_specs/*")] 128 | source_specs += Dir[File.join(FILE_PATH, "/formatter_crystal_specs/*")] 129 | 130 | source_specs.each do |source_spec| 131 | assert_source_specs(source_spec) if File.file?(source_spec) 132 | end 133 | 134 | if VERSION >= Gem::Version.new("2.6") 135 | Dir[File.join(FILE_PATH, "/formatter_source_specs/2.6/*")].each do |source_specs| 136 | assert_source_specs(source_specs) if File.file?(source_specs) 137 | end 138 | end 139 | 140 | # Empty 141 | describe "empty" do 142 | assert_format "", "" 143 | assert_format " ", " " 144 | assert_format "\n", "" 145 | assert_format "\n\n", "" 146 | assert_format "\n\n\n", "" 147 | end 148 | end 149 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/logger_spec.rb: -------------------------------------------------------------------------------- 1 | require "spec_helper" 2 | 3 | RSpec.describe RubyCrystalCodemod::Logger do 4 | subject { described_class.new(level) } 5 | 6 | let(:level) { :debug } 7 | 8 | it "logs all levels" do 9 | expect { 10 | subject.log("a") 11 | subject.debug("b") 12 | }.to output("a\nb\n").to_stdout 13 | 14 | expect { 15 | subject.warn("c") 16 | subject.error("d") 17 | }.to output("c\nd\n").to_stderr 18 | end 19 | 20 | context "when set to log" do 21 | let(:level) { :log } 22 | 23 | it "logs all levels except debug" do 24 | expect { 25 | subject.log("a") 26 | subject.debug("b") 27 | }.to output("a\n").to_stdout 28 | 29 | expect { 30 | subject.warn("c") 31 | subject.error("d") 32 | }.to output("c\nd\n").to_stderr 33 | end 34 | end 35 | 36 | context "when set to warn" do 37 | let(:level) { :warn } 38 | 39 | it "logs only warn and error levels" do 40 | expect { 41 | subject.log("a") 42 | subject.debug("b") 43 | }.to output("").to_stdout 44 | 45 | expect { 46 | subject.warn("c") 47 | subject.error("d") 48 | }.to output("c\nd\n").to_stderr 49 | end 50 | end 51 | 52 | context "when set to error" do 53 | let(:level) { :error } 54 | 55 | it "logs only error levels" do 56 | expect { 57 | subject.log("a") 58 | subject.debug("b") 59 | }.to output("").to_stdout 60 | 61 | expect { 62 | subject.warn("c") 63 | subject.error("d") 64 | }.to output("d\n").to_stderr 65 | end 66 | end 67 | 68 | context "when set to silent" do 69 | let(:level) { :silent } 70 | 71 | it "does not log anything" do 72 | expect { 73 | subject.log("a") 74 | subject.debug("b") 75 | }.to output("").to_stdout 76 | 77 | expect { 78 | subject.warn("c") 79 | subject.error("d") 80 | }.to output("").to_stderr 81 | end 82 | end 83 | end 84 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/post_process_crystal_spec.rb: -------------------------------------------------------------------------------- 1 | require "spec_helper" 2 | 3 | RSpec.describe PostProcessCrystal do 4 | it "mocks the call to File.read_lines" do 5 | allow(PostProcessCrystal).to receive(:file_read_lines).with("example_file").and_return([ 6 | "hey, world!", 7 | "how's it hanging", 8 | ]) 9 | 10 | ppc = PostProcessCrystal.new("example_file") 11 | ppc.post_process_crystal 12 | expect(ppc.contents).to eq("hey, world!\nhow's it hanging\n") 13 | end 14 | 15 | it "removes any content between #~# BEGIN ruby and #~# END ruby" do 16 | allow(PostProcessCrystal).to receive(:file_read_lines) 17 | .with("example_file") 18 | .and_return( 19 | <<-CODE.lines.map(&:chomp) 20 | def foo 21 | #~# BEGIN ruby 22 | return 234 23 | #~# END ruby 24 | 123 25 | end 26 | #~# BEGIN ruby 27 | puts "Code called from Ruby!" 28 | # comment should be removed 29 | #~# END ruby 30 | 31 | puts foo 32 | CODE 33 | 34 | 35 | ) 36 | 37 | ppc = PostProcessCrystal.new("example_file") 38 | ppc.post_process_crystal 39 | expect(ppc.contents).to eq( 40 | <<-CODE 41 | def foo 42 | 123 43 | end 44 | 45 | puts foo 46 | CODE 47 | 48 | 49 | ) 50 | end 51 | 52 | it "uncomments any content between #~# BEGIN crystal and #~# END crystal" do 53 | allow(PostProcessCrystal).to receive(:file_read_lines).with("example_file").and_return( 54 | <<-CODE.lines.map(&:chomp) 55 | def foo 56 | 123 57 | #~# BEGIN crystal 58 | # return 456 59 | #~# END crystal 60 | end 61 | #~# BEGIN crystal 62 | # puts "Code called from Crystal!" 63 | # # comment should be present 64 | #~# END crystal 65 | puts foo 66 | CODE 67 | 68 | 69 | ) 70 | 71 | ppc = PostProcessCrystal.new("example_file") 72 | ppc.post_process_crystal 73 | expect(ppc.contents).to eq( 74 | <<-CODE 75 | def foo 76 | 123 77 | return 456 78 | end 79 | puts "Code called from Crystal!" 80 | # comment should be present 81 | puts foo 82 | CODE 83 | 84 | 85 | ) 86 | end 87 | 88 | it "removes all Ruby lines and uncomments all Crystal lines" do 89 | allow(PostProcessCrystal).to receive(:file_read_lines).with("example_file").and_return( 90 | <<-CODE.lines.map(&:chomp) 91 | class Foo 92 | property :foo, :bar 93 | 94 | #~# BEGIN ruby 95 | def initialize(foo, bar) 96 | @foo = foo 97 | @bar = bar 98 | end 99 | #~# END ruby 100 | #~# BEGIN crystal 101 | # @foo : Int32 102 | # @bar : Int32 103 | # def initialize(@foo: Int32, @bar : Int32) 104 | # end 105 | #~# END crystal 106 | end 107 | CODE 108 | 109 | 110 | ) 111 | 112 | ppc = PostProcessCrystal.new("example_file") 113 | ppc.post_process_crystal 114 | # NOTE: This is a post-processing step. The rufo formatting code 115 | # must run before this, and will translate attr_accessor into property, etc. 116 | expect(ppc.contents).to eq( 117 | <<-CODE 118 | class Foo 119 | property :foo, :bar 120 | 121 | @foo : Int32 122 | @bar : Int32 123 | def initialize(@foo: Int32, @bar : Int32) 124 | end 125 | end 126 | CODE 127 | 128 | 129 | ) 130 | end 131 | end 132 | -------------------------------------------------------------------------------- /spec/lib/ruby_crystal_codemod/settings_spec.rb: -------------------------------------------------------------------------------- 1 | require "spec_helper" 2 | 3 | RSpec.describe RubyCrystalCodemod::Settings do 4 | class TestClass 5 | include RubyCrystalCodemod::Settings 6 | end 7 | 8 | subject { TestClass.new } 9 | 10 | describe "settings" do 11 | it "does not output any warnings for expected settings" do 12 | expect { 13 | subject.init_settings(parens_in_def: :yes) 14 | }.to output("").to_stderr 15 | end 16 | 17 | it "outputs a warning for invalid config value" do 18 | exp_msg = "Invalid value for parens_in_def: :fake. Valid values " \ 19 | "are: :yes, :dynamic\n" 20 | expect { 21 | subject.init_settings(parens_in_def: :fake) 22 | }.to output(exp_msg).to_stderr 23 | end 24 | 25 | it "outputs a warning for invalid config option" do 26 | exp_msg = "Invalid config option=fake\n" 27 | expect { 28 | subject.init_settings(fake: :fake_too) 29 | }.to output(exp_msg).to_stderr 30 | end 31 | end 32 | end 33 | -------------------------------------------------------------------------------- /spec/source_specs/empty.rb.spec: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DocSpring/ruby_crystal_codemod/f7ed800c83c087f4c299a4bfe0679d3f932d5b62/spec/source_specs/empty.rb.spec -------------------------------------------------------------------------------- /spec/spec_helper.rb: -------------------------------------------------------------------------------- 1 | require "bundler/setup" 2 | require "ruby_crystal_codemod" 3 | require "pp" 4 | require "byebug" 5 | 6 | RSpec.configure do |config| 7 | # Enable flags like --only-failures and --next-failure 8 | config.example_status_persistence_file_path = ".rspec_status" 9 | 10 | # Disable RSpec exposing methods globally on `Module` and `main` 11 | config.disable_monkey_patching! 12 | 13 | config.expect_with :rspec do |c| 14 | c.syntax = :expect 15 | end 16 | end 17 | -------------------------------------------------------------------------------- /util/post_process_crystal/shard.lock: -------------------------------------------------------------------------------- 1 | version: 1.0 2 | shards: 3 | mocks: 4 | github: DocSpring/mocks.cr 5 | commit: b098c6ae8a34509df88baf4d3664471cd223bdfe 6 | 7 | singleton: 8 | github: waterlink/singleton.cr 9 | version: 1.0.0 10 | 11 | spectator: 12 | gitlab: arctic-fox/spectator 13 | version: 0.8.3 14 | 15 | -------------------------------------------------------------------------------- /util/post_process_crystal/shard.yml: -------------------------------------------------------------------------------- 1 | name: process_comments 2 | version: 0.1.0 3 | 4 | development_dependencies: 5 | spectator: 6 | gitlab: arctic-fox/spectator 7 | mocks: 8 | github: DocSpring/mocks.cr 9 | branch: updates_for_0.31.1 10 | 11 | license: MIT 12 | -------------------------------------------------------------------------------- /util/post_process_crystal/spec/fixtures/example.rb: -------------------------------------------------------------------------------- 1 | class Foo 2 | attr_accessor :foo 3 | 4 | #~# BEGIN ruby 5 | def initialize(foo) 6 | @foo = foo 7 | end 8 | #~# END ruby 9 | #~# BEGIN crystal 10 | # @foo : Int32 11 | # def initialize(@foo: Int32); end 12 | #~# END crystal 13 | end 14 | -------------------------------------------------------------------------------- /util/post_process_crystal/spec/post_process_crystal_spec.cr: -------------------------------------------------------------------------------- 1 | require "./spec_helper" 2 | 3 | Mocks.create_mock PostProcessCrystal do 4 | mock self.file_read_lines(filename) 5 | end 6 | 7 | Spectator.describe PostProcessCrystal do 8 | it "mocks the call to File.read_lines" do 9 | allow(PostProcessCrystal).to receive(self.file_read_lines("example_file")).and_return([ 10 | "hey, world!", 11 | "how's it hanging" 12 | ]) 13 | 14 | ppc = PostProcessCrystal.new("example_file") 15 | ppc.post_process_crystal 16 | expect(ppc.contents).to eq("hey, world!\nhow's it hanging\n") 17 | end 18 | 19 | it "removes any content between #~# BEGIN ruby and #~# END ruby" do 20 | allow(PostProcessCrystal).to receive(self.file_read_lines("example_file")).and_return( 21 | <<-CODE.lines 22 | def foo 23 | #~# BEGIN ruby 24 | return 234 25 | #~# END ruby 26 | 123 27 | end 28 | #~# BEGIN ruby 29 | puts "Code called from Ruby!" 30 | # comment should be removed 31 | #~# END ruby 32 | 33 | puts foo 34 | CODE 35 | ) 36 | 37 | ppc = PostProcessCrystal.new("example_file") 38 | ppc.post_process_crystal 39 | expect(ppc.contents).to eq( 40 | <<-CODE 41 | def foo 42 | 123 43 | end 44 | 45 | puts foo 46 | 47 | CODE 48 | ) 49 | end 50 | 51 | it "uncomments any content between #~# BEGIN crystal and #~# END crystal" do 52 | allow(PostProcessCrystal).to receive(self.file_read_lines("example_file")).and_return( 53 | <<-CODE.lines 54 | def foo 55 | 123 56 | #~# BEGIN crystal 57 | # return 456 58 | #~# END crystal 59 | end 60 | #~# BEGIN crystal 61 | # puts "Code called from Crystal!" 62 | # # comment should be present 63 | #~# END crystal 64 | puts foo 65 | CODE 66 | ) 67 | 68 | ppc = PostProcessCrystal.new("example_file") 69 | ppc.post_process_crystal 70 | expect(ppc.contents).to eq( 71 | <<-CODE 72 | def foo 73 | 123 74 | return 456 75 | end 76 | puts "Code called from Crystal!" 77 | # comment should be present 78 | puts foo 79 | 80 | CODE 81 | ) 82 | end 83 | 84 | it "removes all Ruby lines and uncomments all Crystal lines" do 85 | allow(PostProcessCrystal).to receive(self.file_read_lines("example_file")).and_return( 86 | <<-CODE.lines 87 | class Foo 88 | property :foo, :bar 89 | 90 | #~# BEGIN ruby 91 | def initialize(foo, bar) 92 | @foo = foo 93 | @bar = bar 94 | end 95 | #~# END ruby 96 | #~# BEGIN crystal 97 | # @foo : Int32 98 | # @bar : Int32 99 | # def initialize(@foo: Int32, @bar : Int32) 100 | # end 101 | #~# END crystal 102 | end 103 | CODE 104 | ) 105 | 106 | ppc = PostProcessCrystal.new("example_file") 107 | ppc.post_process_crystal 108 | # NOTE: This is a post-processing step. The rufo formatting code 109 | # must run before this, and will translate attr_accessor into property, etc. 110 | expect(ppc.contents).to eq( 111 | <<-CODE 112 | class Foo 113 | property :foo, :bar 114 | 115 | @foo : Int32 116 | @bar : Int32 117 | def initialize(@foo: Int32, @bar : Int32) 118 | end 119 | end 120 | 121 | CODE 122 | ) 123 | end 124 | end 125 | -------------------------------------------------------------------------------- /util/post_process_crystal/spec/spec_helper.cr: -------------------------------------------------------------------------------- 1 | require "../src/post_process_crystal" 2 | require "spec" 3 | require "spectator" 4 | require "mocks/spec" 5 | -------------------------------------------------------------------------------- /util/post_process_crystal/src/command.cr: -------------------------------------------------------------------------------- 1 | require "./post_process_crystal" 2 | 3 | if ARGV.size == 0 4 | STDERR.puts "Usage: #{PROGRAM_NAME} " 5 | exit 1 6 | end 7 | 8 | ppc = PostProcessCrystal.new 9 | puts "Processing #~# BEGIN and #~# END comments..." 10 | 11 | ARGV.each_with_index do |arg, i| 12 | puts "=> Processing file: #{arg}" 13 | ppc.filename = arg 14 | ppc.post_process_crystal 15 | File.write(arg, ppc.contents) 16 | end 17 | -------------------------------------------------------------------------------- /util/post_process_crystal/src/post_process_crystal.cr: -------------------------------------------------------------------------------- 1 | class PostProcessCrystal 2 | getter :filename, :contents 3 | @filename : String 4 | @contents : String 5 | 6 | def self.file_read_lines(path) 7 | File.read_lines(path) 8 | end 9 | 10 | def initialize(filename : String = "") 11 | @filename = filename 12 | @contents = "" 13 | end 14 | 15 | def filename=(filename) 16 | self.initialize(filename) 17 | end 18 | 19 | def post_process_crystal 20 | @contents = String.build do |io| 21 | lines = self.class.file_read_lines(@filename) 22 | 23 | current_lang = nil 24 | regex = /^\s*# ?~# (?(BEGIN|END)) (?(ruby|crystal))/ 25 | uncomment_regex = /^(?\s*)# ?/ 26 | lines.each do |line| 27 | matches = regex.match(line) 28 | if matches 29 | case matches["action"] 30 | when "BEGIN" 31 | current_lang = matches["lang"] 32 | when "END" 33 | current_lang = nil 34 | end 35 | next 36 | end 37 | case current_lang 38 | when "ruby" 39 | next 40 | when "crystal" 41 | line = line.sub(uncomment_regex, "\\k") 42 | end 43 | 44 | io << line << "\n" 45 | end 46 | end 47 | end 48 | end 49 | --------------------------------------------------------------------------------