relisp 1.0.1 → 1.1.0

data/CHANGELOG

@@ -1,3 +1,17 @@
+== 1.1.0 / 2011-01-05
+
+* 2 major enhancements
+  * Multiple ruby slaves can be run from Emacs at once.  
+  * The method_missing stuff now retreives and sets elisp variables in
+    addition to calling functions.
+  * Ruby slaves can call elisp while starting up.
+* minor enhancements
+    * Less temporary variables created in elisp, and those that can be
+    are `makunbound'ed when they can be.
+  * Eval used in fewer places in ruby and elisp.
+  * New and better examples.
+  * Code is DRYer, prettier and sucks less in general.
+
 == 1.0.1 / 2009-09-09
 
 * 1 tiny backwards-incompatible enhancement

data/README

@@ -8,8 +8,7 @@ Emacs is great.  So is Ruby.  This purpose of this library is to:
 * manipulate Emacs without using Elisp to some extent (Ruby wrappers
   around some Elisp functions and objects)
 * reduce the number of blog entries titled "Is Ruby an acceptable
-  lisp?" and flame wars under the title "ruby vs. lisp vs. scheme
-  vs. haskell vs. ..."
+  lisp?"
 
 == Install
 
@@ -18,13 +17,15 @@ Emacs is great.  So is Ruby.  This purpose of this library is to:
 Then the library is installed, and you can call elisp from ruby.  But
 if you want to call ruby from emacs (and you do, right?) you need to
 go into the +src+ directory and copy <tt>relisp.el</tt> and/or
-<tt>relisp.elc</tt> to your elisp folder (probably <tt>~/.elisp</tt>).
-Then you might want to add the lines
+<tt>relisp.elc</tt> to your elisp folder (probably <tt>~/.elisp</tt>
+or <tt>~/.emacs.d/site-lisp</tt>).  Then you might want to add the
+lines
 
   (autoload 'relisp-start-slave "relisp" nil t)
   (autoload 'ruby-eval "relisp" nil t)
 
-to your emacs initialization file (probably <tt>~/.emacs'</tt>).
+to your emacs initialization file (<tt>~/.emacs'</tt> or
+<tt>~/.emacs.d/init.el</tt>).
 
 If you don't know where to find the files for this gem, run the
 command <tt>gem env gemdir</tt>.  Or you can download the tarball for
@@ -32,8 +33,8 @@ this gem and get the files there.
 
 == Usage
 
-The stuff below is all in the +examples+ directory if you want to try
-running it.
+The stuff below and a lot more is all in the +examples+ directory if
+you want to try running it.
 
 === Emacs calling Ruby
 
@@ -52,19 +53,17 @@ Then make calls to ruby with <tt>ruby_eval</tt>:
   (type-of (ruby-eval "{:name => 'john'}"))	
       => hash-table
 
-If you need to use an elisp variable or expression in the middle of
-the command, <tt>relisp-to-ruby</tt> will provide a string that, when
-evaluated by ruby, is equal to the original elisp object.  For example:
+If you need to use the value of an elisp variable,
+<tt>method_missing</tt> will give it to you:
 
-  (setq vect [1 2 3 4 5 6])
-  (ruby-eval (concat (relisp-to-ruby vect) ".class"))
-     => Relisp::Vector
-  (ruby-eval (concat (relisp-to-ruby vect) ".kind_of?(Array)"))
-     => t
-  (ruby-eval (concat (relisp-to-ruby vect) ".reverse"))
-     => [6 5 4 3 2 1]
-  (type-of (ruby-eval (concat (relisp-to-ruby vect) ".reverse")))
-     => vector
+  (setq list '(3 5 2 6 4 1))
+  (ruby-eval "list = symbol_value(:list)")
+  
+  (setq elisp-vector [1 2 3 4 5 6])
+  (ruby-eval "vect = symbol_value(:\"elisp-vector\")")
+  (ruby-eval "vect = self.elisp_vector")
+  ; or even
+  (ruby-eval "vect = elisp_vector")
 
 Note that the data types/classes are correct in both languages.  The
 results are converted--it's not just strings getting passed back and
@@ -147,12 +146,13 @@ use the <tt>ElispSlave#debugging</tt> method:
 
 == Author
 
-<don@ohspite.net>
+Don March <don@ohspite.net>
 
 == Copyright
 
-Copyright (C) 2009 <don@ohspite.net>.
-Licensed under the GNU General Public License.
+Copyright (C) 2009, 2010 Don March.
+
+Licensed under the GNU General Public License. 
 
 Relisp is free software: you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by

data/Rakefile

@@ -31,13 +31,14 @@ Wait! You're not finished!
 The gem is installed, and you can now call elisp from ruby.  But if
 you want to call ruby from emacs (and you do, right?) you need to go
 into the 'src' directory of this gem and copy 'relisp.el' and/or
-'relisp.elc' to your elisp folder (probably '~/.elisp').  Then you
-might want to add the lines
+'relisp.elc' to your elisp folder (probably something like
+'~/.emacs.d/site-lisp' or '~/.elisp').  Then you might want to add the
+lines
 
   (autoload 'relisp-start-slave "relisp" nil t)
   (autoload 'ruby-eval "relisp" nil t)
 
-to your emacs initialization file (probably '~/.emacs').
+to your emacs initialization file ('~/.emacs' or ~/.emacs.d/init.el).
 
 If you don't know where to find the files for this gem, run the
 command "gem env gemdir".  Or you can download the tarball for this

data/examples/elisp_master/elisp_master.el

@@ -1,49 +1,85 @@
-;; How to specify a file when running the slave.  The next few
-;; `ruby-eval's call methods defined in the ruby slave file.
+;; You might want to look at the *Relisp* buffer to see what messages
+;; are being passed.  Or you might not.  But it's there if you want it.
 
