class RuboCop::Cop::Bundler::GemComment


gem ‘bar’, ‘< 2.1’
# Version 2.1 introduces breaking change baz
gem ‘foo’, github: ‘some_account/some_fork_of_foo’
# Using this fork because baz
# good
gem ‘bar’, ‘< 2.1’
gem ‘foo’, github: ‘some_account/some_fork_of_foo’
# bad
@example OnlyFor: [‘version_specifiers’, ‘github’]
gem ‘foo’, ‘< 2.1’
# Version 2.1 introduces breaking change baz
# good
gem ‘foo’, ‘< 2.1’
# bad
@example OnlyFor: [‘version_specifiers’]
gem ‘foo’
# Helpers for the foo things.
# good
gem ‘foo’
# bad
@example OnlyFor: [] (default)
you can check the bundler.io/man/gemfile.5.html[official documentation].
For a full list of options supported by bundler,
- ‘source`
- `github`
- `git`
- `gist`
- `bitbucket`
options that change the source of a gem:
A useful use-case is to enforce a comment when using
you want to check.
Add “version_specifiers” and/or the gem option names
use certain options or have version specifiers.
can be used to only register offenses when the gems
Optionally, the “OnlyFor” configuration
Add a comment describing each gem in your Gemfile.

def checked_options_present?(node) 

def checked_options_present?(node)
  (cop_config[CHECKED_OPTIONS_CONFIG].include?(VERSION_SPECIFIERS_OPTION) &&
    version_specified_gem?(node)) ||
    contains_checked_options?(node)
end

def commented?(node) 

def commented?(node)
  preceding_lines = preceding_lines(node)
  preceding_comment?(node, preceding_lines.last)
end

def commented_any_descendant?(node) 

def commented_any_descendant?(node)
  commented?(node) || node.each_descendant.any? { |n| commented?(n) }
end

def contains_checked_options?(node) 

def contains_checked_options?(node)
  (Array(cop_config[CHECKED_OPTIONS_CONFIG]) & gem_options(node).map(&:to_s)).any?
end

def gem_options(node) 

def gem_options(node)
  return [] unless node.arguments.last&.type == :hash
  node.arguments.last.keys.map(&:value)
end

def ignored_gem?(node) 

def ignored_gem?(node)
  ignored_gems = Array(cop_config['IgnoredGems'])
  ignored_gems.include?(node.first_argument.value)
end

def on_send(node) 

def on_send(node)
  return unless gem_declaration?(node)
  return if ignored_gem?(node)
  return if commented_any_descendant?(node)
  return if cop_config[CHECKED_OPTIONS_CONFIG].any? && !checked_options_present?(node)
  add_offense(node)
end

def precede?(node1, node2)

or a Parser::Source::Comment. Both respond to #loc.
The args node1 & node2 may represent a RuboCop::AST::Node 
def precede?(node1, node2)
  node2.loc.line - node1.loc.line <= 1
end

def preceding_comment?(node1, node2) 

def preceding_comment?(node1, node2)
  node1 && node2 && precede?(node2, node1) &&
    comment_line?(node2.loc.expression.source)
end

def preceding_lines(node) 

def preceding_lines(node)
  processed_source.ast_with_comments[node].select do |line|
    line.loc.line <= node.loc.line
  end
end

def version_specified_gem?(node)

as long as it has one we know there's at least one version specifier.
Besides the gem name, all other *positional* arguments to `gem` are version specifiers, 
def version_specified_gem?(node)
  # arguments[0] is the gem name
  node.arguments[1]&.str_type?
end