lisp 1.3.0 → 1.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 728f826f5c7ad7f2b90d6861cdd6d0792c9af21f
-  data.tar.gz: 21b608d9ee103ad308ab4a2b346f459609684120
+SHA256:
+  metadata.gz: 600c4afdb71f1e0635249197b7d0eb7fa9c55a5dabf11bffa5e636f61858712e
+  data.tar.gz: c73dade15637b2226120e61b31d41ae23363fb25cc4ba462e302dc1c32822855
 SHA512:
-  metadata.gz: 451e92aa8b46ea6b0ad3b6d7bab7b0118052f2ec43fdc3c9779ce93817e6a178e6cf99c11e92732e193b952d8f65375eac2338f0360bac181ad892270d14d999
-  data.tar.gz: d297679c014dfa9f0c52be2e8e73baf9c9175e4b3a1038440da0cb20d2597139a526a68d90845d0ab6efdec0f2ef55ae567af36c0219a45ec333d02c31554b3e
+  metadata.gz: 88191d156aba236ac005556a8002a24ab12f54129cb3aac6e82502dfa0741f320cf9e535299a0716e8fd2f41ce1f6f005b11d0a88c746a516d0951ae3d0188b4
+  data.tar.gz: 919dc08c1f74c65b878e734443d868a2cd006c6bda3a24d4d6c5850aeff1428da591da8d45b392509d4c238f780e86dc4450e7490535d0f3287d6fcee4144d44

data/.github/workflows/ci.yaml

@@ -0,0 +1,19 @@
+name: Continuous Integration
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        ruby: [ '2.3', '2.7' ]
+
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true
+    - run: bundle exec rake

data/.gitignore

@@ -1,3 +1,6 @@
 Gemfile.lock
 env
 pkg
+coverage
+doc
+.yardoc

data/Gemfile

@@ -1,7 +1,7 @@
 source "https://rubygems.org"
 
-group :development do
-  gem "codeclimate-test-reporter", require: nil
-end
+gem "rake", "~> 12.0"
+gem "yard", "~> 0.9"
+gem "simplecov", "~> 0.17"
 
 gemspec

data/README.md

@@ -1,35 +1,55 @@
-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 Version][3] ![Gem][1] ![Build Status][2]
 