-(relisp-start-slave "ruby_slave")
+;; To evaluate each examples below, move point after the closing
+;; parenthesis and press C-x C-e.
 
-(ruby-eval "sample_ruby_method1")
-(ruby-eval "sample_ruby_method2")
+;; This is how to start the ruby slave without a file, but if you
+;; don't `ruby-eval' and `ruby-exec' will start one for you. 
+;; This stops the old slave first:
+(relisp-start-slave) 
 
-(member "ruby-created-buffer" (mapcar 'buffer-name (buffer-list)))
-(ruby-exec "sample_ruby_method3")
-(member "ruby-created-buffer" (mapcar 'buffer-name (buffer-list)))
-
-(ruby-exec "sample_ruby_method4")
+;; Note that return values are not strings but actual elisp data
+;; types:
+(ruby-eval "1 + 2 + 3")
+(ruby-eval "'gnirts ybur'.reverse")
 
-;; How to start the ruby slave without a file. The rest of the
-;; commands will work fine with a slave started either way.
+;; Variable persistence between calls:
+(ruby-exec "a = 5")
+(ruby-eval "a + 1")
 
-(relisp-start-slave) ;; stops the old slave first
+;; Recursive calls:
+(ruby-eval "elisp_eval('(+ 1 2)')")
+(ruby-eval "elisp_eval('(ruby-eval \"1 + 2\")')")
 
-;; Basic functionality--note that return values are not strings but
-;; actual elisp data types:
-(ruby-eval "1 + 2 + 3")
-(ruby-eval "'ruby string'.reverse")
+(setq list '(3 5 2 6 4 1))
+(ruby-eval "list = symbol_value(:list)")
+(ruby-eval "list.class")
+(ruby-eval "list.to_list.class")
+(ruby-eval "list.to_list.sort")
+(type-of (ruby-eval "list.to_list"))
 
-(setq vect [1 2 3 4 5 6])
-(ruby-eval (concat (relisp-to-ruby vect) ".class"))
-(ruby-eval (concat (relisp-to-ruby vect) ".kind_of?(Array)"))
-(ruby-eval (concat (relisp-to-ruby vect) ".reverse"))
-(type-of (ruby-eval (concat (relisp-to-ruby vect) ".reverse")))
+;; Because of the method_missing stuff, getting the symbol value
+;; directly isn't even necessary most of the time (it was for `list',
+;; however, because it's a function and method_missing tries that
+;; first.
 
