atom / language-ruby

Ruby package for Atom

Atom and all repositories under Atom will be archived on December 15, 2022. Learn more in our official announcement

Ruby language support in Atom

Adds syntax highlighting and snippets to Ruby files in Atom.

Originally converted from the Ruby TextMate bundle.

Contributions are greatly appreciated. Please fork this repository and open a pull request to add snippets, make grammar tweaks, etc.

language-ruby's Issues

Parentheses in Default Parameter Mess Up Highlighting

Having a default parameter use a ) messes up syntax highlighting. I tried to fix the issue myself but just don't have enough experience with the code to find out how to deal with it. Interestingly enough it doesn't happen if the ) is in a string and it doesn't happen with other recursive tokens like %(te(s)t)

Comment not working when @ symbol

Starting in language-ruby v0.39.0, some comments are not highlighted right. It seems to be when the hash is followed by a space, @ symbol, and a Ruby method.

Here is an example:

# @attr

Add attr_{reader,writer,accessor} defined attributes to list of method names

Name of method definitions starting with an exclamation mark do not get highlighted

example:

def !~(other)
  # do something 
end

Screenshot

Incorrectly highlighted regex

this code has broken highlighting - note the red closing slash on the regex and wash of redness below it

new_node = node.to_s.gsub(/{(\w+)}/) { "<a href=\"/docs\/#{context[:doc_version]}\/api\/classes\/#{$1}\">#{$1}</a>" }

Regexp syntax issues

I'm using the regex railroad diagram package and noticed that many ruby regexps stopped working a while back. Seems to be an issue only with ruby. I also noticed that regexps are syntax highlighted differently depending on where they occur.

This is not syntax highlighted (railroad doesn't work):

"hello".gsub(/[aeiou]/, '*') 

This is highlighted (railroad works):

x = /[aeiou]/

String Literal Syntax highlighting is broken

Consider the following code fragment, when inserted into the editor the syntax highlighitng shows all the code below the closed string as a string. This is not the case in sublime2 and other text-editors.

email.header = "[[\"Received\", \"by luna.mailgun.net with SMTP mgrt 8788212249833; Fri, 26 Apr 2013 18:50:30 +0000\"], [\"Received\", \"from [10.20.76.69] (Unknown [50.56.129.169]) by mxa.mailgun.org with ESMTP id 517acc75.4b341f0-worker2; Fri, 26 Apr 2013 18:50:29 -0000 (UTC)\"], [\"Message-Id\", \"<[email protected]>\"], [\"Date\", \"Fri, 26 Apr 2013 11:50:29 -0700\"], [\"From\", \"Bob <[email protected]>\"], [\"User-Agent\", \"Mozilla/5.0 (X11; Linux x86_64; rv:17.0) Gecko/20130308 Thunderbird/17.0.4\"], [\"Mime-Version\", \"1.0\"], [\"To\", \"Alice <[email protected]>\"], [\"Subject\", \"Re: Sample POST request\"], [\"References\", \"<[email protected]>\"], [\"In-Reply-To\", \"<[email protected]>\"], [\"X-Mailgun-Variables\", \"{\\\"my_var_1\\\": \\\"Mailgun Variable #1\\\", \\\"my-var-2\\\": \\\"awesome\\\"}\"], [\"Content-Type\", \"multipart/mixed; boundary=\\\"------------020601070403020003080006\\\"\"], [\"Sender\", \"[email protected]\"]]"
email.content_type = params['Content-Type']

Duplicate prefixes in snippets

Brought into visibility after mega-commit eb6db3d, which joined them all together.

Some snippets have identical prefixes, and it looks like Atom will choose the last-defined one.
The TextMate behavior was to pop open a prompt after pressing Tab, allowing interactive selection of any of the available methods via (1, 2, ...) selection.

Scope of problem:

$ grep --color=none prefix snippets/language-ruby.cson|sort|uniq -c|sort|grep -v 1
   2     'prefix': 'Dir'
   2     'prefix': 'File'
   2     'prefix': 'eac-'
   2     'prefix': 'mod'
   3     'prefix': 'cla'

Also referenced here: http://discuss.atom.io/t/multiple-snippets-key/2297

So I'm uncertain whether the functionality will be part of Atom, or whether by the time Atom compiles and loads CSON, there's no other way to get at those keys.

Heredoc improperly highlighted.

Rails.logger.error("\s\s" + <<-STR.strip_heredoc.strip)
  #{error_.message}: #{error_.backtrace[0]}
STR

The result is that the end ) is the same color as the string. (Actually this seems to be a bug inside of Pygments too since it seems to do the same thing.)

