apricot 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+*.rbc
+.rbx
+*.gem

data/.rspec

@@ -0,0 +1 @@
+--color --require spec_helper

data/.ruby-version

@@ -0,0 +1 @@
+rbx-head

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - rbx-19mode
+
+notifications:
+  webhooks:
+    - http://rcmp.tenthbit.net/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+# It seems impossible to make Travis CI and my computer agree on this.
+#ruby "1.9.3", :engine => "rbx", :engine_version => "2.0.0.rc1"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,26 @@
+PATH
+  remote: .
+  specs:
+    apricot (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.1)
+    rake (10.0.3)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.0)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  apricot!
+  rake (~> 10.0.3)
+  rspec (~> 2.13.0)

data/README.md

@@ -0,0 +1,90 @@
+# Apricot [![Build Status](https://secure.travis-ci.org/programble/apricot.png?branch=master)](http://travis-ci.org/programble/apricot) [![Dependency Status](https://gemnasium.com/programble/apricot.png?travis)](https://gemnasium.com/programble/apricot)
+
+A Clojure-like Lisp on Rubinius.
+
+Try to contain your excitement, please.
+
+
+## Setup
+To get Apricot up and running, make sure you have Rubinius and Bundler
+installed.  The easiest way to get Rubinius is with [RVM](https://rvm.io/).
+Whenever you are using Apricot you need to be running Rubinius in Ruby 1.9
+mode. We make this easy in the Apricot repository with the `.ruby-version`
+file which RVM automatically reads to figure out which Ruby to switch to.
+
+``` sh
+$ rvm install rbx-head --1.9
+$ rvm use rbx-head
+$ gem install bundler
+$ bundle
+```
+
+## The REPL
+Apricot provides a nice read-eval-print-loop with line editing, history,
+tab-completion, and some interesting commands like `!bytecode`. To enter the
+REPL just run:
+
+``` sh
+$ bin/apricot
+```
+
+Once in the repl you can ask for help by using `!help` and you can exit with
+`!exit`. See the documentation of any function with `(doc <name>)`. Play
+around, read `kernel/core.apr` and try out our functions, and make some of
+your own. Experiment. Tell us what you think!
+
+``` clojure
+apr> (+ 1 2 3)
+=> 6
+apr> (map (fn [x] (* x x)) (Range. 1 10))
+=> [1 4 9 16 25 36 49 64 81 100]
+apr> (defn square [x] (* x x))
+=> #<Proc:0x330@(eval):3 (lambda)>
+apr> (map square (Range. 1 10))
+=> [1 4 9 16 25 36 49 64 81 100]
+apr> (map (comp str square) (Range. 1 10))
+=> ["1" "4" "9" "16" "25" "36" "49" "64" "81" "100"]
+apr> (doc comp)
+-------------------------
+comp
+([] [f] [f g] [f g h] [f1 f2 f3 & fs])
+  Take a set of functions and return a fn that is the composition of those
+  fns. The returned fn takes a variable number of args, applies the rightmost
+  of fns to the args, the next fn (right-to-left) to the result, etc.
+=> nil
+```
+
+## Hello World
+So you want to put your program in a file and not type it into the REPL? Sure:
+
+``` sh
+$ cat hello.apr
+(puts "Hello, world!")
+$ bin/apricot hello.apr
+Hello, world!
+```
+
+## Contact / Bug Reports
+Come visit us on [freenode](http://freenode.net/) in the #apricot channel, or
+drop one of us an email. Please send your bug reports to the GitHub
+[issue tracker](https://github.com/programble/apricot/issues). They will be
+greatly appreciated!
+
+
+## License
+
+Copyright (c) 2012-2013, Curtis McEnroe <programble@gmail.com>
+
+Copyright (c) 2012-2013, Scott Olson <scott@scott-olson.org>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/setup'
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec

data/apricot.gemspec

@@ -0,0 +1,22 @@
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+require "apricot/version"
+
+Gem::Specification.new do |s|
+  s.name        = "apricot"
+  s.version     = Apricot::VERSION
+  s.authors     = ["Curtis McEnroe", "Scott Olson"]
+  s.email       = ["programble@gmail.com", "scott@scott-olson.org"]
+  s.homepage    = "https://github.com/programble/apricot"
+  s.license     = "ISC"
+  s.summary     = "A Clojure-like programming language on Rubinius"
+  s.description = "A compiler for a Clojure-like programming language on the Rubinius VM"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rake", "~> 10.0.3"
+  s.add_development_dependency "rspec", "~> 2.13.0"
+end
+

data/bin/apricot

@@ -0,0 +1,58 @@
+#!/usr/bin/env rbx
+# vim: ft=ruby:
+
+unless defined?(Rubinius)
+  $stderr.puts "Error: Apricot must be run on Rubinius."
+  exit 1
+end
+
+unless Rubinius.ruby19?
+  $stderr.puts "Warning: Apricot must be run in Ruby 1.9 mode, executing rbx -X19..."
+  exec("/usr/bin/env", "rbx", "-X19", file, *ARGV)
+end
+
+require 'apricot'
+
+evals = []
+bytecode = false
+
+options = Rubinius::Options.new "Usage: #{$0} [options] [program]", 20
+options.doc "OPTIONS:"
+
+options.on "-e", "CODE", "evaluate CODE and print the result" do |code|
+  evals << [:eval, code]
+end
+
+options.on "-B", "--bytecode", "print bytecode after compiling" do
+  bytecode = true
+end
+
+options.on "-h", "--help", "display this help" do
+  puts options
+  exit
+end
+
+options.parse(ARGV).each do |file|
+  evals << [:file, file]
+end
+
+if evals.empty?
+  if $stdin.tty?
+    require 'apricot/repl'
+    Apricot::REPL.new('apr> ', bytecode).run
+  else
+    evals << [:stdin]
+  end
+end
+
+evals.each do |type, *args|
+  case type
+  when :eval
+    Apricot::Compiler.eval(args.first, "(eval)", 1, bytecode)
+  when :stdin
+    Apricot::Compiler.eval(STDIN.read, "(stdin)", 1, bytecode)
+  when :file
+    # The code is executed as it compiles.
+    Apricot::Compiler.compile(args.first, nil, bytecode)
+  end
+end

data/examples/bot.apr

@@ -0,0 +1,23 @@
+; An example IRC bot. This does not reflect our vision for Apricot, just what
+; features we currently have working.
+
+(require "socket")
+
+(defn send [io & parts]
+  (let [msg (apply str parts)]
+    (println "<< " msg)
+    (.print io msg "\r\n")))
+
+(defn run-bot [nick username realname channel server [port 6667]]
+  (let [irc (TCPSocket. server port)]
+    (send irc "NICK " nick)
+    (send irc "USER " username " * * :" realname)
+    (while-let [line (.gets irc)]
+      (println ">> " line)
+      (when (.start_with? line "PING")
+        (send irc (.sub line "PING" "PONG")))
+      (when (.include? line "001")
+        (send irc "JOIN " channel)
+        (send irc "PRIVMSG " channel " :It works!")))))
+
+(run-bot "apribot" "apr" "Apribot" "#apricot" "irc.freenode.net")

data/examples/cinch-bot.apr

@@ -0,0 +1,12 @@
+(require "cinch")
+
+(doto (Cinch::Bot.)
+  (.configure | #(doto %
+                   (.server= "irc.tenthbit.net")
+                   (.nick= "apribot")
+                   (.channels= ["#programming"])))
+
+  (.on :message #r/^apribot[:,]?\s+(.+)/
+       | (fn [m msg] (.reply m msg true)))
+
+  .start)

data/examples/hanoi.apr

@@ -0,0 +1,10 @@
+; Print the solution of a towers of hanoi puzzle with n disks using pegs a, b,
+; and c.
+(defn hanoi [n a b c]
+  (when-not (zero? n)
+    (hanoi (dec n) a c b)
+    (println "Move disk " n " from peg " a " to peg " c)
+    (hanoi (dec n) b a c)))
+
+; 5-disk example:
+(hanoi 5 "A" "B" "C")

data/examples/hello.apr

@@ -0,0 +1 @@
+(println "Hello, world!")

data/examples/plot.apr

@@ -0,0 +1,28 @@
+; Just a quick and dirty graph plotter.
+
+(defn plot [f x1 x2 xscale y1 y2 yscale]
+  (let [width (.ceil (* (- x2 x1) xscale))
+        height (.ceil (* (- y2 y1) yscale))
+        points (map (fn [x] [(.round (* xscale (- x x1)))
+                             (.round (* yscale (- (f x) y1)))])
+                    (.step x1 x2 (/ xscale)))
+        graph (Array. (inc height) | #(* " " width))]
+    (each [p points]
+      (let [x (first p)
+            y (second p)]
+        (when (<= 0 y height)
+          (#|.[]=| (graph (- height y)) x "*"))))
+    (each [line graph]
+          (println line))))
+
+(println "Exponential:")
+(plot Math/exp 0 5 10 0 20 1)
+
+(println "Logarithm base 10:")
+(plot Math/log10 1 15 5 0 1.5 10)
+
+(println "Sine:")
+(plot Math/sin 0 (* 4 Math::PI) 5 -1 1 5)
+
+(println "Tangent:")
+(plot Math/tan 0 (* 2 Math::PI) 10 -5 5 2)

data/examples/quine.apr

@@ -0,0 +1 @@
+((fn [x] (println (list x (list (quote quote) x)))) (quote (fn [x] (println (list x (list (quote quote) x))))))