-(setq list '(3 5 2 6 4 1))
-(ruby-eval (concat (relisp-to-ruby list) ".class"))
-(ruby-eval (concat (relisp-to-ruby list) ".to_list.class"))
-(ruby-eval (concat (relisp-to-ruby list) ".to_list.sort"))
-(type-of (ruby-eval (concat (relisp-to-ruby list) ".to_list")))
+(setq elisp-vector [1 2 3 4 5 6])
+;; (ruby-eval "vect = symbol_value(:\"elisp-vector\")")
+(ruby-eval "vect = self.elisp_vector")
+;; or even
+(ruby-eval "vect = elisp_vector")
+(ruby-eval "vect.class")
+(ruby-eval "vect.kind_of? Array")
+(ruby-eval "vect.reverse")
+(type-of (ruby-eval "vect.reverse"))
+(ruby-eval "self.elisp_vector= vect.reverse")
+(symbol-value 'elisp-vector)
 
 (setq str "a couple of words")
-(ruby-eval (concat (relisp-to-ruby str) ".split"))
+(ruby-eval "self.str.split")
 
-;; Recursive calls:
-(ruby-eval "elisp_eval('(+ 1 2)')")
-(ruby-eval "elisp_eval('(ruby-eval \"1 + 2\")')")
+; If you need an elisp value in ruby but don't want it in an elisp
+; variable, just elisp_eval it:
+(ruby-exec "vect = elisp_eval '[1 2 3 4]'")
+(ruby-eval "vect.reverse")
 
-;; Variable persistence between calls:
-(ruby-exec "a = 5")
-(ruby-eval "a + 1")
+;; Running multiple slaves is possible by specifying `t' as a an
+;; optional second argument to `relisp-start-slave'.
 
+;; This stops the old slave first:
+(setq p1 (relisp-start-slave))
+;; This doesn't:
+(setq p2 (relisp-start-slave nil t))
+(ruby-exec "p=1" p1)
+(ruby-exec "p=2" p2)
+(ruby-eval "p" p1)
+(ruby-eval "p" p2)
+(relisp-stop-slave p1)
+(relisp-slave-alive-p p1)
+(relisp-stop-slave p2)
 
+;; How to specify a file when running the slave.  This ruby file runs
+;; some window stuff and then exits, i.e., it doesn't turn itself into
+;; a slave.
+(setq p (relisp-start-slave "ruby_slave2.rb"))
+(relisp-slave-alive-p p)
 
+;; This ruby file defines some methods, runs some frame stuff at
+;; startup, and then starts itself as a slave.
+(setq p (relisp-start-slave "ruby_slave.rb"))
+(relisp-slave-alive-p p)
+(ruby-exec "kill_the_new_buffer")
+(ruby-eval "ruby_elisp_eval")
+(ruby-eval "ruby_elisp_eval_ruby_eval")
+(ruby-exec "frame_class")

data/examples/elisp_master/ruby_slave.rb

@@ -0,0 +1,37 @@
+$:.unshift File.join(File.dirname(__FILE__), "../../lib") 
+require 'relisp'
+
+slave = Relisp::RubySlave.new
+
+def kill_the_new_buffer
+  switch_to_buffer('*relisp_test_buffer*')
+  kill_buffer
+end
+
+def ruby_elisp_eval
+  elisp_eval("(+ 1 5)")
+end
+
+def ruby_elisp_eval_ruby_eval
+  elisp_eval('(ruby-eval "(1 + 5)")')
+end   
+
+def frame_class
+  frame = Relisp::Frame.new({:width => 80, :height => 20, :name => "ruby frame"})
+  frame.height=30
+  frame.width=60
+  10.times { frame.width += 2 }
+  10.times { frame.width -= 2 }
+  10.times { frame.height += 2 }
+  10.times { frame.height -= 2 }
+  5.times { frame.height +=2; frame.width += 2 }
+  5.times { frame.height -=2; frame.width -= 2 }
+  frame.delete
+end 
+
+buffer = Relisp::Buffer.new('*relisp_test_buffer*')
+slave.display_buffer buffer
+buffer.insert "This buffer was created by the startup stuff in `ruby_slave.rb\'\n"
+buffer.insert "It will go away when you run `kill_the_new_buffer'"
+
+slave.start

data/examples/elisp_master/ruby_slave2.rb

@@ -0,0 +1,33 @@
+$:.unshift File.join(File.dirname(__FILE__), "../../lib") 
+require 'relisp'
+
+slave = Relisp::RubySlave.new
+
+w = slave.selected_window
+w2 = w.split_vertically
+w3 = w2.split_horizontally
+10.times do
+  w.shrink(1)
+  slave.redisplay
+  sleep 0.01
+end
+10.times do
+  w.enlarge(1)
+  slave.redisplay
+  sleep 0.01
+end
+10.times do
+  w2.shrink(0,1)
+  slave.redisplay
+  sleep 0.01
+end
+10.times do
+  w2.enlarge(0,1)
+  slave.redisplay
+  sleep 0.01
+end
+
+w2.delete
+w3.delete
+
+

data/examples/ruby_master/basic.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "../../lib") 
+
+require 'relisp'
+
+emacs = Relisp::ElispSlave.new
+
+puts "elisp_eval '(+ 1 2)'"
+puts '=> ' + emacs.elisp_eval("(+ 1 2)").to_s
+puts
+puts "elisp_exec '(+ 1 2)'"
+puts '=> ' + emacs.elisp_exec("(+ 1 2)").to_s
+puts "elisp_exec '(setq a (+ 1 2))'"
+puts '=> ' + emacs.elisp_exec("(setq a (+ 1 2))").to_s
+puts "elisp_eval 'a'"
+puts '=> ' + emacs.elisp_eval("a").to_s
+
+
+

data/examples/ruby_master/debugging.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "../../lib") 
+
+require 'relisp'
+
+emacs = Relisp::ElispSlave.new
+
+
+puts 'buffer = Relisp::Buffer.new("ruby-created-buffer"); buffer.to_s'
+emacs.debugging do  
+  @buffer = Relisp::Buffer.new("ruby-created-buffer")
+end
+puts '=> ' + @buffer.to_s
+
+puts
+
+puts "buffer.insert 'some text'; buffer.to_s"
+emacs.debugging do  
+  @buffer.insert 'some text'
+end
+puts '=> ' + @buffer.to_s
+
+puts
+puts "Hashes are currently the most complex thing to convert (press Enter to see it):"
+gets
+
+ruby_hash = ({ :time => "money",
+       :money => "power" })
+emacs.debugging do  
+  emacs.emacs_hash= ruby_hash
+end

