lisp 1.1.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cd79b300ba14a7d6c45496292f33a72767c9f839
-  data.tar.gz: a7500b1c04cdc5262d899dee558b6a68648cb141
+  metadata.gz: 42a5f2b1b6e96db9ab76de11598d650aa99a4f4c
+  data.tar.gz: 258c6c47e9dca2afd7ab5e7e9c265caadfe7fa8a
 SHA512:
-  metadata.gz: 43b51dfb0eb3ace2920704f9bf54cf4690889a79bf38edca8e06cc703e453fddc3dd6055e45f8965e6a4d1410c8883ae9c2472624ed1e79d37e5157c9441f067
-  data.tar.gz: e67b94f6412a29046f759f1666d8fcefef4c5a4f07439f4ff2cfba076cfe04b63d4d14e5ee5ecb581fcd184e79a0684c2dc1a7c0cb963daff398a8d05ca9e3ea
+  metadata.gz: a80b1fdda67cffb7e3a8ca1369a27b418b1d591efc460422a60dcc2196f24bd7919be6f40e068453d6c949c059f3d37a485cc04e74018f4d11e9b8b99d7e1a9f
+  data.tar.gz: cd35640693b386066596e6dfc26433f088650170e817715a174ddaf018cdec9f421a2373f8a72a332da7b74412e57af8c300d8a94c271711cf278a0d39d226b8

data/.gitignore

@@ -1,3 +1,4 @@
 Gemfile.lock
 env
 pkg
+coverage

data/.travis.yml

@@ -0,0 +1,19 @@
+sudo: false
+
+language: ruby
+
+rvm:
+  - 2.3.8
+
+env:
+  global:
+    - CC_TEST_REPORTER_ID=0a4c13b71635c00cee43aba776853ade9404cc745c42977e25a5877a3e148527
+
+before_script:
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  - ./cc-test-reporter before-build
+  - gem install bundler -v 2.0.2
+
+after_script:
+  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT

data/Gemfile

@@ -1,7 +1,7 @@
 source "https://rubygems.org"
 
-group :development do
-  gem "codeclimate-test-reporter", require: nil
+group :test do
+  gem "simplecov"
 end
 
 gemspec

data/README.md

@@ -1,30 +1,26 @@
-lisp-rb
-=======
+lisp
+====
 