-Lisp Interpreter in Ruby. Inspired by [Lis.py](http://norvig.com/lispy.html).
+Minimal Lisp interpreter using 75LOC and only standard libraries excluding the REPL. 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 install lisp
 ```
 
+Usage
+-----
+
+```clojure
+require "lisp"
+
+Lisp.eval(<<-eos)
+  (begin
+    (define fact
+      (lambda (n)
+        (if (<= n 1)
+          1
+          (* n (fact (- n 1))))))
+    (fact 10))
+eos # => 3628800
+```
+
+Commandline
+-----------
+
+```
+lisp-repl
+```
+
+
 Features
 --------
 
@@ -50,3 +70,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/Rakefile

@@ -1,7 +1,29 @@
 require "bundler/gem_tasks"
+require "rake/testtask"
+require 'yard'
 
-require 'rake/testtask'
+YARD::Rake::YardocTask.new do |t|
+  t.files = ['lib/**/*.rb', 'README', 'CHANGELOG', 'CODE_OF_CONDUCT']
+  t.options = []
+  t.stats_options = ['--list-undoc']
+end
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
 
-task :default do
-  Dir.glob('./test/*.rb').each { |file| require file}
+namespace :gh do
+  desc "Deploy yard docs to github pages"
+  task :pages => :yard do
+    `git add -f doc`
+    `git commit -am "update: $(date)"`
+    `git subtree split --prefix doc -b gh-pages`
+    `git push -f origin gh-pages:gh-pages`
+    `git branch -D gh-pages`
+    `git reset head~1`
+  end
 end
+
+task :default => :test

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,76 +1,8 @@
-$:.unshift File.dirname(__FILE__)
+$LOAD_PATH.unshift File.dirname(__FILE__)
 
 require "lisp/version"
+require "lisp/interpreter"
 require "lisp/repl"
 
 module Lisp
-  def self.eval(string)
-    execute(parse(tokenize(string)))
-  end
-
-  def self.tokenize(string)
-    string.gsub("("," ( ").gsub(")"," ) ").split
-  end
-
-  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)
-      end
-      tokens.shift
-      tree
-    when ")"
-      raise "unexpected: )"
-    else
-      evaluator(token)
-    end
-  end
-
-  def self.evaluator(token)
-    case token
-    when /\d/
-      token.to_f
-    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
-
-    case exp[0]
-    when :define
-      _, var, exp = exp
-      scope[var] = execute(exp, scope)
-    when :lambda
-      _, params, exp = exp
-      lambda { |*args| execute(exp, scope.merge(Hash[params.zip(args)])) }
-    when :if
-      _, test, conseq, alt = exp
-      exp = execute(test, scope) ? conseq : alt
-      execute(exp, scope)
-    when :set!
-      _, var, exp = exp
-      if scope.has_key?(var) then scope[var] = execute(exp, scope) else raise "#{var} is undefined" end
-    when :begin
-      _, *exp = exp
-      exp.map { |exp| execute(exp) }.last
-    else
-      func, *args = exp.map { |exp| execute(exp, scope) }
-      func.call(*args)
-    end
-  end
-
-  def self.global
-    @scope ||= begin
-      operators = [:==, :"!=", :"<", :"<=", :">", :">=", :+, :-, :*, :/]
-      operators.inject({}) do |scope, operator|
-        scope.merge(operator => lambda { |*args| args.inject(&operator) })
-      end
-    end
-  end
 end

data/lib/lisp/interpreter.rb

@@ -0,0 +1,74 @@
+module Lisp
+  class << self
+    def eval string
+      execute parse tokenize string
+    end
+
+    def tokenize string
+      string.gsub("(", " ( ").gsub(")", " ) ").split
+    end
+
+    def parse tokens, tree = []
+      raise "unexpected: eof" if tokens.size.zero?
+
+      case token = tokens.shift
+      when "("
+        while tokens[0] != ")" do
+          tree.push parse tokens
+        end
+        tokens.shift
+        tree
+      when ")"
+        raise "unexpected: )"
+      else
+        atom token
+      end
+    end
+
+    def 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 expression[0]
+      when :define
+        _, var, expression = expression
+        scope[var] = execute expression, scope
+      when :lambda
+        _, params, expression = expression
+        lambda { |*args| execute expression, scope.merge(Hash[params.zip(args)]) }
+      when :if
+        _, test, consequent, alternative = expression
+        expression = if execute test, scope then consequent else alternative end
+        execute expression, scope
+      when :set!
+        _, 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
+      else
+        function, *args = expression.map { |expression| execute expression, scope }
+        function.call *args
+      end
+    end
+
+    private
+
+    def atom token
+      case token
+      when /^[\p{N}\.]+$/
+        token.to_f % 1 > 0 ? token.to_f : token.to_i
+      else
+        token.to_sym
+      end
+    end
+
+    def global
+      operators = [:==, :"!=", :"<", :"<=", :">", :">=", :+, :-, :*, :/]
+
+      operators.inject({}) do |scope, operator|
+        scope.merge operator => lambda { |*args| args.inject &operator }
+      end
+    end
+  end
+end

data/lib/lisp/repl.rb

@@ -1,22 +1,66 @@
-#!/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
+
+    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
-  end
-end
 
-if __FILE__ == $0
-   Lisp.repl
+    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.3.0"
+  VERSION = '1.5.2'.freeze
 end

data/lisp.gemspec

@@ -1,4 +1,5 @@
 # coding: utf-8
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'lisp/version'
@@ -8,9 +9,9 @@ Gem::Specification.new do |spec|
   spec.version       = Lisp::VERSION
   spec.authors       = ["James Moriarty"]
   spec.email         = ["jamespaulmoriarty@gmail.com"]
-  spec.summary       = %q{Lisp Interpreter in Ruby.}
-  spec.description   = ""
-  spec.homepage      = ""
+  spec.summary       = %q{Lisp interpreter}
+  spec.description   = "Minimal Lisp interpreter using 75LOC and only standard libraries excluding the REPL. Inspired by Lis.py."
+  spec.homepage      = "https://github.com/jamesmoriarty/lisp"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
@@ -19,7 +20,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/lisp_test.rb

@@ -0,0 +1,144 @@
+#!/usr/bin/env ruby
+require "bundler/setup"
+
+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
+
+  # parser
+
+  def test_tokenize
+    assert_equal ["(", "+", "1", "1", ")"], Lisp.tokenize("(+ 1 1)")
+  end
+
+  def test_parse_open
+    assert_raises(RuntimeError) { Lisp.parse(Lisp.tokenize("(")) }
+  end
+
+  def test_parse_close
+    assert_raises(RuntimeError) { Lisp.parse(Lisp.tokenize(")")) }
+  end
+
+  # ast
+
+  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_return
+    assert_equal 1, Lisp.execute(1)
+  end
+
+  def test_execution_reduce
+    assert_equal 2, Lisp.execute([:*, 2, [:+, 1, 0]])
+  end
+
+  def test_eval
+    assert_equal 2, Lisp.eval("(* 2 (+ 1 0) )")
+  end
+
+  def test_define
+    assert_equal 6.283185306, Lisp.eval(<<-eos)
+      (begin
+        (define pi 3.141592653)
+        (* pi 2))
+    eos
+  end
+
+  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
+
+  def test_set!
+    assert_raises(RuntimeError) { Lisp.eval("(set! foo 0)") }
+  end
+
+  def test_begin
+    assert_equal 4, Lisp.eval(<<-eos)
+      (begin
+        (define x 1)
+        (set! x (+ x 1)) (* x 2))
+    eos
+  end
+
+  def test_lambda
+    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
+    skip if ENV['CI']
+
+    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

data/test/support/simplecov.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lisp
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.5.2
 platform: ruby
 authors:
 - James Moriarty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-23 00:00:00.000000000 Z
+date: 2021-05-26 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,26 +66,44 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: ''
+- !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: Minimal Lisp interpreter using 75LOC and only standard libraries excluding
+  the REPL. Inspired by Lis.py.
 email:
 - jamespaulmoriarty@gmail.com
 executables:
-- lisp-rb
+- lisp-repl
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yaml"
 - ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
-- bin/lisp-rb
+- bin/lisp-repl
 - lib/lisp.rb
+- lib/lisp/interpreter.rb
 - lib/lisp/repl.rb
 - lib/lisp/version.rb
 - lisp.gemspec
-- test/test_lisp.rb
-homepage: ''
+- test/lisp_test.rb
+- test/support/simplecov.rb
+homepage: https://github.com/jamesmoriarty/lisp
 licenses:
 - MIT
 metadata: {}
@@ -104,10 +122,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: Lisp Interpreter in Ruby.
+summary: Lisp interpreter
 test_files:
-- test/test_lisp.rb
+- test/lisp_test.rb
+- test/support/simplecov.rb

data/test/test_lisp.rb

@@ -1,65 +0,0 @@
-#!/usr/bin/env ruby
-require "bundler/setup"
-require "codeclimate-test-reporter"
-CodeClimate::TestReporter.start
-require "minitest/autorun"
-require "pry"
-
-require_relative "../lib/lisp"
-
-class TestLisp < MiniTest::Unit::TestCase
-
-  # parser
-
-  def test_tokenize
-    assert_equal ["(", "+", "1", "1", ")"], Lisp.tokenize("(+ 1 1)")
-  end
-
-  def test_parse
-    assert_raises(RuntimeError) { Lisp.parse(Lisp.tokenize("(")) }
-    assert_raises(RuntimeError) { Lisp.parse(Lisp.tokenize(")")) }
-  end
-
-  # representation
-
-  def test_representation
-    assert_equal [:*, 2, [:+, 1, 0]],                              Lisp.parse(Lisp.tokenize("(* 2 (+ 1 0) )"))
-    assert_equal [:lambda, [:r], [:*, 3.141592653, [:*, :r, :r]]], Lisp.parse(Lisp.tokenize("(lambda (r) (* 3.141592653 (* r r)))"))
-  end
-
-  # execution
-
-  def test_execution
-    assert_equal 1, Lisp.execute(1)
-    assert_equal 2, Lisp.execute([:*, 2, [:+, 1, 0]])
-  end
-
-  def test_eval
-    assert_equal 2, Lisp.eval("(* 2 (+ 1 0) )")
-  end
-
-  def test_define
-    Lisp.eval("(define pi 3.141592653)")
-    assert_equal 6.283185306, Lisp.eval("(* pi 2)")
-  end
-
-  def test_if
-    assert_equal 2, Lisp.eval("(if(== 1 2) 1 2)")
-    assert_equal 1, Lisp.eval("(if(!= 1 2) 1 2)")
-  end
-
-  def test_set!
-    assert_raises(RuntimeError) { Lisp.eval("(set! foo 0)") }
-  end
-
-  def test_begin
-    assert_equal 4, Lisp.eval("(begin (define x 1) (set! x (+ x 1)) (* x 2))")
-  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)")
-  end
-end