relisp 0.9.1 → 0.9.2

data/CHANGELOG

@@ -1,3 +1,13 @@
+== 0.9.2 / 2009-03-09
+
+* 3 minor enhancements
+  * Added a 'ruby-exec' lisp function that executes ruby code taking
+    the time to translate the result.
+  * Improved the 'elisp_exec' ruby function.
+  * Wrote test cases that cover a good chunk of a Relisp::Proxy
+    classes.
+  * Fixed whatever bugs that were found by writing the tests.
+
 == 0.9.1 / 2009-01-28
 
 * 2 major enhancements

data/Manifest

@@ -7,10 +7,13 @@ examples/elisp_master/elisp_master.el
 examples/elisp_master/ruby_slave
 examples/ruby_master/ruby_master_example
 lib/relisp.rb
-lib/relisp/editing_types.rb
 lib/relisp/elisp_functions.rb
-lib/relisp/programming_types.rb
 lib/relisp/slaves.rb
+lib/relisp/type_conversion.rb
+lib/relisp/type_conversion/editing_types.rb
+lib/relisp/type_conversion/programming_types.rb
+manual_test/tests.el
+manual_test/tests.rb
 setup.rb
 src/relisp.el
 src/relisp.elc

data/README

@@ -13,7 +13,7 @@ Emacs is great.  So is Ruby.  This purpose of this library is to:
 
 == Install
 
-   [sudo] gem install sundae
+   [sudo] gem install relisp
 
 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
@@ -110,7 +110,7 @@ The Emacs process is managed by <tt>Relisp::ElispSlave</tt>.
   require 'relisp'
   emacs = Relisp::ElispSlave.new
 
-Calls are made calling <tt>elisp_eval</tt> and <tt>elisp_execute</tt>
+Calls are made calling <tt>elisp_eval</tt> and <tt>elisp_exec</tt>
 on the ElispSlave object.
 
   emacs.elisp_eval "(+ 1 2)"
@@ -128,7 +128,7 @@ functions:
   emacs.*(5,2)                         # (* 5 2)
   emacs.create_file_buffer("blah.txt") # (create-file-buffer "blah.txt")
 
-Emacs editing types have (or will have) proxy classes:
+Emacs editing types have proxy classes with extensive functionality:
 
   buffer =  Relisp::Buffer.new("ruby-created-buffer")
      => #<Relisp::Buffer:0xb7c4784c>
@@ -144,7 +144,6 @@ use the <tt>ElispSlave#debugging</tt> method:
 
 == To Do
 
-* finish implementing emacs editting types (buffers, frames, etc.)
 * fix Windows bug(s)
 
 == Author

data/examples/elisp_master/elisp_master.el

@@ -10,10 +10,10 @@
 (ruby-eval "sample_ruby_method2")
 
 (member "ruby-created-buffer" (mapcar (lambda (a) (buffer-name a)) (buffer-list)))
-(ruby-eval "sample_ruby_method3")
+(ruby-exec "sample_ruby_method3")
 (member "ruby-created-buffer" (mapcar (lambda (a) (buffer-name a)) (buffer-list)))
 
-(ruby-eval "sample_ruby_method4")
+(ruby-exec "sample_ruby_method4")
 
 ;; How to start the ruby slave without a file. The rest of the
 ;; commands will work fine with a slave started either way.
@@ -48,9 +48,8 @@
 (ruby-eval "elisp_eval('(ruby-eval \"1 + 2\")')")
 
 ;; Variable persistence between calls:
-(ruby-eval "a = 5")
+(ruby-exec "a = 5")
 (ruby-eval "a + 1")
 
 
 
-

data/examples/elisp_master/ruby_slave

@@ -17,7 +17,10 @@ def sample_ruby_method3
 end
 
 def sample_ruby_method4
-  Relisp::Frame.new({:width => 80, :height => 20, :name => "ruby frame"})
+  frame=  Relisp::Frame.new({:width => 80, :height => 20, :name => "ruby frame"})
+  frame.height
+  frame.height=60
+  frame.height
 end 
 
 slave.start

data/lib/relisp/elisp_functions.rb

@@ -28,13 +28,14 @@ module Relisp
     #
     # This does not simply call the <tt>save-excursion</tt> function
     # in elisp, it is a rewrite to accept a ruby block.
+    #
     def save_excursion 
       raise ArgumentError unless block_given?
       begin
         start_point  = point()
         start_mark   = mark()
         start_buffer = current_buffer()
-        start_active = elisp_execute( "mark-active" )
+        start_active = elisp_eval( "mark-active" )
         yield
       ensure
         set_buffer(start_buffer)
