Module: RubyBeautify

Extended by:
RubyBeautify
Included in:
RubyBeautify
Defined in:
lib/ruby-beautify.rb,
lib/ruby-beautify/version.rb

Constant Summary collapse

OPEN_BLOCK_START = 
["module", "class", "begin", "def", 'if', 'while', 'unless', 'case']
BOTH_BLOCK = 
["else", "elsif", 'rescue', 'when']
OPEN_BLOCK_DO = 
['do', '{']
CLOSE_BLOCK = 
['end', '}']
OPEN_BRACKETS = 
[:on_lparen, :on_lbracket, :on_lbrace, :on_embexpr_beg]
CLOSE_BRACKETS = 
[:on_rparen, :on_rbracket, :on_rbrace, :on_embexpr_end]
NEW_LINES = 
[:on_nl, :on_ignored_nl, :on_comment, :on_embdoc_end]
VERSION = 
"0.97.3"

Instance Method Summary collapse

Instance Method Details

#both_block?(line_lex) ⇒ Boolean

is the first word one of our ‘both’ keywords?

Returns:

  • (Boolean) 


98
99
100
101
102
103
104
105
 
# File 'lib/ruby-beautify.rb', line 98

def both_block?(line_lex)
	line_lex.each do |x|
		# search for a first non-space token
		if not x[1] == :on_sp
			return x[1] == :on_kw && BOTH_BLOCK.include?(x[2])
		end
	end
end

#closing_assignment?(line_lex) ⇒ Boolean

…

Returns:

  • (Boolean) 


69
70
71
72
73
74
 
# File 'lib/ruby-beautify.rb', line 69

def closing_assignment?(line_lex)
	opens = opening_assignment_count line_lex
	closes = closing_assignment_count line_lex
	return false if opens == closes
	return true if closes > opens
end

#closing_block?(line_lex) ⇒ Boolean

kinda complex, we count open/close to determine if we ultimately have close a hanging line. Always true if it’s a both_block.

Returns:

  • (Boolean) 


119
120
121
122
123
124
125
126
 
# File 'lib/ruby-beautify.rb', line 119

def closing_block?(line_lex)
	return true if both_block? line_lex
	opens = starts_block?(line_lex) ? 1 : 0
	opens += opening_block_count line_lex
	closes = closing_block_count line_lex
	return false if opens == closes
	return true if opens < closes
end

#contains_block_assignment?(line_lex) ⇒ Boolean

test for assignment from a block

Returns:

  • (Boolean) 


77
78
79
80
81
82
83
84
 
# File 'lib/ruby-beautify.rb', line 77

def contains_block_assignment?(line_lex)
	compacted_line = line_lex.reject{|x| x[1] == :on_sp} #remove spaces
	idx = compacted_line.rindex{|x| ['=', '||='].include? x[2]} #find last equal
	if idx
		return OPEN_BLOCK_START.include?(compacted_line[idx+1][2]) #check for if/begin block
	end
	return false
end

#opening_assignment?(line_lex) ⇒ Boolean

same trick as opening_block

Returns:

  • (Boolean) 


61
62
63
64
65
66
 
# File 'lib/ruby-beautify.rb', line 61

def opening_assignment?(line_lex)
	opens = opening_assignment_count line_lex
	closes = closing_assignment_count line_lex
	return false if opens == closes
	return true if opens > closes
end

#opening_block?(line_lex) ⇒ Boolean

kinda complex, we count open/close to determine if we ultimately have a hanging line. Always true if it’s a both_block.

Returns:

  • (Boolean) 


109
110
111
112
113
114
115
 
# File 'lib/ruby-beautify.rb', line 109

def opening_block?(line_lex)
	opens = (starts_block?(line_lex) || both_block?(line_lex)) ? 1 : 0
	opens += opening_block_count line_lex
	closes = closing_block_count line_lex
	return false if opens == closes
	return true if opens > closes
end

#pretty_string(content, indent_token: "\t", indent_count: 1) ⇒ Object 



18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/ruby-beautify.rb', line 18

def pretty_string(content, indent_token: "\t", indent_count: 1)
	output_string = ""
	raise "Bad Syntax" unless syntax_ok? content
	lex = ::Ripper.lex(content)

	indent_level = 0
	line_lex = []

	# walk through line tokens
	lex.each do |token|
		line_lex << token
		if NEW_LINES.include? token[1] # if type of this token is a new line

			# did we just close something?  if so, lets bring it down a level.
			if closing_block?(line_lex) || closing_assignment?(line_lex)
				indent_level -= 1 if indent_level > 0
			end

			# print our line, in place.
			line_string = line_lex.map {|l| l.last}.join
			output_string += indented_line(indent_level, indent_token, indent_count, line_string)

			# oh, we opened something did we?  lets indent for the next run.
			if opening_block?(line_lex) || opening_assignment?(line_lex)
				indent_level += 1
			end

			line_lex.clear
		end
	end

	return output_string
end

#starts_block?(line_lex) ⇒ Boolean

is the first word a key word?

Returns:

  • (Boolean) 


87
88
89
90
91
92
93
94
95
 
# File 'lib/ruby-beautify.rb', line 87

def starts_block?(line_lex)
	return true if contains_block_assignment? line_lex
	line_lex.each do |x|
		# search for a first non-space token
		if not x[1] == :on_sp
			return x[1] == :on_kw && OPEN_BLOCK_START.include?(x[2])
		end
	end
end

#syntax_ok?(string) ⇒ Boolean

check the syntax of a string, will pipe it through the ruby bin to see if it has a valid syntax.

Returns:

  • (Boolean) 


54
55
56
57
58
 
# File 'lib/ruby-beautify.rb', line 54

def syntax_ok?(string)
	out, err, status = Open3.capture3("ruby -c -", stdin_data:string )
	return false unless err.empty?
	return true
end