data/examples/ruby_master/elisp_data_types.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "../../lib") 
+
+require 'relisp'
+
+emacs = Relisp::ElispSlave.new
+
+puts 'buffer = Relisp::Buffer.new("ruby-created-buffer"); buffer.to_s'
+buffer = Relisp::Buffer.new("ruby-created-buffer")
+puts '=> ' + buffer.to_s
+puts "buffer.insert 'some text'; buffer.to_s"
+buffer.insert 'some text'
+puts '=> ' + buffer.to_s
+puts 'buffer.name'
+puts '=> ' + buffer.name.to_s
+puts "buffer.name= 'fred'"
+puts '=> ' + buffer.name= 'fred'.to_s
+puts 'buffer.name'
+puts '=> ' + buffer.name
+
+puts
+
+puts 'emacs.create_file_buffer("blah.txt").class'
+puts '=> ' + emacs.create_file_buffer("blah.txt").class.to_s
+

data/examples/ruby_master/method_missing.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "../../lib") 
+
+require 'relisp'
+
+emacs = Relisp::ElispSlave.new
+
+puts "emacs.elisp_eval '(concat \"two\" \"words\")"
+puts '=> ' + (emacs.elisp_eval '(concat "two " "words")')
+puts "emacs.concat \"two\", \"words\""
+puts '=> ' + emacs.concat("two ", "words")
+
+puts
+
+puts 'emacs.set(:a, 3); emacs.symbol_value(:a)'
+emacs.set(:a, 3).to_s
+puts '=> ' + emacs.symbol_value(:a).to_s
+puts 'emacs.a'
+puts '=> ' + emacs.a.to_s
+puts 'emacs.a= 5; emacs.a'
+emacs.a= 5
+puts '=> ' + emacs.a.to_s
+