@@ -44,6 +45,42 @@ module Relisp
       end
     end
 
+    # Save the current buffer; execute a block of code;
+    # restore the current buffer.
+    #
+    # This does not simply call the <tt>with-current-buffer</tt>
+    # function in elisp, it is a rewrite to accept a ruby block.
+    #
+    def with_current_buffer
+      raise ArgumentError unless block_given?
+      begin
+        start_buffer = current_buffer()
+        yield
+      ensure
+        set_buffer(start_buffer)
+      end
+    end
+
+    # Create a temporary buffer, and evaluate a block of code there.
+    #
+    # This does not simply call the <tt>with-temp-buffer</tt> function
+    # in elisp, it is a rewrite to accept a ruby block.
+    #
+    def with_temp_buffer
+      raise ArgumentError unless block_given?
+      begin
+        start_buffer = current_buffer()
+        temp_buffer = Relisp::Buffer.new("*temp--relisp--buffer*", self)
+        yield
+      ensure
+        set_buffer(start_buffer)
+        temp_buffer.kill
+      end
+    end
+
+    # TODO:    save_selected_window
+    # TODO:    with_selected_window
+
     private
 
     # Forward any missing method to elisp, writing the function and

data/lib/relisp/slaves.rb

@@ -44,14 +44,21 @@ module Relisp
     # each other.  This ruby library and the elisp code are tied to
     # one another so closely that I don't know if it matters, but it
     # still seemed like a bad idea to hard code the constants in both
-    # places.
-    ANSWER_CODE            = '___FORTYTWO___'
-    QUESTION_CODE          = '___TOBEORNOTTOBE___'
-    ERROR_CODE             = '___NO_THATSNOTTRUE_THATSIMPOSSIBLE___'
-    ENDOFMESSAGE_REGEXP   = Regexp.new(ANSWER_CODE + '|' + QUESTION_CODE + '|' + ERROR_CODE)
+    # places.  Just make sure that the order in the elisp function
+    # <tt>relisp-get-constants</tt> matches the ruby method
+    # <tt>send_constants</tt>.
+    CONSTANTS = Array.new
+    CONSTANTS << QUESTION_CODE     = '___TOBEORNOTTOBE___'
+    CONSTANTS << COMMAND_CODE      = '___THOUSHALT___'
+    CONSTANTS << BEGIN_ANSWER_CODE = '___WHATIS___'
+    CONSTANTS << ANSWER_CODE       = '___FORTYTWO___'
+    CONSTANTS << ERROR_CODE        = '___NO_THATSNOTTRUE_THATSIMPOSSIBLE___'
+    TRANSMISSION_CODES_REGEXP   = Regexp.new(CONSTANTS.join('|'))
+                                       
     # Every time ruby asks elisp to evaluate an expression, the result
     # is saved in this variable so ruby can access it if necessary.
-    PREVIOUS_ELISP_RESULT = :"--relisp--previous--result"
+    PREVIOUS_ELISP_RESULT = :"--relisp--previous--result" 
+    CONSTANTS << PREVIOUS_ELISP_RESULT
     # A prefix for elisp variables created by ruby.
     VARIABLE_PREFIX        = '--relisp--variable--'
 
@@ -79,17 +86,36 @@ module Relisp
     #
     def get_permanent_variable(old_variable)
       permanent_variable = new_elisp_variable
-      elisp_execute( "(setq #{permanent_variable} #{old_variable})" )
+      elisp_exec( "(setq #{permanent_variable} #{old_variable})" )
       return permanent_variable
     end
 
     # Run _code_ in the elisp process.
     #
-    def elisp_execute(code)
+    def elisp_exec(code)
+      code = code.to_s # maybe code is a symbol or something
+      write_to_emacs code
+      write_to_emacs COMMAND_CODE
+      receive_answer
+    end
+    
+    # Run _code_ in the elisp process and return the result as the
+    # corresponding ruby object.  If the ruby object is not going to
+    # be used, use elisp_exec instead.
+    #
+    def elisp_eval(code)
       code = code.to_s # maybe code is a symbol or something
       write_to_emacs code
       write_to_emacs QUESTION_CODE
+      to_ruby(receive_answer)
+    end
+
+    private 
 
+    # Handle messages from emacs after <tt>elisp_exec</tt> or
+    # <tt>elisp_eval</tt> are called.
+    #
+    def receive_answer
       output = ''
       output_line = read_from_emacs
       until output_line.strip == ANSWER_CODE
