Revert "rubocop auto correct."

This reverts commit dacd9c4.

Author: James Moriarty

lib/lisp.rb

@@ -1,33 +1,35 @@
-$LOAD_PATH.unshift File.dirname(__FILE__)
+$:.unshift File.dirname(__FILE__)
 
-require 'lisp/version'
-require 'lisp/repl'
+require "lisp/version"
+require "lisp/repl"
 
 module Lisp
-  def self.eval(string)
+  def self.eval string
     execute parse tokenize string
   end
 
-  def self.tokenize(string)
-    string.gsub('(', ' ( ').gsub(')', ' ) ').split
+  def self.tokenize string
+    string.gsub("("," ( ").gsub(")"," ) ").split
   end
 
-  def self.parse(tokens, tree = [])
-    raise 'unexpected: eof' if tokens.size.zero?
+  def self.parse tokens, tree = []
+    raise "unexpected: eof" if tokens.size.zero?
 
     case token = tokens.shift
-    when '('
-      tree.push parse tokens while tokens[0] != ')'
+    when "("
+      while tokens[0] != ")" do
+        tree.push parse tokens
+      end
       tokens.shift
       tree
-    when ')'
-      raise 'unexpected: )'
+    when ")"
+      raise "unexpected: )"
     else
       atom token
     end
   end
 
-  def self.atom(token)
+  def self.atom token
     case token
     when /\d/
       token.to_f % 1 > 0 ? token.to_f : token.to_i
@@ -36,7 +38,7 @@ def self.atom(token)
     end
   end
 
-  def self.execute(expression, scope = global)
+  def self.execute expression, scope = global
     return scope.fetch(expression) { |var| raise "#{var} is undefined" } if expression.is_a? Symbol
     return expression                                                    unless expression.is_a? Array
 
@@ -46,14 +48,14 @@ def self.execute(expression, scope = global)
       scope[var]         = execute expression, scope
     when :lambda
       _, params, expression = expression
-      ->(*args) { execute expression, scope.merge(Hash[params.zip(args)]) }
+      lambda { |*args| execute expression, scope.merge(Hash[params.zip(args)]) }
     when :if
       _, test, consequent, alternative = expression
-      expression                       = execute test, scope ? consequent : alternative
+      expression                       = if execute test, scope then consequent else alternative end
       execute expression, scope
     when :set!
-      _, var, expression = expression
-      scope.key?(var) ? (scope[var] = execute expression, scope) : (raise "#{var} is undefined")
+      _, var, expression                     = expression
+      if scope.has_key?(var) then scope[var] = execute expression, scope else raise "#{var} is undefined" end
     when :begin
       _, *expression = expression
       expression.map { |expression| execute expression, scope }.last
@@ -67,7 +69,7 @@ def self.global
     @scope ||= begin
       operators = [:==, :"!=", :"<", :"<=", :">", :">=", :+, :-, :*, :/]
       operators.inject({}) do |scope, operator|
-        scope.merge operator => ->(*args) { args.inject &operator }
+        scope.merge operator => lambda { |*args| args.inject &operator }
       end
     end
   end

lib/lisp/ext/proc.rb

@@ -1,6 +1,6 @@
 class Proc
   def to_s
-    '(lambda (...) (...))'
+    "(lambda (...) (...))"
   end
 
   def inspect

lib/lisp/repl.rb

@@ -1,9 +1,9 @@
 #!/usr/bin/env ruby
 
-require 'coolline'
-require 'coderay'
+require "coolline"
+require "coderay"
 
-require 'lisp/ext/proc'
+require "lisp/ext/proc"
 
 module Lisp
   class REPL
@@ -20,9 +20,9 @@ def initialize
     end
 
     def run
-      trap('SIGINT') { throw :exit }
+      trap("SIGINT") { throw :exit }
 
-      puts 'ctrl-c to exit'
+      puts "ctrl-c to exit"
 
       catch(:exit) do
         loop do
@@ -34,7 +34,7 @@ def run
 
               reset_input!
             end
-          rescue StandardError => e
+          rescue Exception => e
             puts e.message
 
             reset_input!
@@ -47,20 +47,20 @@ def run
 
     def prompt
       count = open_count - close_count
-      char  = count > 0 ? '(' : ')'
+      char  = count > 0 ? ?( : ?)
       "#{char * count}> "
     end
 
     def reset_input!
-      @input = ''
+      @input = String.new
     end
 
     def open_count
-      tokens.count('(')
+      tokens.count(?()
     end
 
     def close_count
-      tokens.count(')')
+      tokens.count(?))
     end
 
     def tokens