-[![Code Climate](https://codeclimate.com/github/jamesmoriarty/lisp-rb.png)](https://codeclimate.com/github/jamesmoriarty/lisp-rb) [![Code Climate](https://codeclimate.com/github/jamesmoriarty/lisp-rb/coverage.png)](https://codeclimate.com/github/jamesmoriarty/lisp-rb)
+![Gem][1] ![Build Status][2]
 
-Lisp Interpreter in Ruby. Inspired by [Lis.py](http://norvig.com/lispy.html).
+Lisp Interpreter in the Ruby Programming Language - 70 LOC. Inspired by [Lis.py](http://norvig.com/lispy.html).
 
-```
-$ lisp-rb
+```clojure
+$ lisp-repl
 ctrl-c to exit
-> (define pi 3.14)
-3.14
-> (* pi 2)
-6.28
-> (define area (lambda (r) (* 3.141592653 (* r r))))
-#<Proc:0x007f8af9c59ff0@./lisp.rb:44>
-> (area 3)
-28.274333877
-> (define fact (lambda (n) (if (<= n 1) 1 (* n (fact (- n 1))))))
-#<Proc:0x007f9a4cc4acf0@./lisp.rb:63 (lambda)>
-> (fact 10)
-3628800.0
+> (begin                                                                        
+(>   (define incf                                                               
+((>     (lambda (x)                                                             
+(((>       (set! x (+ x 1))))                                                   
+(>   (define one 1)                                                             
+(>   (incf one))                                                                
+2
+>                                      
 ```
 
 Install
 -------
-[![Gem Version](https://badge.fury.io/rb/lisp.svg)](http://badge.fury.io/rb/lisp)
+![Gem Version][3]
 
 ```
 gem install lisp
@@ -50,3 +46,7 @@ Features
 - [x] __assignment__ -	(set! var exp)	Evaluate exp and assign that value to var, which must have been previously defined (with a define or as a parameter to an enclosing procedure). _Example: (set! x2 (* x x))_
 
 - [x] __sequencing__ -	(begin exp...)	 Evaluate each of the expressions in left-to-right order, and return the final value. _Example: (begin (set! x 1) (set! x (+ x 1)) (* x 2)) ⇒ 4_
+
+[1]: https://img.shields.io/gem/dt/lisp
+[2]: https://travis-ci.org/jamesmoriarty/lisp.svg?branch=master
+[3]: https://img.shields.io/gem/v/lisp

data/bin/{lisp-rb → lisp-repl}

@@ -2,4 +2,4 @@
 
 require_relative "../lib/lisp"
 
-Lisp.repl
+Lisp::REPL.new.run

data/lib/lisp.rb

@@ -1,66 +1,67 @@
-require "bundler/setup"
+$:.unshift File.dirname(__FILE__)
+
 require "lisp/version"
 require "lisp/repl"
 
 module Lisp
-  def self.eval(string)
-    execute(parse(tokenize(string)))
+  def self.eval string
+    execute parse tokenize string
   end
 
-  def self.tokenize(string)
+  def self.tokenize string
     string.gsub("("," ( ").gsub(")"," ) ").split
   end
 
-  def self.parse(tokens, tree = [])
+  def self.parse tokens, tree = []
     raise "unexpected: eof" if tokens.size.zero?
 
     case token = tokens.shift
     when "("
       while tokens[0] != ")" do
-        tree.push parse(tokens)
+        tree.push parse tokens
       end
       tokens.shift
       tree
     when ")"
       raise "unexpected: )"
     else
-      evaluator(token)
+      atom token
     end
   end
 
-  def self.evaluator(token)
+  def self.atom token
     case token
     when /\d/
-      token.to_f
+      token.to_f % 1 > 0 ? token.to_f : token.to_i
     else
       token.to_sym
     end
   end
 
-  def self.execute(exp, scope = global)
-    return scope[exp] if     exp.is_a? Symbol
-    return exp        unless exp.is_a? Array
+  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
 
-    case exp[0]
+    case expression[0]
     when :define
-      _, var, exp = exp
-      scope[var] = execute(exp, scope)
+      _, var, expression = expression
+      scope[var]         = execute expression, scope
     when :lambda
-      _, params, exp = exp
-      lambda { |*args| execute(exp, scope.merge(Hash[params.zip(args)])) }
+      _, params, expression = expression
+      lambda { |*args| execute expression, scope.merge(Hash[params.zip(args)]) }
     when :if
-      _, test, conseq, alt = exp
-      exp = execute(test, scope) ? conseq : alt
-      execute(exp, scope)
+      _, test, consequent, alternative = expression
+      expression                       = if execute test, scope then consequent else alternative end
+      execute expression, scope
     when :set!
-      _, var, exp = exp
-      if scope.has_key?(var) then scope[var] = execute(exp, scope) else raise "#{var} is undefined" end
+      _, var, expression                     = expression
+      if scope.has_key?(var) then scope[var] = execute expression, scope else raise "#{var} is undefined" end
     when :begin
-      _, *exp = exp
-      exp.map { |exp| execute(exp) }.last
+      _, *expression = expression
+      expression.map { |expression| execute expression, scope }.last
     else
-      func, *args = exp.map { |exp| execute(exp, scope) }
-      func.call(*args)
+      function, *args = expression.map { |expression| execute expression, scope }
+      function.call *args
     end
   end
 
@@ -68,7 +69,7 @@ module Lisp
     @scope ||= begin
       operators = [:==, :"!=", :"<", :"<=", :">", :">=", :+, :-, :*, :/]
       operators.inject({}) do |scope, operator|
-        scope.merge(operator => lambda { |*args| args.inject(&operator) })
+        scope.merge operator => lambda { |*args| args.inject &operator }
       end
     end
   end

data/lib/lisp/repl.rb

@@ -1,22 +1,68 @@
 #!/usr/bin/env ruby
+
 require "coolline"
+require "coderay"
 
 module Lisp
-  def self.repl
-    trap("SIGINT") { throw :exit }
-    puts "ctrl-c to exit"
-    catch(:exit) do
-      loop do
-        puts begin
-          eval Coolline.new.readline
-        rescue Exception => e
-          e.message
+  class REPL
+    attr_reader :io, :input
+
+    def initialize
+      @io = Coolline.new do |config|
+        config.transform_proc = proc do
+          CodeRay.scan(config.line, :clojure).term
         end
       end
+
+      reset_input!
     end
-  end
-end
 
-if __FILE__ == $0
-   Lisp.repl
+    def run
+      trap("SIGINT") { throw :exit }
+
+      puts "ctrl-c to exit"
+
+      catch(:exit) do
+        loop do
+          begin
+            @input += io.readline prompt
+
+            if open_count == close_count
+              puts Lisp.eval input
+
+              reset_input!
+            end
+          rescue Exception => e
+            puts e.message
+
+            reset_input!
+          end
+        end
+      end
+    end
+
+    private
+
+    def prompt
+      count = open_count - close_count
+      char  = count > 0 ? ?( : ?)
+      "#{char * count}> "
+    end
+
+    def reset_input!
+      @input = String.new
+    end
+
+    def open_count
+      tokens.count(?()
+    end
+
+    def close_count
+      tokens.count(?))
+    end
+
+    def tokens
+      Lisp.tokenize input
+    end
+  end
 end

data/lib/lisp/version.rb

@@ -1,3 +1,3 @@
 module Lisp
-  VERSION = "1.1.0"
+  VERSION = '1.5.0'.freeze
 end

data/lisp.gemspec

@@ -19,7 +19,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "coolline"
-  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_dependency "coderay"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "pry"
+  spec.add_development_dependency "minitest", "> 5"
 end

data/test/support/simplecov.rb

@@ -0,0 +1,5 @@
+require 'simplecov'
+
+SimpleCov.add_filter 'vendor'
+SimpleCov.add_filter 'test'
+SimpleCov.start

data/test/test_lisp.rb

@@ -1,11 +1,10 @@
 #!/usr/bin/env ruby
 require "bundler/setup"
-require "codeclimate-test-reporter"
-CodeClimate::TestReporter.start
-require "minitest/autorun"
-require "pry"
 
-require_relative "../lib/lisp"
+Dir[File.expand_path(File.join(File.dirname(__FILE__),'support', '*.rb'))].each { |file| require file }
+
+require "lisp"
+require "minitest/autorun"
 
 class TestLisp < MiniTest::Unit::TestCase
 
@@ -15,22 +14,31 @@ class TestLisp < MiniTest::Unit::TestCase
     assert_equal ["(", "+", "1", "1", ")"], Lisp.tokenize("(+ 1 1)")
   end
 
-  def test_parse
+  def test_parse_open
     assert_raises(RuntimeError) { Lisp.parse(Lisp.tokenize("(")) }
+  end
+
+  def test_parse_close
     assert_raises(RuntimeError) { Lisp.parse(Lisp.tokenize(")")) }
   end
 
-  # representation
+  # ast
 
-  def test_representation
-    assert_equal [:*, 2, [:+, 1, 0]],                              Lisp.parse(Lisp.tokenize("(* 2 (+ 1 0) )"))
+  def test_ast_nested
+    assert_equal [:*, 2, [:+, 1, 0]], Lisp.parse(Lisp.tokenize("(* 2 (+ 1 0) )"))
+  end
+
+  def test_ast_call
     assert_equal [:lambda, [:r], [:*, 3.141592653, [:*, :r, :r]]], Lisp.parse(Lisp.tokenize("(lambda (r) (* 3.141592653 (* r r)))"))
   end
 
   # execution
 
-  def test_execution
+  def test_execution_return
     assert_equal 1, Lisp.execute(1)
+  end
+
+  def test_execution_reduce
     assert_equal 2, Lisp.execute([:*, 2, [:+, 1, 0]])
   end
 
@@ -39,12 +47,18 @@ class TestLisp < MiniTest::Unit::TestCase
   end
 
   def test_define
-    Lisp.eval("(define pi 3.141592653)")
-    assert_equal 6.283185306, Lisp.eval("(* pi 2)")
+    assert_equal 6.283185306, Lisp.eval(<<-eos)
+      (begin
+        (define pi 3.141592653)
+        (* pi 2))
+    eos
   end
 
-  def test_if
+  def test_if_cont
     assert_equal 2, Lisp.eval("(if(== 1 2) 1 2)")
+  end
+
+  def test_if_alt
     assert_equal 1, Lisp.eval("(if(!= 1 2) 1 2)")
   end
 
@@ -53,13 +67,75 @@ class TestLisp < MiniTest::Unit::TestCase
   end
 
   def test_begin
-    assert_equal 4, Lisp.eval("(begin (define x 1) (set! x (+ x 1)) (* x 2))")
+    assert_equal 4, Lisp.eval(<<-eos)
+      (begin
+        (define x 1)
+        (set! x (+ x 1)) (* x 2))
+    eos
   end
 
   def test_lambda
-    Lisp.eval("(define area (lambda (r) (* 3.141592653 (* r r))))")
-    assert_equal 28.274333877, Lisp.eval("(area 3)")
-    Lisp.eval("(define fact (lambda (n) (if (<= n 1) 1 (* n (fact (- n 1))))))")
-    assert_equal 3628800, Lisp.eval("(fact 10)")
+    assert_equal 28.274333877, Lisp.eval(<<-eos)
+      (begin
+        (define area
+          (lambda (r)
+            (* 3.141592653 (* r r))))
+        (area 3))
+    eos
+  end
+
+  def test_lambda_no_args
+    assert_equal 42, Lisp.eval(<<-eos)
+      (begin
+        (define test
+          (lambda () 42))
+        (test))
+    eos
+  end
+
+  def test_lambda_call_self
+    assert_equal 3628800, Lisp.eval(<<-eos)
+      (begin
+        (define fact
+          (lambda (n)
+            (if (<= n 1)
+              1
+              (* n (fact (- n 1))))))
+        (fact 10))
+    eos
+  end
+
+  def test_lambda_call_arg
+    assert_equal 40, Lisp.eval(<<-eos)
+      (begin
+        (define twice (lambda (x) (* 2 x)))
+        (define repeat (lambda (f) (lambda (x) (f (f x)))))
+        ((repeat twice) 10)))
+    eos
+  end
+
+  def test_program
+    assert_equal 2, Lisp.eval(<<-eos)
+      (begin
+        (define incf
+          (lambda (x)
+            (set! x (+ x 1))))
+        (define one 1)
+        (incf one))
+    eos
+  end
+
+  def test_repl
+    pid     = Process.pid
+    subject = Lisp::REPL.new
+    thread  = Thread.new do
+      sleep 1
+      Process.kill("INT", pid)
+      thread.join
+    end
+
+    assert_output("ctrl-c to exit\n") do
+      subject.run
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lisp
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.5.0
 platform: ruby
 authors:
 - James Moriarty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-22 00:00:00.000000000 Z
+date: 2020-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coolline
@@ -25,21 +25,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: coderay
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
-  type: :development
+        version: '0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -66,24 +66,40 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '5'
 description: ''
 email:
 - jamespaulmoriarty@gmail.com
 executables:
-- lisp-rb
+- lisp-repl
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
-- bin/lisp-rb
+- bin/lisp-repl
 - lib/lisp.rb
 - lib/lisp/repl.rb
 - lib/lisp/version.rb
 - lisp.gemspec
+- test/support/simplecov.rb
 - test/test_lisp.rb
 homepage: ''
 licenses:
@@ -105,9 +121,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
 summary: Lisp Interpreter in Ruby.
 test_files:
+- test/support/simplecov.rb
 - test/test_lisp.rb