@@ -97,6 +123,11 @@ module Relisp
           write_to_emacs((eval(output, @local_binding)).to_elisp)
           write_to_emacs ANSWER_CODE
           output = ''
+        elsif output_line.strip == COMMAND_CODE
+          eval output, @local_binding
+#          write_to_emacs ""
+          write_to_emacs ANSWER_CODE
+          output = ''
         elsif output_line.strip == ERROR_CODE
           raise Relisp::ElispError, (eval output)
         else
@@ -108,17 +139,6 @@ module Relisp
       output.gsub!(/\n\z/, '')
       return output
     end
-    
-    # Run _code_ in the elisp process and return the result as the
-    # corresponding ruby object.  If the ruby object is not going to
-    # be used, use elisp_execute instead.
-    #
-    def elisp_eval(code)
-      result_string = elisp_execute(code)
-      to_ruby(result_string)
-    end
-
-    private 
 
     # Pass an elisp evaluation result to the appropriate Relisp class
     # for translation.  The first line of _result_string_ is the
@@ -128,8 +148,24 @@ module Relisp
     # be kept (in emacs) in the variable +PREVIOUS_ELISP_RESULT+.
     #
     def to_ruby(result_string)
+
+      # The result_string might have junk at the begining caused by
+      # whatever emacs sends to the echo area while evaluating ruby's
+      # instructions (it doesn't seem possible to get around this
+      # using with-output-to-string because the output from
+      # save-buffer and other functions is 'message'd).  It is also
+      # not possible to just pull off the last two elements, because
+      # sometimes the string representation of the result has newlines
+      # in it (Buffer#to_s, for example). Otherwise, you could just
+      # do:
+      #      object_string = result_string.pop
+      #      elisp_type    = result_string.pop
+
       result_string = result_string.split("\n")
-      elisp_type    = result_string.reverse!.pop
+      start_index = result_string.index(BEGIN_ANSWER_CODE) + 1
+      result_string = result_string[start_index..(result_string.size-1)]
+      
+      elisp_type = result_string.reverse!.pop
       object_string = result_string.reverse!.join("\n")
 
       object_info = {
@@ -150,8 +186,8 @@ module Relisp
 
     # Send the constants that ruby and elisp need to share.
     #
-    def pass_constants
-      [ANSWER_CODE, QUESTION_CODE, ERROR_CODE, PREVIOUS_ELISP_RESULT].each do |constant|
+    def send_constants 
+      CONSTANTS.each do |constant|
         read_from_emacs
         write_to_emacs constant
       end
@@ -203,7 +239,7 @@ module Relisp
     #
     def initialize
       super
-      pass_constants
+      send_constants
 
       if block_given?
         yield self
@@ -221,17 +257,26 @@ module Relisp
         loop do
           code = ''
           input = read_from_emacs
-          until input.strip == QUESTION_CODE
+          until input.strip == QUESTION_CODE || input.strip == COMMAND_CODE
             code << input
             input = read_from_emacs
           end
           code.gsub!(/\n\z/, '')
           
-          write_to_emacs((eval code, @local_binding).to_elisp)
+          if input.strip == QUESTION_CODE
+            write_to_emacs((eval code, @local_binding).to_elisp)
+          else
+            eval(code, @local_binding)
+          end
           write_to_emacs ANSWER_CODE
         end
       rescue => dag_yo
-        write_to_emacs dag_yo
+        msg = dag_yo.message + "\n"
+        dag_yo.backtrace.each do |b|
+          msg << "  " + b + "\n" 
+        end
+        write_to_emacs(msg)
+        #write_to_emacs(dag_yo.message)
         write_to_emacs ERROR_CODE
         retry
       end
@@ -291,7 +336,7 @@ module Relisp
 
       # gobble whatever output until emacs reports for duty
       until read_from_emacs.strip == "SEND CONSTANTS"; end
-      pass_constants
+      send_constants
     end
 
     attr_accessor :debug
@@ -325,7 +370,7 @@ module Relisp
     #
     def write_to_emacs(code)
       if @debug
-        puts "ruby> " + code.to_s unless code =~ ENDOFMESSAGE_REGEXP
+        puts "ruby> " + code.to_s unless code =~ TRANSMISSION_CODES_REGEXP
       end
       @emacs_pipe.puts code
     end
@@ -337,7 +382,7 @@ module Relisp
     def read_from_emacs
       output = @emacs_pipe.gets
       if @debug
-        puts "lisp> " + output unless output =~ ENDOFMESSAGE_REGEXP
+        puts "lisp> " + output unless output =~ TRANSMISSION_CODES_REGEXP
       end
       return output
     end