Pasting heredoc doesn't auto indent correctly

1. Paste heredoc:

sql = <<-SQL
  blah1
  blah2
SQL

1. Expect:

sql = <<-SQL
  blah1
  blah2
SQL

1. Actual:

sql = <<-SQL
blah1
blah2
SQL

Note the missing indention for blah1 and blah2. I've noticed it with other things in ruby as well like certain blocks and if/else statements.

Minor issue with syntax highlighting

Thanks for an awesome editor! ⛵

Multi-line array using %{ ... } seems to break highlighting. No biggie, though.

[ EDIT: I'm blind!! I missed the w in %w]

Language grammar highlighting does not end properly for this particular regular expression

FYI: language grammar for regexp in ruby is not ending properly

reg_exp = (/((http|https):\/\/)?[a-z0-9]+([\.\-@]{1}[a-z0-9]+)*\.[a-z]{2,5}(\/([a-z0-9]+[\.\-]?{1})*)*((\#|\:)([a-z0-9_]*[\.\-]?{1})* | \?(([a-z]+[a-z0-9_]*)(=[a-z0-9]*)&?)*)?/ix)

...continues to think the regexp is still going on after the end ')'

Atom mis-highlights [Array[0], Array] in comments.

In the comment:

# @return [Array#[](0), Array[0], Array] comment

It thinks everything after #[] is part of the string when it's part of the list of possible return classes.

`def meth *args` does not get highlighted like `def method(*args)`

def meth *args ends up leading to the * being marked what ( is usually highlighted as (punctuation.definition along with variable.ruby) instead of as a storage modifier.

Treat Guardfile* as Ruby code

language-ruby does a good job loading Guardfiles as Ruby code. In large projects, I like to name these Guardfile-test, Guardfile-lint, Guardfile-doc, etc. Could we please treat Guardfile* as Ruby code, so these files are colorized as well?

Different keyword for function and class definitions.

Some syntaxes (like Solarized Dark and Solarized Light) need special highlight for function and class definitions.

The problem is that I can't find a way to differentiate the blocks ends from functions and classes ends.

Is there a way to do:

class Foo
    def bar
        [].each do |e|
        end # normal end (no special color) 👍
    end # <--- Special class (close def)
end # <--- Special class (close class)

I'd be happy to try to help if you're open to some help.

Regexs are undetected when used with String#[]

pound should assume user is interpolating if used within double quotes

When a user highlights something in a double quote string and presses pound it should assume the use wants to interpolate. Right now it replaces the highlighted text with a pound symbol.

Pressing pound within a double quoted string should also assume the user intends to interpolate.

e.g.

"#{}"
" Good morning #{user} It is good to see you."

Atom confuses :$symbol with a global.

:$symbol

Gets highlighted as a global (with the colon in black or white) instead of as a symbol.

question: indentation for multi-line method params?

hi,

auto-indent for the following yields:

    result = Foo.bar
    (
    from_month: from_month,
    to_month: to_month
    )

is there any way to coax auto-indent to yield the parameters indented like so...?:

    result = Foo.bar
    (
      from_month: from_month,
      to_month: to_month
    )

similarly, the following yields like so:

    result = Foo.bar(from_month: from_month,
    to_month: to_month)

i might have expected something like:

    result = Foo.bar(from_month: from_month,
                     to_month: to_month)

regards,
tony...

No recognition of Module::Class.method syntax for highlighing.

I'm seeing problems with the syntax highlighting recognition of the Module and Class construct, and the Class.method construct.

It recognizes Class and sort of recognizes Module::Class but definitely misses Class.method

Manually creating array with more than 23 elements syntax highlight problem

class Green
   def initialize(value = ['1','2','3','4','5','6','7','8','9','10','11','12','13','14','15','16','17','18','19','20','21','22','23','PROBLEM'])
      @array = value
   end
   def why_green
      puts "everyhing is green"
      puts "Unitl the next apostrophe"
      '
   end
   def not_green
      puts "Syntax is now correct"
   end
end

syntax highlighting - strings - issue related to `%%`

It seems to create multiple nested string syntax highlights... and since my theme uses a semi-transparent background for the string highlights, you can clearly see that they are piling up on top of each other because they get darker and darker throughout the file:

On closer inspection, it looks like it's related to the characters %%- and %%=.
And in case it helps, this is a .erb file, and the <%% is meant to escape the ERB tag so that it will output the <% characters for use in an underscore template.

Moved from atom/atom#3940

Add opal extension

Opal is a ruby implementation in the browser.

Regexp's lose syntax highlighting when comma or other added.

Properly Highlighted:

LineRegexps = [
    /Invalid\suser\s.*\sfrom/
]

if val =~ /Invalid\suser\s.*\sfrom/
  # Do Work Son
end

Loses syntax highlighting:

LineRegexps = [
    /Invalid\suser\s.*\sfrom/,
]

if val =~ /Invalid\suser\s.*\sfrom/ \
    || other
  # Do work Son
end

"repetition" is misspelled

repitition => repetition

It's also misspelled in a few other places:
https://github.com/search?q=repitition+user%3Aatom&ref=searchresults&type=Code

Regexp with interpolation results in comments.

(self.dup).downcase.gsub(/#{REMOVE_FROM_STRING}/, ""). \
   gsub(/_/, "-").gsub(/\s+/, "-").gsub(/-+/, "-")

Single and multiple line regexp like the above results in everything past the # being a comment.

'do' snippet recurs when deleteing block arguments

When trying to write argument-less blocks, by deleting the |variable| code that is generated and then pressing tab again, a new |variable| argument is created and a new end is inserted.

I am expecting the 2nd tab to result in the cursor dropping into the block. I am 99.9% sure this used to function as expected, and mirror how TextMate 1/2 deals with this:

I am currently using Atom 0.136.0, atom/language-ruby 0.39.0 and running on OSX 10.9.4.

I checked the console whilst doing this, but no errors were occuring.

Regexp with some kinds of interpolation get transformed into comments.

Full example:

module EnvyGeeks
  module Get extend self
    def ips(cidr = "192.168.1.0/24")
      # Technically we don't need the select but we should defensively double chck.
      `ip route show #{cidr}`.each_line.select { |v| v =~ /scope link/ }.map do |v|
        IPAddr.new(v.match(/(?:src )(#{Regexp.escape(cidr.gsub(/\/\d+\Z/, "").gsub(/\.\d+\Z/, ""))}\.\d+)/)[1])
      end
    end
  end
end

Ternary regexp does not get highlighted.

The following loses all regexp syntax highlighting.

hello =~ /world/ ? hello : world

For some reason it actually ends up marking it as an arithmetic operator.

Add automatic `end`

It would be interesting to add the ability to automatically add end in the next line when writing new:

• classes
• modules
• methods
• blocks
• conditional statements
• etc.

Thanks.

Syntax Highlighting breaks if you use / after )

If you do something like (1+2)/3, it breaks syntax highlighting. I'm using 0.31.0.

Feature request: Hilight beginning and end of selected block

When my cursor is on an def it should hilight the corresponding end, same if I'm inside the block.

regular expression in hash table

In a hash table like {a: /#{x}/i} or {:a => /#{x}/i} the regex is not rederred as expected

folding rescue blocks does not work as expected

See atom/atom#731

Method highlighting inconsistency & miscellaneous bugs

I'm testing Atom from a Sublime Text background. I've noticed two main highlighting differences:

• Anything starting with a capital letter is now highlighted the same way as constants (purple) instead of like classes (cyan)
• Methods are randomly highlighted in cyan/white, instead of just white (prime example #select vs #reject)

The former seemed like a nice change but it doesn't always detect constants correctly so I think it should default to class styling. The latter is the most important thing to address though, I've never seen any highlighter do this.

Windows 7
Atom 0.136.0
Monokai 0.8.0
Language Ruby 0.39.0

I'm using the Monokai theme and describing things in terms of those colours and how Sublime Text handles it, but lots of these are legacy issues from TextMate that Atom has inherited (which were otherwise fixed in Sublime and its ruby packages). Please read the screenshot:

Gist

I can break this down into 11 tickets if needed, it was just convenient for me to display and annotate it all in a single image.

Wrong highlighting

Both with and without soft wrapping enabled, atom --safe fails to highlight this file.

Running atom 0.135.0 with Language Ruby 0.38.0 on MacOS X 10.9.5

Local variables?

Why every type of variables except local ones supported, is this intended or ...?

invalid regex parsing

value1 = value2 / (1.0 - (percentage / 100.0))

Moved over from #47 after releasing it was different that that issue.

case when, case # when and generic casing tabbing broken.

Atom seems to always want to de-indent when in a case statement in Ruby. It was bad that it always broke the way I like to tab single-line whens but it got worse when I started commenting above the when statement it would then tab behind the case resulting in:

  case true

  # Comment
when arguments then do_work(son)
  end

It would be nice if language-ruby respected our custom tabbing and didn't try to enforce crazy rules, please, because I like my single line whens to look like:

case true
  when argument then do_work(son)
end

But editing always breaks the tabbing in some way especially when you start commenting.

attr_reader shortcut is incorrectly taking precedence over existing snippet being used

1. Type "def" and hit tab to start using the define a method snippet.
2. Type method name that ends with "r" like "test_subscriptions_with_sort_order".
3. Hit tab.

Result:

def test_subscriptions_with_sort_ordeattr_reader :attr_names

end

Expected:

def test_subscriptions_with_sort_order
  <cursor here>
end

This just recently started happening.

Multi-line regexs are not highlighted as regexs

After #41, I thought to check if multiline regexs are supported by the regex highlighting, and they're not.

Can't think of a simple way to detect the difference between the opening of a multi-line regex and a simple /, though, given that a file may have multiple /, all unrelated.

Using 0.32.0.

Update "self" to include a ".self" class

See: atom/language-coffee-script#39

Per the discussion on the CoffeeScript language package, it makes sense to keep the various default Atom language packages consistent. So rather than self being given a class of variable.language.ruby it should be given a class of variable.language.self.ruby.

auto indent not working as expected

I ran into a situation where Auto Indent results in a wrong indent. I could reduce the example code to the following:

class Example
  private

  def attribute_and_value(attribute, value)
    "%s: %s" % [human_attribute_name(attribute),
      value]
  end
end

After calling Auto Indent it will look like this:

class Example
  private

  def attribute_and_value(attribute, value)
    "%s: %s" % [human_attribute_name(attribute),
      value]
    end
  end

Add Jbuilder support

Please add, in grammars/ruby.cson, fileTypes += "jbuilder" for https://github.com/rails/jbuilder support.

Add support for string interpolation autocomplete

I'd love to be able to type # in a double quoted string and it would fill in #{} or #{<selection>} if I have something selected

Regular expressions with apostrophes break syntax highlighting

some_regex_with_an_apostrophe /foo'/

def oh_no
  "no more syntax highlighting"
end

renders as this:

Regexp starting with = doesn't get highlighted.

When doing the regexp:

/=\Z/

it doesn't get highlighted. It seems to only happen with =

Regexen on the LHS don't get syntax highlighted.

I experienced this bug with the =~ operator originally, but it's not limited to there.

Atom doesn't recognize keyword: val as different than a normal param.

Can we please get highlighting support for:

def function(keyword: var)
  "win"
end

So that we can highlight the keyword different than a normal param.