Infix to postfix conversion using stack in ruby

Ruby program for Infix to postfix conversion using stack. Here problem description and explanation.

#  Ruby program for
#  Infix to postfix conversion
#  Using custom stack

#  Stack node
class StackNode 
	# Define the accessor and reader of class StackNode
	attr_reader :element, :next
	attr_accessor :element, :next
	#  Stack data
	def initialize(element, last) 
		self.element = element
		self.next = last
	end
end

#  Define a custom stack
class MyStack 
	# Define the accessor and reader of class MyStack
	attr_reader :top, :size
	attr_accessor :top, :size
	def initialize() 
		self.top = nil
		self.size = 0
	end

	#  Add node at the top of stack
	def push(element) 
		self.top = StackNode.new(element, self.top)
		self.size += 1
	end

	def isEmpty() 
		if (self.size > 0 && self.top != nil) 
			return false
		else
			return true
		end
	end

	#  Remove top element of stack
	def pop() 
		if (self.size > 0 && self.top != nil) 
			temp = self.top
			#  Change top element of stack
			self.top = temp.next
			self.size -= 1
		end
	end

	#  Return top element of stack
	def peek() 
		if (self.top == nil) 
			return ' '
		end
		return self.top.element
	end
end

class Conversion 
	def precedence(text) 
		if (text == '+' || text == '-') 
			return 1
		elsif (text == '*' || text == '/') 
			return 2
		elsif (text == '^') 
			return 3
		end
		return -1
	end

	def is_operator(text) 
		if (text == '+' || text == '-' || 
            text == '*' || text == '/' || text == '^') 
			return true
		end

		return false
	end

	#  Converting the given infix expression to postfix expression
	def infixToPostfix(infix) 
		result = ""
		#  Get the size
		size = infix.length
		#  Create empty stack 
		s = MyStack.new()
		i = 0
		while (i < size) 
			if ((infix[i] >= '0' && infix[i] <= '9') || 
                (infix[i] >= 'a' && infix[i] <= 'z') || 
                (infix[i] >= 'A' && infix[i] <= 'Z')) 
				#  When getting a operands
				result = result + infix[i].to_s
			else
 
				if (s.isEmpty() || infix[i] == '(') 
					#  Base case
					#  When getting a open parenthesis
					#  Or stack is empty
					s.push(infix[i])
				elsif (infix[i] == ')') 
					#  Need to remove stack element until the close bracket
					while (s.isEmpty() == false && s.peek() != '(') 
						#  Get top element
						result += s.peek()
						#  Remove stack element
						s.pop()
					end

					if (s.peek() == '(') 
						#  Remove stack element
						s.pop()
					end

				else
 
					#  Remove stack element until precedence of 
					#  top is greater than current infix operator
					while (s.isEmpty() == false && 
                           self.precedence(infix[i]) <= 
                           self.precedence(s.peek())) 
						#  Get top element
						result += s.peek()
						#  Remove stack element
						s.pop()
					end

					#  Add new operator
					s.push(infix[i])
				end

			end

			i += 1
		end

		#  Add remaining elements
		while (s.isEmpty() == false) 
			result += s.peek()
			s.pop()
		end

		#  Display result
		print(" Infix    : ", infix, "\n")
		print(" Postfix  : ", result, "\n")
	end

end

def main() 
	task = Conversion.new()
	infix = "((a/b+c))/(e*f)+(g^h-i)+k"
	task.infixToPostfix(infix)
	infix = "((a*b)^(c+d)/e)-f"
	task.infixToPostfix(infix)
end

main()

Output

 Infix    : ((a/b+c))/(e*f)+(g^h-i)+k
 Postfix  : ab/c+ef*/gh^i-+k+
 Infix    : ((a*b)^(c+d)/e)-f
 Postfix  : ab*cd+^e/f-