Class: Synvert::Core::Rewriter::Instance

Inherits:
Object
  • Object
show all
Includes:
Helper
Defined in:
lib/synvert/core/rewriter/instance.rb

Overview

Instance is an execution unit, it finds specified ast nodes, checks if the nodes match some conditions, then add, replace or remove code.

One instance can contain one or many Scope and Condition.

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Helper

#add_arguments_with_parenthesis_if_necessary, #add_curly_brackets_if_necessary, #add_receiver_if_necessary, #reject_keys_from_hash, #strip_brackets

Constructor Details

#initialize(rewriter, file_patterns) { ... } ⇒ Instance

Initialize an Instance.

Parameters:

  • rewriter (Synvert::Core::Rewriter)
  • file_patterns (Array<String>) —

    pattern list to find files, e.g. [‘spec/*/_spec.rb’]

Yields:

  • block code to find nodes, match conditions and rewrite code.



15
16
17
18
19
20
21
 
# File 'lib/synvert/core/rewriter/instance.rb', line 15

def initialize(rewriter, file_patterns, &block)
  @rewriter = rewriter
  @actions = []
  @file_patterns = file_patterns
  @block = block
  rewriter.helpers.each { |helper| singleton_class.send(:define_method, helper[:name], &helper[:block]) }
end

Instance Attribute Details

#current_file ⇒ Object

Returns current filename.

Returns:

  • current filename



29
 
# File 'lib/synvert/core/rewriter/instance.rb', line 29

attr_accessor :current_node, :current_file, :current_mutation

#current_mutation ⇒ Object

Returns current mutation.

Returns:

  • current mutation



29
 
# File 'lib/synvert/core/rewriter/instance.rb', line 29

attr_accessor :current_node, :current_file, :current_mutation

#current_node ⇒ Object

Returns current parsing node.

Returns:

  • current parsing node



29
30
31
 
# File 'lib/synvert/core/rewriter/instance.rb', line 29

def current_node
  @current_node
end

Instance Method Details

#any_value ⇒ Synvert::Core::Rewriter::AnyValue

Match any value but nil.

Examples:

type: 'hash', nothing_value: 'true', status_value: any_value

Returns:



336
337
338
 
# File 'lib/synvert/core/rewriter/instance.rb', line 336

def any_value
  Rewriter::AnyValue.new
end

#append(code) ⇒ Object

Parse append dsl, it creates a AppendAction to append the code to the bottom of current node body.

Examples:

# def teardown
#   clean_something
# end
# =>
# def teardown
#   clean_something
#   super
# end
with_node type: 'def', name: 'steardown' do
  append 'super'
end

Parameters:

  • code (String) —

    code need to be appended.



180
181
182
 
# File 'lib/synvert/core/rewriter/instance.rb', line 180

def append(code)
  @current_mutation.append(@current_node, code)
end

#delete(*selectors, **options) ⇒ Object

Parse delete dsl, it creates a DeleteAction to delete child nodes.

Examples:

# FactoryBot.create(...)
# =>
# create(...)
with_node type: 'send', receiver: 'FactoryBot', message: 'create' do
  delete :receiver, :dot
end

Parameters:

  • selectors (Array<Symbol>) —

    selector names of child node.

  • options (Hash)
  • and_comma (Hash) —

    a customizable set of options



300
301
302
 
# File 'lib/synvert/core/rewriter/instance.rb', line 300

def delete(*selectors, **options)
  @current_mutation.delete(@current_node, *selectors, **options)
end

#find_node(query_string) { ... } ⇒ Object

Parse find_node dsl, it creates QueryScope to recursively find matching ast nodes, then continue operating on each matching ast node.

Examples:

# matches FactoryBot.create(:user)
find_node '.send[receiver=FactoryBot][message=create][arguments.size=1]' do
end

Parameters:

  • query_string (String) —

    query string to find matching ast nodes.

Yields:

  • run on the matching nodes.

Raises:

  • (Synvert::Core::NodeQuery::Compiler::ParseError) —

    if query string is invalid.



85
86
87
 
# File 'lib/synvert/core/rewriter/instance.rb', line 85

def find_node(query_string, &block)
  Rewriter::QueryScope.new(self, query_string, &block).process
end

#goto_node(child_node_name, &block) ⇒ Object

Parse goto_node dsl, it creates a GotoScope to go to a child node, then continue operating on the child node.

Examples:

# head status: 406
with_node type: 'send', receiver: nil, message: 'head', arguments: { size: 1, first: { type: 'hash' } } do
  goto_node 'arguments.first' do
  end
end

Parameters:

  • child_node_name (Symbol|String) —

    the name of the child nodes.

  • block (Block) —

    block code to continue operating on the matching nodes.



118
119
120
 
# File 'lib/synvert/core/rewriter/instance.rb', line 118

def goto_node(child_node_name, &block)
  Rewriter::GotoScope.new(self, child_node_name, &block).process
end

#if_exist_node(rules, &block) ⇒ Object

Parse if_exist_node dsl, it creates a Synvert::Core::Rewriter::IfExistCondition to check if matching nodes exist in the child nodes, if so, then continue operating on each matching ast node.

Examples:

# Klass.any_instance.stub(:message)
with_node type: 'send', message: 'stub', arguments: { first: { type: { not: 'hash' } } } do
  if_exist_node type: 'send', message: 'any_instance' do
  end
end

Parameters:

  • rules (Hash) —

    rules to check mathing ast nodes.

  • block (Block) —

    block code to continue operating on the matching nodes.



132
133
134
 
# File 'lib/synvert/core/rewriter/instance.rb', line 132

def if_exist_node(rules, &block)
  Rewriter::IfExistCondition.new(self, rules, &block).process
end

#if_only_exist_node(rules, &block) ⇒ Object

Parse if_only_exist_node dsl, it creates a Synvert::Core::Rewriter::IfOnlyExistCondition to check if current node has only one child node and the child node matches rules, if so, then continue operating on each matching ast node.

Examples:

# it { should matcher }
with_node type: 'block', caller: { message: 'it' } do
  if_only_exist_node type: 'send', receiver: nil, message: 'should' do
  end
end

Parameters:

  • rules (Hash) —

    rules to check mathing ast nodes.

  • block (Block) —

    block code to continue operating on the matching nodes.



161
162
163
 
# File 'lib/synvert/core/rewriter/instance.rb', line 161

def if_only_exist_node(rules, &block)
  Rewriter::IfOnlyExistCondition.new(self, rules, &block).process
end

#insert(code, at: 'end', to: nil) ⇒ Object

Parse insert dsl, it creates a Synvert::Core::Rewriter::InsertAction to insert code.

Examples:

# open('http://test.com')
# =>
# URI.open('http://test.com')
with_node type: 'send', receiver: nil, message: 'open' do
  insert 'URI.', at: 'beginning'
end

Parameters:

  • code (String) —

    code need to be inserted.

  • at (String) (defaults to: 'end') —

    insert position, beginning or end

  • to (String) (defaults to: nil) —

    where to insert, if it is nil, will insert to current node.



214
215
216
 
# File 'lib/synvert/core/rewriter/instance.rb', line 214

def insert(code, at: 'end', to: nil)
  @current_mutation.insert(@current_node, code, at: at, to: to)
end

#insert_after(code) ⇒ Object

Parse insert_after dsl, it creates a Synvert::Core::Rewriter::InsertAfterAction to insert the code next to the current node.

Examples:

# Synvert::Application.config.secret_token = "0447aa931d42918bfb934750bb78257088fb671186b5d1b6f9fddf126fc8a14d34f1d045cefab3900751c3da121a8dd929aec9bafe975f1cabb48232b4002e4e"
# =>
# Synvert::Application.config.secret_token = "0447aa931d42918bfb934750bb78257088fb671186b5d1b6f9fddf126fc8a14d34f1d045cefab3900751c3da121a8dd929aec9bafe975f1cabb48232b4002e4e"
# Synvert::Application.config.secret_key_base = "bf4f3f46924ecd9adcb6515681c78144545bba454420973a274d7021ff946b8ef043a95ca1a15a9d1b75f9fbdf85d1a3afaf22f4e3c2f3f78e24a0a188b581df"
with_node type: 'send', message: 'secret_token=' do
  insert_after "{{receiver}}.secret_key_base = \"#{SecureRandom.hex(64)}\""
end

Parameters:

  • code (String) —

    code need to be inserted.



229
230
231
 
# File 'lib/synvert/core/rewriter/instance.rb', line 229

def insert_after(code)
  @current_mutation.insert_after(@current_node, code)
end

#node ⇒ Parser::AST::Node

Gets current node, it allows to get current node in block code.

Returns:



47
48
49
 
# File 'lib/synvert/core/rewriter/instance.rb', line 47

def node
  @current_node
end

#prepend(code) ⇒ Object

Parse prepend dsl, it creates a PrependAction to prepend the code to the top of current node body.

Examples:

# def setup
#   do_something
# end
# =>
# def setup
#   super
#   do_something
# end
with_node type: 'def', name: 'setup' do
  prepend 'super'
end

Parameters:

  • code (String) —

    code need to be prepended.



199
200
201
 
# File 'lib/synvert/core/rewriter/instance.rb', line 199

def prepend(code)
  @current_mutation.prepend(@current_node, code)
end

#process ⇒ Object

Process the instance. It finds specified files, for each file, it executes the block code, rewrites the original code, then write the code back to the original file.



34
35
36
37
38
39
40
41
42
 
# File 'lib/synvert/core/rewriter/instance.rb', line 34

def process
  @file_patterns.each do |file_pattern|
    Dir.glob(File.join(Configuration.path, file_pattern)).each do |file_path|
      next if Configuration.skip_files.include?(file_path)

      process_file(file_path)
    end
  end
end

#process_with_node(node) { ... } ⇒ Object

Set current_node to node and process.

Parameters:

Yields:

  • process



55
56
57
58
59
 
# File 'lib/synvert/core/rewriter/instance.rb', line 55

def process_with_node(node)
  self.current_node = node
  yield
  self.current_node = node
end

#process_with_other_node(node) { ... } ⇒ Object

Set current_node properly, process and set current_node back to original current_node.

Parameters:

Yields:

  • process



65
66
67
68
69
70
 
# File 'lib/synvert/core/rewriter/instance.rb', line 65

def process_with_other_node(node)
  original_node = current_node
  self.current_node = node
  yield
  self.current_node = original_node
end

#remove(**options) ⇒ Object

Parse remove dsl, it creates a RemoveAction to remove current node.

Examples:

with_node type: 'send', message: { in: %w[puts p] } do
  remove
end

Parameters:

  • options (Hash) —

    options.

  • and_comma (Hash) —

    a customizable set of options



285
286
287
 
# File 'lib/synvert/core/rewriter/instance.rb', line 285

def remove(**options)
  @current_mutation.remove(@current_node, **options)
end

#replace(*selectors, with:) ⇒ Object

Parse replace dsl, it creates a ReplaceAction to replace the code of specified child nodes.

Examples:

# assert(object.empty?)
# =>
# assert_empty(object)
with_node type: 'send', receiver: nil, message: 'assert', arguments: { size: 1, first: { type: 'send', message: 'empty?', arguments: { size: 0 } } } do
  replace :message, with: 'assert_empty'
  replace :arguments, with: '{{arguments.first.receiver}}'
end

Parameters:

  • selectors (Array<Symbol>) —

    selector names of child node.

  • with (String) —

    code need to be replaced with.



274
275
276
 
# File 'lib/synvert/core/rewriter/instance.rb', line 274

def replace(*selectors, with:)
  @current_mutation.replace(@current_node, *selectors, with: with)
end

#replace_erb_stmt_with_expr ⇒ Object

Parse replace_erb_stmt_with_expr dsl, it creates a ReplaceErbStmtWithExprAction to replace erb stmt code to expr code.

Examples:

# <% form_for post do |f| %>
# <% end %>
# =>
# <%= form_for post do |f| %>
# <% end %>
with_node type: 'block', caller: { type: 'send', receiver: nil, message: 'form_for' } do
  replace_erb_stmt_with_expr
end



244
245
246
 
# File 'lib/synvert/core/rewriter/instance.rb', line 244

def replace_erb_stmt_with_expr
  @current_mutation.actions << Rewriter::ReplaceErbStmtWithExprAction.new(@current_node).process
end

#replace_with(code) ⇒ Object

Parse replace_with dsl, it creates a ReplaceWithAction to replace the whole code of current node.

Examples:

# obj.stub(:foo => 1, :bar => 2)
# =>
# allow(obj).to receive_messages(:foo => 1, :bar => 2)
with_node type: 'send', message: 'stub', arguments: { first: { type: 'hash' } } do
  replace_with 'allow({{receiver}}).to receive_messages({{arguments}})'
end

Parameters:

  • code (String) —

    code need to be replaced with.



258
259
260
 
# File 'lib/synvert/core/rewriter/instance.rb', line 258

def replace_with(code)
  @current_mutation.replace_with(@current_node, code)
end

#unless_exist_node(rules, &block) ⇒ Object

Parse unless_exist_node dsl, it creates a UnlessExistCondition to check if matching nodes doesn’t exist in the child nodes, if so, then continue operating on each matching ast node.

Examples:

# obj.stub(:message)
with_node type: 'send', message: 'stub', arguments: { first: { type: { not: 'hash' } } } do
  unless_exist_node type: 'send', message: 'any_instance' do
  end
end

Parameters:

  • rules (Hash) —

    rules to check mathing ast nodes.

  • block (Block) —

    block code to continue operating on the matching nodes.



146
147
148
 
# File 'lib/synvert/core/rewriter/instance.rb', line 146

def unless_exist_node(rules, &block)
  Rewriter::UnlessExistCondition.new(self, rules, &block).process
end

#warn(message) ⇒ Object

Parse warn dsl, it creates a Warning to save warning message.

Examples:

within_files 'vendor/plugins' do
  warn 'Rails::Plugin is deprecated and will be removed in Rails 4.0. Instead of adding plugins to vendor/plugins use gems or bundler with path or git dependencies.'
end

Parameters:

  • message (String) —

    warning message.



328
329
330
 
# File 'lib/synvert/core/rewriter/instance.rb', line 328

def warn(message)
  @rewriter.add_warning Rewriter::Warning.new(self, message)
end

#within_node(rules, options = {}) { ... } ⇒ Object Also known as: with_node

Parse within_node dsl, it creates a WithinScope to recursively find matching ast nodes, then continue operating on each matching ast node.

Examples:

# matches User.find_by_login('test')
with_node type: 'send', message: /^find_by_/ do
end

Parameters:

  • rules (Hash) —

    rules to find mathing ast nodes.

  • options (Hash) (defaults to: {}) —

    optional

  • stop_when_match (Hash) —

    a customizable set of options

  • direct (Hash) —

    a customizable set of options

Yields:

  • run on the matching nodes.



100
101
102
103
104
 
# File 'lib/synvert/core/rewriter/instance.rb', line 100

def within_node(rules, options = {}, &block)
  options[:stop_when_match] ||= false
  options[:direct] ||= false
  Rewriter::WithinScope.new(self, rules, options, &block).process
end

#wrap(with:) ⇒ Object

Parse wrap dsl, it creates a WrapAction to wrap current node with code.

Examples:

# class Foobar
# end
# =>
# module Synvert
#   class Foobar
#   end
# end
within_node type: 'class' do
  wrap with: 'module Synvert'
end

Parameters:

  • with (String) —

    code need to be wrapped with.



318
319
320
 
# File 'lib/synvert/core/rewriter/instance.rb', line 318

def wrap(with:)
  @current_mutation.wrap(@current_node, with: with)
end