data/examples/ruby_master/recursive_calling.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "../../lib") 
+
+require 'relisp'
+
+emacs = Relisp::ElispSlave.new
+
+puts "emacs.elisp_eval '(ruby-eval \"1 + 3\")'"
+puts '=> ' + emacs.elisp_eval('(ruby-eval "1 + 3")').to_s
+

data/lib/relisp/elisp_functions.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (C) 2009 <don@ohspite.net>
+# Copyright (C) 2009, 2010 Don March
 #
 # This file is part of Relisp.
 #
@@ -83,23 +83,40 @@ module Relisp
 
     private
 
-    # Forward any missing method to elisp, writing the function and
-    # arguments in prefix notation (calling the +to_elisp+ method of
-    # each of the _args_).  
+    # Forward any missing method to elisp.  
+    #
+    # If a function with that name exists, write the rubyized (swap _
+    # for -) function and arguments in prefix notation (calling the
+    # +to_elisp+ method of each of the _args_).
+    #
+    # If a symbol with that name exists, return its value.  
+    #
+    # If the last char of the missing method is `=', set the symbol
+    # formed by the characters before the `=' to the first argument.
+    #
+    # For example:
+    #
+    #   emacs = Relisp::ElispSlave.new
+    #   puts emacs.concat "two", "words"
+    #   emacs.a= 5
+    #   puts emacs.a
     #
     # This automatically allows access to a large portion of elisp
-    # functions a rubyish way.  
+    # in a rubyish way.  
     #
     def method_missing(function, *args) # :doc:
-      function = function.to_s.gsub('_', '-')
-      unless elisp_eval("(functionp '#{function})")
-        raise NameError, "#{function} is not an elisp function"
-      end
+      lisp_name = function.to_s.gsub('_', '-')
 
-      elisp_eval('(' + 
-                 function + ' ' + 
-                 args.map{|a| a.to_elisp}.join(' ') +
-                 ')')
+      if elisp_eval "(functionp '#{lisp_name})"
+        elisp_eval "(#{lisp_name} #{args.map{|a| a.to_elisp}.join(' ')})"
+      elsif elisp_eval("(boundp '#{lisp_name})") && args.empty? # if there are args, it was meant to be a function
+        elisp_eval "#{lisp_name}"
+      elsif lisp_name[lisp_name.size-1..lisp_name.size-1] == "="
+        elisp_eval "(setq #{lisp_name[0..lisp_name.size-2]} #{args[0].to_elisp})"
+      else
+        raise NameError, "#{function} is undefined variable/method/function in Ruby and Elisp"
+      end
+#      elisp_eval("(if (functionp '#{function}) (#{function} #{args.map{|a| a.to_elisp}.join(' ')}) #{function})")
     end
     
   end