flea 0.1.0 → 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 45c4d8338ff0266e41e153d43a451cfe72225d15b1a9b0b91c02923096c10880
+  data.tar.gz: 2588e992c1b9b5e2d8de2e7fe7cf1336b031d1f075e01ef84f6ba86642aebeed
+SHA512:
+  metadata.gz: 89c54c2f8cf295379fa2a30cce74d2cde2bb0d05ca5c9fd80f23ade581628db180b68a80f0f485112c75c6d85df07b7dad7c9eb9d60c6baa6d9d10657cb86f87
+  data.tar.gz: 8bd3f4dc4c13741143a81c4f045d926c2f5331bd96b2ae505e8415cab150527c123d0f49e2bc95a110576d74038934f932a1cd7b6ffee9eea17aa03828465c5e

data/.github/workflows/build.yml

@@ -0,0 +1,30 @@
+name: build
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+
+    - name: Install Ruby (2.6)
+      uses: actions/setup-ruby@v1
+      with:
+        ruby-version: 2.6.x
+
+    - name: Setup Code Climate test-reporter
+      run: |
+        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
+    - name: Build and test with RSpec
+      run: |
+        gem install bundler
+        bundle install --jobs 4 --retry 3
+        bundle exec rspec
+    - name: Publish code coverage
+      run: |
+        export GIT_BRANCH="${GITHUB_REF/refs\/heads\//}"
+        ./cc-test-reporter after-build --id ${{secrets.CC_TEST_REPORTER_ID}} --coverage-input-type simplecov

data/.gitignore

@@ -1 +1,4 @@
 *.swp
+.DS_Store
+*.gem
+coverage

data/.rspec

@@ -0,0 +1,2 @@
+--format progress
+--color

data/.rubocop.yml

