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:



347
348
349
 
# File 'lib/synvert/core/rewriter/instance.rb', line 347

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.



186
187
188
 
# File 'lib/synvert/core/rewriter/instance.rb', line 186

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



306
307
308
 
# File 'lib/synvert/core/rewriter/instance.rb', line 306

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

#find_node(nql, options = {}) { ... } ⇒ 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:

  • nql (String) —

    node query language to find matching ast nodes.

Yields:

  • run on the matching nodes.

Raises:

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

    if query string is invalid.



90
91
92
93
94
 
# File 'lib/synvert/core/rewriter/instance.rb', line 90

def find_node(nql, options = {}, &block)
  Rewriter::QueryScope.new(self, nql, options, &block).process
rescue NodeQueryLexer::ScanError, Racc::ParseError => e
  raise NodeQuery::Compiler::ParseError, "Invalid query string: #{nql}"
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.



124
125
126
 
# File 'lib/synvert/core/rewriter/instance.rb', line 124

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.



138
139
140
 
# File 'lib/synvert/core/rewriter/instance.rb', line 138

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.



167
168
169
 
# File 'lib/synvert/core/rewriter/instance.rb', line 167

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.



220
221
222
 
# File 'lib/synvert/core/rewriter/instance.rb', line 220

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.



235
236
237
 
# File 'lib/synvert/core/rewriter/instance.rb', line 235

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:



52
53
54
 
# File 'lib/synvert/core/rewriter/instance.rb', line 52

def node
  @current_node
end

#noop ⇒ Object

Parse +noop dsl.



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

def noop
  @current_mutation.noop(@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.



205
206
207
 
# File 'lib/synvert/core/rewriter/instance.rb', line 205

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 writes the code back to the original file.



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

def process
  get_file_paths.each do |file_path|
    process_file(file_path)
  end
end

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

Set current_node to node and process.

Parameters:

Yields:

  • process



60
61
62
63
64
 
# File 'lib/synvert/core/rewriter/instance.rb', line 60

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



70
71
72
73
74
75
 
# File 'lib/synvert/core/rewriter/instance.rb', line 70

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



291
292
293
 
# File 'lib/synvert/core/rewriter/instance.rb', line 291

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.



280
281
282
 
# File 'lib/synvert/core/rewriter/instance.rb', line 280

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


250
251
252
 
# File 'lib/synvert/core/rewriter/instance.rb', line 250

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.



264
265
266
 
# File 'lib/synvert/core/rewriter/instance.rb', line 264

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

#test ⇒ Object

Test the instance. It finds specified files, for each file, it executes the block code, tests the original code, then returns the actions.



43
44
45
46
47
 
# File 'lib/synvert/core/rewriter/instance.rb', line 43

def test
  get_file_paths.map do |file_path|
    test_file(file_path)
  end
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.



152
153
154
 
# File 'lib/synvert/core/rewriter/instance.rb', line 152

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.



339
340
341
 
# File 'lib/synvert/core/rewriter/instance.rb', line 339

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

  • including_self (Hash) —

    a customizable set of options

  • stop_at_first_match (Hash) —

    a customizable set of options

  • recursive (Hash) —

    a customizable set of options

Yields:

  • run on the matching nodes.



108
109
110
 
# File 'lib/synvert/core/rewriter/instance.rb', line 108

def within_node(rules, options = {}, &block)
  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.



324
325
326
 
# File 'lib/synvert/core/rewriter/instance.rb', line 324

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