@@ -0,0 +1,30 @@
+Metrics/BlockLength:
+  IgnoredMethods: ['describe', 'context']
+
+Style/SymbolProc:
+  IgnoredMethods: ['configure']
+
+AllCops:
+  SuggestExtensions: false
+  NewCops: enable
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/AbcSize:
+  Max: 20
+
+Metrics/MethodLength:
+  Max: 15
+
+Metrics/CyclomaticComplexity:
+  Max: 10
+  
+Gemspec/RequireMFA:
+  Enabled: false
+
+Naming/PredicateName:
+  AllowedMethods: ['has_variable?']
+
+Security/Eval:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,65 @@
+PATH
+  remote: .
+  specs:
+    flea (0.1.1)
+      sexpistol (~> 0.1.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    any-spec (0.1.0)
+    ast (2.4.2)
+    diff-lcs (1.3)
+    docile (1.3.5)
+    json (2.6.1)
+    parallel (1.21.0)
+    parser (3.1.0.0)
+      ast (~> 2.4.1)
+    rainbow (3.0.0)
+    regexp_parser (2.2.0)
+    rexml (3.2.5)
+    rspec (3.6.0)
+      rspec-core (~> 3.6.0)
+      rspec-expectations (~> 3.6.0)
+      rspec-mocks (~> 3.6.0)
+    rspec-core (3.6.0)
+      rspec-support (~> 3.6.0)
+    rspec-expectations (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-mocks (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-support (3.6.0)
+    rubocop (1.24.1)
+      parallel (~> 1.10)
+      parser (>= 3.0.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.15.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.15.1)
+      parser (>= 3.0.1.1)
+    ruby-progressbar (1.11.0)
+    sexpistol (0.1.2)
+    simplecov (0.17.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    unicode-display_width (2.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  any-spec (~> 0.1.0)
+  flea!
+  rspec (~> 3.2)
+  rubocop (~> 1.24.1)
+  simplecov (~> 0.17.1)
+
+BUNDLED WITH
+   1.17.3

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010 Aaron Gough (http://thingsaaronmade.com/)
+Copyright (c) 2022 Aaron Gough (http://aarongough.com/)
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -0,0 +1,345 @@
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-rubocop-brightgreen.svg)](https://github.com/rubocop/rubocop)
+[![Actions Status](https://github.com/aarongough/flea/actions/workflows/build.yml/badge.svg)](https://github.com/aarongough/flea/actions/workflows/build.yml)
+[![Maintainability](https://api.codeclimate.com/v1/badges/eae94ce7c694372a56cb/maintainability)](https://codeclimate.com/github/aarongough/flea/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/eae94ce7c694372a56cb/test_coverage)](https://codeclimate.com/github/aarongough/flea/test_coverage)
+[![Gem Version](https://badge.fury.io/rb/flea.svg)](https://badge.fury.io/rb/flea)
+
+# Flea
+
+Flea is a tiny Lisp interpreter implemented in Ruby. Flea is not designed to be a production language, instead it is designed to be an example of how simple it can be to bootstrap the core of a small flexible language. Flea essentially defines an informal subset of Scheme, just enough to be fun and interesting.
+
+### A Quick Example:
+
+This is the classic 'guess the number' program implemented in Flea:
+
+```scheme
+(define number (+ (rand 9) 1))
+
+(display "\n\nI'm thinking of a number between 1 and 10,\n")
+(display "try to guess it!\n\n")
+
+(define user-guess 
+  (lambda () 
+    (display "Take a guess - ")
+    (define guess (string-to-num (gets)))
+    (if (equal? guess number)
+      (display "Good guess!\n")
+      (begin
+        (if (greater-than? guess number)
+          (display "Lower!\n")
+          (display "Higher!\n"))
+        (user-guess)))))
+
+(user-guess)
+```
+
+### Installation:
+
+For ease of use the Flea is packaged as a RubyGem. Providing you already have Ruby and RubyGems installing Flea is as easy as entering the following command in a terminal:
+
+    gem install flea
+  
+Mac OS X and most Unix/Linux distributions come with an installation of Ruby and RubyGems. If you do not have Ruby and RubyGems installed please check the [Ruby website for instructions](http://www.ruby-lang.org/en/downloads/).
+
+### Usage:
+
+After Flea is installed you can run a program by typing the following on the command line:
+
+    flea /path/to/program
+  
+You can also launch Flea's interactive shell by simply calling `flea` with no arguments.
+
+## How it works:
+
+Flea's core is only about 100 lines of code, and provides a simple interface that is used to build the rest of the language. Flea is highly extensible because of its foreign function interface which allows Ruby Proc objects to be defined and then executed within the context of the Flea interpreter. The entire standard library of the language is implemented using this foreign function interface. For example, here is the implementation of the multiplication operator:
+
+```scheme
+(define * 
+  (native_function "
+    Proc.new() do |arguments, interpreter|
+      tmp = arguments.map {|item| interpreter.evaluate(item)}
+      tmp.inject {|sum, n| sum * n}
+    end
+  "))
+```
+    
+## API Documentation:
+
+Flea comes with a small but thoughtful standard library that includes functions for:
+
+#### Output:
+
+`(display)` Outputs data to STDOUT:
+
+```scheme
+(display "test")
+# => test
+
+(display (quote(1 2 3)))
+# => (1 2 3)
+```
+
+#### Input:
+
+`(read)` Reads and parses an s-expression from STDIN:
+
+```scheme
+(read) # user enters '(1 2 3)'
+# => (1 2 3)
+```
+
+`(gets)` Reads a string from STDIN:
+
+```scheme
+(gets) # user enters '(1 2 3)'
+# => "(1 2 3)"
+```
+
+#### Variables:
+
+`(define)` Sets a variable:
+
+```scheme
+(define test 1)
+(display test)
+# => 1
+```
+
+`(set!)` Re-defines an existing variable:
+
+```scheme
+(define test 1)
+(set! test 2)
+(display test)
+# => 2  
+```
+
+#### Numeric operations:
+
+`(+)` Add one or more numbers:
+
+```scheme  
+(+ 1 2 3)
+# => 6
+```
+
+`(-)` Subtract one or more numbers:
+
+```scheme
+(- 10 2 1)
+# => 7
+```
+
+`(*)` Multiply one or more numbers:
+
+```scheme
+(* 10 2 4)
+# => 80
+```
+
+`(/)` Divide one or more numbers:
+
+```scheme
+(/ 100 2 2)
+# => 25
+```
+
+`(greater-than?)` Returns true if it's first argument is greater than all the others, false otherwise:
+
+```scheme
+(greater-than? 10 2 3 4)
+# => #t
+
+(greater-than? 1 2 3 4)
+# => #f
+```
+
+`(less-than?)` Returns true if it's first argument is smaller than all the others, false otherwise:
+
+```scheme
+(less-than? 1 3 4 5)
+# => #t
+
+(less-than? 50 2 45 100)
+ # => #f
+```
+
+`(equal?)` and `(=)` Return true if all their arguments are the same, false otherwise:
+
+```scheme
+(equal? 1 1 1)
+# => #t
+
+(= 1 2 3)
+# => #f
+```
+
+#### List creation and manipulation:
+
+`(list)` Creates a new list from it's arguments:
+
+```scheme
+(list (+ 1 2) "test" (rand 10))
+# => (3 "test" 5)
+```
+
+`(list?)` Returns true if it's first argument is a list, false otherwise:
+
+```scheme
+(list? (quote ()))
+# => #t
+
+(list? 1)
+# => #f
+```
+
+`(list-tail)` Returns a new list created by removing the first n elements of the provided list:
+
+```scheme
+(define a (quote (1 2 3 4 5 6)))
+(list-tail a 3)
+# => (4 5 6)
+```
+
+`(car)` Returns the first item of a list:
+
+```scheme
+(car (quote (1 2 3)))
+# => 1
+```
+
+`(cdr)` Returns the remainder of a list:
+
+```scheme
+(cdr (quote (1 2 3)))
+# => (2 3)
+```
+
+`(cons)` Creates a new list by using it's first argument as the CAR it's second argument as the CDR:
+
+```scheme
+(cons (quote (1 2 3)) 3)
+# => ((1 2 3) 3)
+
+(cons 1 2)
+# => (1 2)
+
+
+(cons 1 (2 3 4))
+# => (1 2 3 4)
+```
+
+`(append)` Creates a new list by concatenating it's arguments, it's first argument must be a list:
+
+```scheme
+(append (quote (1 2)) (quote (3 4)) 5)
+# => (1 2 3 4 5)
+```
+
+`(null?)` Returns true if it's first argument is null (the empty list):
+
+```scheme
+(null? (quote ()))
+# => #t
+
+(null? (quote (1 2 3)))
+# => #f
+
+(null? 1)
+# => #f
+```
+
+#### Conditionals:
+
+`(if)` If it's first argument is true then it will execute it's first code block, otherwise it will execute the second code block (if any):
+
+```scheme
+(if (equal? 1 1)
+  (display "true")
+  (display "false"))
+# => true
+
+(if (equal? 2 1)
+  (display "true")
+  (display "false"))
+# => false
+```
+
+#### Function creation:
+
+`(lambda)` Creates a new function:
+
+```scheme
+(define adder
+  (lambda (a)
+    (+ a 10)))
+    
+(adder 5)
+# => 15
+```
+
+For more info on lambda syntax read the [R5RS Scheme specification](http://schemers.org/Documents/Standards/R5RS/HTML/r5rs-Z-H-7.html#%_sec_4.1.4).
+
+### Type conversion:
+
+`(string-to-num)` Converts a string containing a number into a numeric literal:
+
+```scheme
+(string-to-num "123")
+# => 123
+```
+
+#### Misc:
+
+`(rand)` Returns a random number less than or equal to it's first argument:
+
+```scheme
+(rand 10)
+# => 1
+
+(rand 10)
+# => 6
+```
+
+#### Foreign function interface:
+
+`(native_function)` Takes a string representing a Ruby Proc object and returns it in a form that is able to be called like any other Flea function. The proc must take two arguments (arguments and interpreter):
+
+```scheme
+(define test
+  (native_function "
+    Proc.new() do |arguments, interpreter|
+      puts "Arguments class: " + arguments.class
+      puts "Arguments: " + arguments.inspect
+      puts "Interpreter class: " + interpreter.class
+      puts "foo"
+    end
+  ")
+
+(test 1 2 3 4)
+# => Arguments class: Array
+     Arguments: [1, 2, 3, 4]
+     Interpreter class: Flea::Interpreter
+     foo
+```
+   
+## Development and Testing:
+
+Before doing any development work make sure you have all the development dependencies installed by running `bundle install` in the root of the project directory.
+
+Making changes to Flea is made simpler by the presence of an extensive test suite. Tests are written in [RSpec](https://rspec.info/) and live in the `/spec` folder. To run the tests simply type `rspec` in the root of the project directory.
+
+Flea also has an 'executable language specification' which is a series of small programs that exercise every part of the language and also assert what the output for each small program should be. The language specification is written with the use of a helper tool called [AnySpec](https://github.com/aarongough/any-spec), and the test cases can be found at `/flea-language-spec`. To run the executable language specification run the following command from the root of the project directory:
+
+```
+bundle exec any-spec ./bin/flea flea-language-spec/flea-language-spec.yaml
+```
+
+---
+
+### Author & Credits:
+
+Author: [Aaron Gough](mailto:aaron@aarongough.com)
+
+Copyright © 2021 [Aaron Gough](http://thingsaaronmade.com/), released under the MIT license
+

data/bin/flea

@@ -1,11 +1,12 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require 'stringio'
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'flea.rb'))
+require 'bundler/setup'
+require 'flea'
 
 interpreter = Flea::Interpreter.new
 
-if ARGV.length > 0
+if ARGV.length.positive?
   interpreter.run(ARGF.read)
   exit
 end
@@ -14,20 +15,21 @@ loop do
   program = []
   indent = 0
   loop do
-    print "> " + ("  " * indent)
+    print "> #{'  ' * indent}"
     program << gets
-    
-    tmp_program = program.join(" ")
-    open_p_count = tmp_program.count("(")
-    close_p_count = tmp_program.count(")")
-    
+
+    tmp_program = program.join(' ')
+    open_p_count = tmp_program.count('(')
+    close_p_count = tmp_program.count(')')
+
     break if open_p_count == close_p_count
-    indent += 1 if program.last.count("(") > program.last.count(")")
-    indent -= 1 if program.last.count("(") < program.last.count(")")
+
+    indent += 1 if program.last.count('(') > program.last.count(')')
+    indent -= 1 if program.last.count('(') < program.last.count(')')
   end
-  program = program.join(" ")
-  exit if program.strip == "quit"
-  
+  program = program.join(' ')
+  exit if program.strip == 'quit'
+
   old_stdout = $stdout
   buffer = StringIO.new
   $stdout = buffer
@@ -36,4 +38,4 @@ loop do
   print buffer.string
   print "\n" unless buffer.string.empty?
   puts " => #{result.inspect}"
-end
+end

data/flea-language-spec/{README.rdoc → README.md}

@@ -1,3 +1,3 @@
-= Flea Language Specifcation
+# Flea Language Specifcation
 
-This is a small executable language specification for Flea written using {AnySpec}[https://github.com/aarongough/any-spec]. It basically serves as an integration test-suite for the language, and provides an easy way of doing test-first development of new language features.
+This is a small executable language specification for Flea written using [AnySpec](https://github.com/aarongough/any-spec). It basically serves as an integration test-suite for the language, and provides an easy way of doing test-first development of new language features.

data/flea-language-spec/test-cases/01-display-and-basic-literals/05-display-list-literal-using-quote.scm

@@ -2,4 +2,4 @@
 
 ----
 
-assert_output "(1 Hello! #t #f)"
+assert_output '(1 "Hello!" #t #f)'

data/flea-language-spec/test-cases/02-variables/05-define-with-list.scm

@@ -3,4 +3,4 @@
 
 ----
 
-assert_output "(1 Hello! #t #f)"
+assert_output '(1 "Hello!" #t #f)'

data/flea-language-spec/test-cases/04-quoting/01-quoting.scm

@@ -0,0 +1,5 @@
+(display (quote (1 "Hello!" #t #f)))
+
+----
+
+assert_output '(1 "Hello!" #t #f)'

data/flea.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'flea/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'flea'
+  spec.version       = Flea::VERSION
+  spec.authors       = ['Aaron Gough']
+  spec.email         = ['aaron@aarongough.com']
+
+  spec.summary       = 'A tiny but flexible Lisp interpreter written in Ruby'
+  spec.description   = 'Flea is an extremely simple, but extremely extensible Lisp interpreter written in Ruby.'
+  spec.homepage      = 'https://github.com/aarongough/flea'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'sexpistol', '~> 0.1.2'
+
+  spec.required_ruby_version = '>= 2.5.0'
+
+  spec.add_development_dependency 'any-spec', '~> 0.1.0'
+  spec.add_development_dependency 'rspec', '~> 3.2'
+  spec.add_development_dependency 'rubocop', '~> 1.24.1'
+  spec.add_development_dependency 'simplecov', '~> 0.17.1'
+end

data/lib/flea/environment.rb

@@ -1,38 +1,40 @@
+# frozen_string_literal: true
+
 module Flea
   class Environment
-    
-    attr_accessor :parent
-    
+    attr_accessor :parent, :table
+
     def initialize(parent = nil)
       @parent = parent
       @table = {}
       add_globals if @parent.nil?
     end
-    
+
     def has_variable?(name)
-      return true if @table.has_key?(name)
+      return true if @table.key?(name)
       return false if @parent.nil?
-      return @parent.has_variable?(name)
+
+      @parent.has_variable?(name)
     end
-    
+
     def find(name)
-      return @table[name] if @table.has_key?(name)
+      return @table[name] if @table.key?(name)
       return nil if @parent.nil?
-      return @parent.find(name)
+
+      @parent.find(name)
     end
-    
+
     def define(name, value)
       @table[name] = value
     end
-    
+
     private
-    
+
     def add_globals
-      @table.merge!({
-        :"#t" => true,
-        :"#f" => false
-      })
+      @table.merge!(
+        '#t': true,
+        '#f': false
+      )
     end
-    
   end
-end
+end