relisp 0.9.0 → 0.9.1

data/CHANGELOG

@@ -1,3 +1,11 @@
+== 0.9.1 / 2009-01-28
+
+* 2 major enhancements
+  * Cons are now proxy objects.  If the cons is a list, it can be
+    converted to a Relisp::List, a subclass of Array.
+  * Editing types are now subclasses of a Relisp::Proxy class that
+    takes care of creating the wrapping over the elisp variable.
+
 == 0.9.0 / 2009-01-25
 
 * 1 major enhancement

data/Manifest

@@ -8,11 +8,13 @@ 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
 setup.rb
 src/relisp.el
 src/relisp.elc
 test/test_editing_types.rb
+test/test_elisp_functions.rb
 test/test_programming_types.rb
 test/test_slaves.rb

data/examples/elisp_master/elisp_master.el

@@ -13,6 +13,8 @@
 (ruby-eval "sample_ruby_method3")
 (member "ruby-created-buffer" (mapcar (lambda (a) (buffer-name a)) (buffer-list)))
 
+(ruby-eval "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.
 

data/examples/elisp_master/ruby_slave

@@ -16,4 +16,8 @@ def sample_ruby_method3
   Relisp::Buffer.new("ruby-created-buffer")
 end
 
+def sample_ruby_method4
+  Relisp::Frame.new({:width => 80, :height => 20, :name => "ruby frame"})
+end 
+
 slave.start

data/lib/relisp/editing_types.rb

@@ -42,45 +42,254 @@
 
 module Relisp
 
-  # A Buffer object just holds onto the Emacs buffer in an elisp
-  # variable and acts as a proxy.
+  # Proxy contains the code that creates a wrapper around a variable
+  # in emacs.
   #
-  class Buffer
+  class Proxy
     def self.from_elisp(object)
       new(object[:variable], object[:slave])
     end
 
-    # When _var_or_name_ is a symbol it is considered to be the name
-    # of a pre-existing buffer in the _slave_ process.  If
-    # _var_or_name_ is a string, a new buffer is created with a name
-    # based on that string. 
-    def initialize(var_or_name, slave = Relisp.default_slave)
-      @slave = slave
+    # If the last argument is a Relisp::Slave, it gets pulled off and
+    # used as the slave; otherwise Relisp.default_slave is used.  If
+    # the first argument is a Symbol, it is assumed to be the name of
+    # an elisp variable which needs a proxy.  If the first argument
+    # isn't a Symbol, all of the arguments (except the last, if it was
+    # a Slave) are send off to the child to handle.
+    #
+    def initialize(*args)
+      @slave = if args.last.kind_of?(Relisp::Slave)
+                 args.pop
+               else
+                 Relisp.default_slave
+               end
 
-      if var_or_name.kind_of?( Symbol )
-        @elisp_variable = @slave.get_permanent_variable(var_or_name)
+      if args[0].kind_of?(Symbol)
+        @elisp_variable = @slave.get_permanent_variable(args[0])
+        elisp_type= ""
+        self.class.to_s.split("::").last.split(//).each_with_index do |char, index|
+          unless index==0 || char == char.downcase
+            elisp_type << "-"
+          end
+          elisp_type << char.downcase
+        end
 
-        unless @slave.elisp_eval("(type-of #{@elisp_variable})") == :buffer
-          raise ArgumentError, "#{@elisp_variable} isn't a buffer"
+        unless @slave.elisp_eval("(type-of #{@elisp_variable})") == elisp_type.to_sym
+          raise ArgumentError, "#{@elisp_variable} isn't a #{elisp_type}"
         end
-      elsif var_or_name.kind_of?( String )
-        @slave.elisp_execute("(generate-new-buffer #{var_or_name.to_elisp})")
-        @elisp_variable = @slave.get_permanent_variable(Relisp::Slave::PREVIOUS_ELISP_RESULT)
       else
-        raise ArgumentError
+        @elisp_variable = @slave.new_elisp_variable
+        yield args
       end
     end
+  
+    attr_reader :slave, :elisp_variable
 
     def to_elisp
       @elisp_variable
     end
+  end
+
+  # A proxy to an Emacs buffer.
+  #
+  class Buffer < Proxy
 
-    # Return the name of the buffer.
+    # _args_ can be any of these forms:
+    # * (_symbol_, <em>slave = Relisp.default_slave</em>)
+    # * (_string_, <em>slave = Relisp.default_slave</em>)
+    # * (<em>slave = Relisp.default_slave</em>)
     #
+    # When a _symbol_ is given it is considered to be the name of a
+    # pre-existing bufer in the _slave_ process.  Otherwise a new,
+    # buffer is created (<tt>generate-new-buffer</tt>).  The name is
+    # _string_, if given, and a variant of "relisp-buffer" otherwise.
+    #
+    def initialize(*args)
+      super do |args|
+        name = args[0] ? args[0] : "relisp-buffer"
+        raise ArgumentError unless name.kind_of?(String)
+        @slave.elisp_execute( "(setq #{@elisp_variable} (generate-new-buffer #{name.to_elisp}))" )      
+      end
+    end
+
+    # Return the name of Buffer, as a string (<tt>buffer-name</tt>).
     def name
-      @slave.elisp_eval "(buffer-name #{@elisp_variable})"
+      @slave.buffer_name(@elisp_variable.value)
+    end
+
+    # Save the buffer in its visited file, if it has been modified.
+    #
+    def save
+      @slave.elisp_eval <<-EOM
+        (save-excursion
+          (set-buffer #{@elisp_variable})
+          (save-buffer))
+      EOM
+    end
+  end
+
+  # A  proxy to an Emacs marker.
+  #
+  class Marker < Proxy
+
+    # _args_ can be any of these forms:
+    # * (_symbol_, <em>slave = Relisp.default_slave</em>)
+    # * (<em>slave = Relisp.default_slave</em>)
+    #
+    # When a _symbol_ is given it is considered to be the name of a
+    # pre-existing marker in the _slave_ process.  Otherwise a new,
+    # empty marker is created (<tt>make-marker</tt>).
+    #
+    def initialize(*args)
+      super do 
+        @slave.elisp_execute( "(setq #{@elisp_variable} (make-marker))" )
+      end
     end
+
+    # Return a newly allocated marker which does not point at any
+    # position (<tt>make-marker</tt>).
+    #
+    def self.make(slave = Relisp.default_slave)
+      slave.make_marker
+    end
+
   end
 
+  # A  proxy to an Emacs window
+  #
+  class Window < Proxy
+
+    # _args_ must be of the form (_symbol_, <em>slave =
+    # Relisp.default_slave</em>)
+    #
+    # The _symbol_ argument is considered to be the name of a
+    # pre-existing window in the _slave_ process.  
+    #
+    def initialize(*args)
+      super do 
+        raise ArgumentError, "Cannot create Window using 'new' method."
+      end
+    end
+  end
+
+  # A proxy to an Emacs frame
+  #
+  class Frame < Proxy
+
+    # _args_ can be any of these forms:
+    # * (_symbol_, <em>slave = Relisp.default_slave</em>)
+    # * (<em>option_hash = {}</em>, <em>slave = Relisp.default_slave</em>)
+    # * (<em>slave = Relisp.default_slave</em>)
+    #
+    # When a _symbol_ is given it is considered to be the name of a
+    # pre-existing frame in the _slave_ process.  Otherwise a new,
+    # frame is created using any options in (<tt>new-frame</tt>).
+    #
+    # The _option_hash_ can specify the following
+    # [<tt>:name =></tt> _string_] 
+    #      The frame should be named _string_.
+    # [<tt>:width =></tt> _fixnum_] 
+    #      The frame should be _fixnum_ characters in width.
+    # [<tt>:height =></tt> _fixnum_] 
+    #      The frame should be _fixnum_ text lines high.
+    #
+    # You cannot specify either :width or :height, you must use neither or both.
+    #
+    # [<tt>:minibuffer => true</tt>]
+    #      The frame should have a minibuffer.
+    # [<tt>:minibuffer => nil</tt>]
+    #      The frame should have no minibuffer.
+    # [<tt>:minibuffer => :only</tt>] 
+    #      The frame should contain only a minibuffer.
+    # [<tt>:minibuffer =></tt> _window_] 
+    #      The frame should use _window_ as its minibuffer window.
+    #
+    # [<tt>:"window-system" => nil</tt>] 
+    #      The frame should be displayed on a terminal device.
+    # [<tt>:"window-system" => :x</tt>] 
+    #      The frame should be displayed in an X window.
+    # [<tt>:terminal =></tt> _id_] 
+    #      The frame should use the terminal identified by _id_.
+    #
+    def initialize(*args)
+      super do |args|
+        hash = args[0]
+        alist = ""
+        if hash && hash.size > 1
+          alist << "'("
+          hash.each_pair do |key, val|
+            val = if val.kind_of?(Symbol)
+                    val.value.to_elisp
+                  else
+                    val.to_elisp
+                  end
+            alist << "(#{key} . #{val.to_s}) "
+          end
+          alist << ")"
+        end
+
+        @slave.elisp_execute( "(setq #{@elisp_variable} (new-frame #{alist}))" )
+      end
+    end
+
+  end
+
+  # A  proxy to an Emacs window-configuration
+  #
+  class WindowConfiguration < Proxy
+
+    # _args_ must be of the form (_symbol_, <em>slave =
+    # Relisp.default_slave</em>)
+    #
+    # The _symbol_ argument is considered to be the name of a
+    # pre-existing window-configuration in the _slave_ process.  
+    #
+    def initialize(*args)
+      super do 
+        raise ArgumentError, "Cannot create WindowConfiguration using 'new' method."
+      end
+    end
+  end
+
+  # A  proxy to an Emacs frame-configuration
+  #
+  class FrameConfiguration < Proxy
+
+    # _args_ must be of the form (_symbol_, <em>slave =
+    # Relisp.default_slave</em>)
+    #
+    # The _symbol_ argument is considered to be the name of a
+    # pre-existing frame-configuration in the _slave_ process.  
+    #
+    def initialize(*args)
+      @elisp_type = :cons
+      @elisp_test_type_function = "frame-configuration-p"
+
+      super do 
+        raise ArgumentError, "Cannot create FrameConfiguration using 'new' method."
+      end
+    end
+  end
+
+
+#   # A  proxy to an Emacs [OBJECT]
+#   #
+#   class [CLASS] < Proxy
+
+#     # _args_ can be any of these forms:
+#     # * (_symbol_, <em>slave = Relisp.default_slave</em>)
+#     # * (<em>slave = Relisp.default_slave</em>)
+#     #
+#     # When a _symbol_ is given it is considered to be the name of a
+#     # pre-existing [TYPE] in the _slave_ process.  Otherwise a new,
+#     # empty [TYPE] is created (<tt>[FUNCTION]</tt>).
+#     #
+#     def initialize(*args)
+#       super do 
+#         @slave.elisp_execute( "(setq #{@elisp_variable} (FUNCTION))" )
+#       end
+#     end
+#   end
+
 end
 

data/lib/relisp/elisp_functions.rb

@@ -0,0 +1,69 @@
+#--
+# Copyright (C) 2009 <don@ohspite.net>
+#
+# This file is part of Relisp.
+#
+# Relisp is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#  
+# Relisp is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see
+# <http://www.gnu.org/licenses/>.
+#++
+#
+#
+
+module Relisp
+  class Slave
+
+    # Save point, mark, and current buffer; execute a block of code;
+    # restore those things.
+    #
+    # 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" )
+        yield
+      ensure
+        set_buffer(start_buffer)
+        set(:"mark-active", start_active)
+        goto_char(start_point)
+        set_mark(start_mark)
+      end
+    end
+
+    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_).  
+    #
+    # This automatically allows access to a large portion of elisp
+    # functions 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
+
+      elisp_eval('(' + 
+                 function + ' ' + 
+                 args.map{|a| a.to_elisp}.join(' ') +
+                 ')')
+    end
+    
+  end
+end

data/lib/relisp/programming_types.rb

@@ -54,9 +54,9 @@
 #
 # Every type in the first group obviously matches a ruby class except
 # for 'Cons' and 'Vector'.  The types that have an analogous ruby
-# class are mapped directly to that class.  'Cons' and 'Vector' are
-# mapped to a corresponding subclass of Array; the only difference
-# between the two is how they are translated back to elisp.
+# class are mapped directly to that class.  'Cons' is a kept in a
+# proxy object in the same way as the editting data types.  'Vector'
+# is mapped to a corresponding subclass of Array.
 #
 # Every ruby class that corresponds to a elisp data type is duplicated
 # inside the Relisp module with the rubyized version of the elisp
@@ -110,10 +110,140 @@ module Relisp
     def to_elisp
       "'" + self.to_s
     end
+
+    def value
+      VariableValue.new(self)
+    end
+  end
+
+  # This exists so that the value of a Relisp::Symbol type can be
+  # conveniently passed to elisp.
+  #   
+  #   @slave.buffer_name(@elisp_variable)
+  #      => Relisp::ElispError: Wrong type argument: bufferp, --relisp--variable--1
+  #   @slave.buffer_name(@elisp_variable.value)
+  #      => "my buffer"
+  #
+  class VariableValue
+    def initialize(variable)
+      @variable = variable
+    end
+
+    def to_elisp
+      @variable.to_s
+    end
+  end
+
+  #
+#   class Cons < Proxy
+#     def self.from_elisp(object)
+#       slave = object[:slave]
+#       object_variable = slave.get_permanent_variable(object[:variable])
+#       car = slave.elisp_eval("(car #{object_variable})")
+#       cdr = slave.elisp_eval("(cdr #{object_variable})")
+#       new(car, cdr)
+#     end
+
+#     def initialize(car, cdr)
+#       @car = car
+#       @cdr = cdr
+#     end
+
+#     attr_accessor :car, :cdr
+
+#     def to_list
+#     end
+
+#     def inspect
+#       to_s
+#     end
+
+#     def to_s
+#       str = "(" + car.inspect
+#       if @cdr
+#         cdr = @cdr
+#         while cdr.kind_of?(Cons)
+#           str << " #{cdr.car.inspect}"
+#           cdr = cdr.cdr
+#         end
+#         str << " . #{cdr.inspect}" unless cdr == nil
+#       str << ")"
+#       end
+#     end
+
+#     def to_elisp
+#       str = "(cons #{@car.to_elisp} #{@cdr.to_elisp})"
+#     end
+#  end
+
+  # A proxy to an Emacs cons. If the cons is actually a list, the
+  # to_list method will convert it a subclass of Array so that all of
+  # the ruby Array stuff is available.
+  #
+  class Cons < Proxy
+
+    # _args_ must be of the form (_symbol_, <em>slave =
+    # Relisp.default_slave</em>)
+    #
+    # The _symbol_ argument is considered to be the name of a
+    # pre-existing window in the _slave_ process.  
+    #
+    def initialize(*args)
+      super do 
+        raise ArgumentError, "Cannot create Cons using 'new' method."
+      end
+    end
+
+    def car
+      @slave.car(@elisp_variable.value)
+    end
+
+    def cdr
+      @slave.cdr(@elisp_variable.value)
+    end
+
+    # This function will NOT return true whenever the elisp function
+    # <tt>listp</tt> is true.  The elisp function is true whenever the
+    # object is a cons cell, but this method is true only when the
+    # cons can be unambiguously translated to an array; this condition
+    # is satisfied when the object in question could have been written
+    # using the elisp function +list+.
+    #
+    def list?
+      current_cdr = cdr
+      while current_cdr.kind_of?(Cons)
+        current_cdr = current_cdr.cdr
+      end
+      if current_cdr.nil?
+        return true
+      else
+        return false
+      end
+    end
+
+    # Translate the cons cell into a Relisp::List, a subclass of
+    # Array.  See list? for when this be done.
+    #
+    def to_list
+      list_array = []
+      list_array << car
+      current_cdr = cdr
+      while current_cdr.kind_of?(Cons)
+        list_array << current_cdr.car
+        current_cdr = current_cdr.cdr
+      end
+
+      if current_cdr.nil?
+        return Relisp::List.new(list_array)
+      else
+        return false
+      end
+    end
+
   end
 
 
-  class Cons < Array
+  class List < Array
     def self.from_elisp(object)
       new(super(object))
     end
@@ -173,7 +303,9 @@ module Relisp
                               (setq #{vals_var} (append #{vals_var} (list val)))) #{object_variable})" )
       keys = slave.elisp_eval( keys_var )
       vals = slave.elisp_eval( vals_var )
-      keys ||= []
+      keys ||= nil
+      keys = keys.to_list
+      vals = vals.to_list
       hash = Hash.new
       keys.each_index do |i|
         hash[keys[i]] = vals[i]
@@ -242,10 +374,10 @@ end
 
 
 # The normal Array class is modified so that an array can be converted
-# to either Relisp::Cons or Relisp::Vector.
+# to either Relisp::List or Relisp::Vector.
 #
 class Array
-  @@default_elisp_type = Relisp::Cons
+  @@default_elisp_type = Relisp::List
 
   # Converts either a 'cons' or 'vector' to a ruby array.
   def self.from_elisp(object)
@@ -291,3 +423,5 @@ class Array
     elisp_type.new(self).to_elisp
   end
 end
+
+

data/lib/relisp/slaves.rb

@@ -18,8 +18,7 @@
 # <http://www.gnu.org/licenses/>.
 #++
 #
-# TODO:
-# * maybe catch Errno::EPIPE to see if slave died
+# TODO: maybe catch Errno::EPIPE to see if slave died
 
 module Relisp
 
@@ -158,25 +157,6 @@ module Relisp
       end
     end
 
-    # Forward any missing method to elisp, writing the function and
-    # arguments in prefix notation (calling the +to_elisp+ method of
-    # each of the _args_).  
-    #
-    # This automatically allows access to a large portion of elisp
-    # functions 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
-
-      elisp_eval('(' + 
-                 function + ' ' + 
-                 args.map{|a| a.to_elisp}.join(' ') +
-                 ')')
-    end
-    
     public
     
     # Creates a method in the slave that is a reference to the
@@ -327,11 +307,12 @@ module Relisp
           @debug = true
           puts
           puts "-----------------"
-          yield
+          result = yield
         ensure
           @debug = debug_original_val
           puts "-----------------"
         end
+        return result
       else
         @debug = ! @debug
       end

data/lib/relisp.rb

@@ -19,12 +19,12 @@
 #++
 
 module Relisp
-  VERSION = '0.9.0'
+  VERSION = '0.9.1'
 
   class ElispError < RuntimeError; end
 end
 
-require 'relisp/slaves'
-require 'relisp/programming_types'
 require 'relisp/editing_types'
-
+require 'relisp/elisp_functions.rb'
+require 'relisp/programming_types'
+require 'relisp/slaves'

data/setup.rb

@@ -1370,7 +1370,6 @@ class Installer
   end
 
   def install_dir_conf(rel)
-    # FIXME: should not remove current config files
     # (rename previous file to .old/.org)
     install_files targetfiles(), "#{config('sysconfdir')}/#{rel}", 0644
   end

data/src/relisp.el

@@ -69,12 +69,13 @@
 
 (defun relisp-log (text)
   "Insert TEXT at the end of `relisp-buffer-name', unless emacs is the slave."
-  (when relisp-emacs-master-p
-    (get-buffer-create relisp-buffer-name)
-    (unless (string-match (relisp-endofmessage-regexp) (relisp-strip text))
-      (set-buffer relisp-buffer-name)
-      (goto-char (point-max))
-      (insert text "\n"))))
+  (save-excursion
+    (when relisp-emacs-master-p
+      (get-buffer-create relisp-buffer-name)
+      (unless (string-match (relisp-endofmessage-regexp) (relisp-strip text))
+	(set-buffer relisp-buffer-name)
+	(goto-char (point-max))
+	(insert text "\n")))))
 
 (defun relisp-write-to-ruby (message)
   "Send MESSAGE to the ruby process."

data/test/test_editing_types.rb

@@ -7,6 +7,34 @@ require 'relisp'
 
 
 module TestRelisp
+  class TestProxy < Test::Unit::TestCase
+    def setup
+      @emacs = Relisp::ElispSlave.new
+    end
+  
+    def test_class_from_elisp
+      test_buffer_name = "*relisp-test-buffer*"
+      buffer = @emacs.elisp_eval( "(create-file-buffer \"#{test_buffer_name}\") " )
+      assert_kind_of Relisp::Buffer, buffer
+      buffer_names = @emacs.elisp_eval( '(buffer-list)' ).to_list.map { |buffer| buffer.name } 
+      assert buffer_names.include?(test_buffer_name)
+    end
+
+    # This is really tested in all of the other classes.
+    def test_initialize
+      new_buffer = Relisp::Buffer.new("new-buffer")
+      assert_kind_of Relisp::Buffer, new_buffer
+      assert_equal "new-buffer", new_buffer.name
+    end
+
+    def test_to_elisp
+      test_buffer_name = "*relisp-test-buffer*"
+      buffer = @emacs.elisp_eval( "(create-file-buffer \"#{test_buffer_name}\") " )
+      assert_equal :buffer, @emacs.elisp_eval("(type-of #{buffer.to_elisp})")
+    end
+  end
+
+
   class TestBuffer < Test::Unit::TestCase
     def setup
       @emacs = Relisp::ElispSlave.new
@@ -16,7 +44,7 @@ module TestRelisp
       test_buffer_name = "*relisp-test-buffer*"
       buffer = @emacs.elisp_eval( "(create-file-buffer \"#{test_buffer_name}\") " )
       assert_kind_of Relisp::Buffer, buffer
-      buffer_names = @emacs.elisp_eval( '(buffer-list)' ).map { |buffer| buffer.name } 
+      buffer_names = @emacs.elisp_eval( '(buffer-list)' ).to_list.map { |buffer| buffer.name } 
       assert buffer_names.include?(test_buffer_name)
     end
 
@@ -24,6 +52,8 @@ module TestRelisp
       new_buffer = Relisp::Buffer.new("new-buffer")
       assert_kind_of Relisp::Buffer, new_buffer
       assert_equal "new-buffer", new_buffer.name
+      found_buffer = @emacs.get_buffer(new_buffer.name)
+      assert_kind_of Relisp::Buffer, found_buffer
     end
 
     def test_to_elisp
@@ -37,7 +67,78 @@ module TestRelisp
       buffer = @emacs.elisp_eval( "(create-file-buffer \"#{test_buffer_name}\") " )
       assert_equal test_buffer_name, buffer.name
     end
+  end
+
+  class TestMarker < Test::Unit::TestCase
+    def setup
+      @emacs = Relisp::ElispSlave.new
+    end
+
+    def test_class_from_elisp
+      assert_kind_of Relisp::Marker, @emacs.point_marker
+      assert @emacs.elisp_eval( "(equal #{@emacs.point_marker.to_elisp} (point-marker))" )
+      assert_kind_of Relisp::Marker, Relisp::Marker.new
+    end
+
+    def test_class_make
+      assert_kind_of Relisp::Marker, Relisp::Marker.make
+    end
+
+    def test_to_elisp
+      assert_equal :marker, @emacs.elisp_eval( "(type-of #{@emacs.point_marker.to_elisp})" )
+    end
+  end
+
+  class TestWindow < Test::Unit::TestCase
+    def setup
+      @emacs = Relisp::ElispSlave.new
+    end
+
+    def test_class_from_elisp
+      assert_kind_of Relisp::Window, @emacs.selected_window
+    end
+  end
+
+  class TestFrame < Test::Unit::TestCase
+    def setup
+      @emacs = Relisp::ElispSlave.new
+    end
+
+    def test_class_from_elisp
+      assert_kind_of Relisp::Frame, @emacs.selected_frame
+    end
+    
+    def test_initialize
+      new_frame = Relisp::Frame.new
+      assert_kind_of Relisp::Frame, new_frame
+      assert_equal :frame,  @emacs.elisp_eval( "(type-of #{new_frame.to_elisp})")
+      new_frame = Relisp::Frame.new({:width => 30, :height => 20})
+      assert_kind_of Relisp::Frame, new_frame
+      assert_equal :frame,  @emacs.elisp_eval( "(type-of #{new_frame.to_elisp})")
+    end
+  end
+
+  class TestWindowConfiguration < Test::Unit::TestCase
+    def setup
+      @emacs = Relisp::ElispSlave.new
+    end
+
+    def test_class_from_elisp
+      assert_kind_of Relisp::WindowConfiguration, @emacs.current_window_configuration
+    end
+  end
 
+  class TestFrameConfiguration < Test::Unit::TestCase
+    def setup
+      @emacs = Relisp::ElispSlave.new
+    end
+
+    def test_class_from_elisp
+#      assert_kind_of Relisp::WindowConfiguration, @emacs.current_frame_configuration
+      assert_kind_of Relisp::Cons, @emacs.current_frame_configuration
+      assert_equal :"frame-configuration", @emacs.current_frame_configuration.car
+    end
   end
+
 end
 

data/test/test_elisp_functions.rb

@@ -0,0 +1,39 @@
+# Code Generated by ZenTest v. 3.11.1
+
+require 'test/unit' unless defined? $ZENTEST and $ZENTEST
+
+$:.unshift File.dirname(__FILE__) + "/../lib" 
+require 'relisp'
+
+module TestRelisp
+  class TestSlave < Test::Unit::TestCase
+    # setup done in test_slaves.rb
+    #     def setup
+    #       @emacs = Relisp::ElispSlave.new
+    #     end
+
+    def test_save_excursion
+      # TODO: test mark, mark-active
+      start_point = @emacs.point
+      start_buffer = @emacs.current_buffer
+      @emacs.save_excursion do 
+        @emacs.insert("move along")
+        assert_not_equal start_point, @emacs.point
+        buffer = Relisp::Buffer.new("--relisp--test--", @emacs)
+        @emacs.switch_to_buffer(buffer)
+        assert_not_equal start_buffer.name, @emacs.current_buffer.name
+      end
+      assert_equal start_point, @emacs.point
+      assert_equal start_buffer.name, @emacs.current_buffer.name
+    end
+
+    def test_method_missing
+      assert_equal 6, @emacs.+(1, 2, 3)
+      assert_raise NameError do
+        @emacs.utter_nonsense
+      end
+    end
+  end
+end
+
+

data/test/test_programming_types.rb

@@ -22,7 +22,7 @@ class TestArray < Test::Unit::TestCase
   end
 
   def test_class_from_elisp
-    assert "if from_elisp works for Vector and Cons, then this works"
+    assert "if from_elisp works for Vector and List, then this works"
   end
 
   def test_class_default_elisp_type_equals
@@ -31,12 +31,12 @@ class TestArray < Test::Unit::TestCase
     end
     Array.default_elisp_type = Relisp::Vector    
     assert_equal Relisp::Vector, Array.default_elisp_type
-    Array.default_elisp_type = Relisp::Cons
-    assert_equal Relisp::Cons, Array.default_elisp_type
+    Array.default_elisp_type = Relisp::List
+    assert_equal Relisp::List, Array.default_elisp_type
   end
 
   def test_to_elisp
-    Array.default_elisp_type = Relisp::Cons
+    Array.default_elisp_type = Relisp::List
     assert_equal :cons, @emacs.elisp_eval( "(type-of #{[1, 2, 3].to_elisp})" )
     Array.default_elisp_type = Relisp::Vector
     assert_equal :vector, @emacs.elisp_eval( "(type-of #{[1, 2, 3].to_elisp})" )
@@ -53,7 +53,7 @@ class TestArray < Test::Unit::TestCase
   end
 
   def test_elisp_type_equals
-    Array.default_elisp_type = Relisp::Cons
+    Array.default_elisp_type = Relisp::List
     array = [1, 2, 3]
     assert_equal :cons, @emacs.elisp_eval( "(type-of #{array.to_elisp})" )
     array.elisp_type = Relisp::Vector
@@ -124,18 +124,49 @@ module TestRelisp
       @emacs = Relisp::ElispSlave.new
     end
 
+    def test_car
+      result = @emacs.elisp_eval( "'(1 2 3)" )
+      assert_equal 1, result.car
+    end
+
+    def test_cdr
+      result = @emacs.elisp_eval( "'(1 2 3)" )
+      assert_equal @emacs.elisp_eval( "'(2 3)" ).to_list, result.cdr.to_list
+    end
+
+    def test_list_eh
+      result = @emacs.elisp_eval( "'(1 2 3)" )
+      assert result.list?
+      result = @emacs.elisp_eval( "'(1 . 2)" )      
+      assert ! result.list?
+    end
+
+    def test_to_list
+      result = @emacs.elisp_eval( "'(1 2 3)" ).to_list
+      assert_equal [1, 2, 3], result
+      result = @emacs.elisp_eval( "'(1 . 2)" )      
+      assert ! result.to_list
+    end
+
+   end
+
+  class TestList < Test::Unit::TestCase
+    def setup
+      @emacs = Relisp::ElispSlave.new
+    end
+
     def test_class_from_elisp
-      Array.default_elisp_type = Relisp::Cons
-      result = @emacs.elisp_eval( "'(1 \"string\" 3 [4 5] )" )
-      assert result.kind_of?(Array)
-      assert_equal Relisp::Cons, result.class
+      Array.default_elisp_type = Relisp::List
+      result = @emacs.elisp_eval( "'(1 \"string\" 3 [4 5] )" ).to_list
+      assert_kind_of Array, result
+      assert_equal Relisp::List, result.class
       assert_equal "string", result[1]
       assert_equal [4, 5], result[3]
     end
 
     def test_to_elisp
       list = [1,2,'a',[4,5]]
-      list.elisp_type = Relisp::Cons
+      list.elisp_type = Relisp::List
       assert @emacs.elisp_eval( "(equal (list 1 2 \"a\" (list 4 5)) #{list.to_elisp})" )
       assert @emacs.elisp_eval( "(equal (list 1 2 \"a\" (list 4 5)) (ruby-eval \"[1, 2, 'a', [4, 5]]\"))" )
       assert_equal 1, @emacs.elisp_eval( "(car #{list.to_elisp})" )

data/test/test_slaves.rb

@@ -72,12 +72,6 @@ module TestRelisp
       assert_equal test_array, @emacs.test_array
     end
 
-    def test_method_missing
-      assert_equal 6, @emacs.+(1, 2, 3)
-      assert_raise NameError do
-        @emacs.utter_nonsense
-      end
-    end
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: relisp
 version: !ruby/object:Gem::Version 
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors: 
 - Don
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-26 00:00:00 -05:00
+date: 2009-01-28 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -41,6 +41,7 @@ files:
 - 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
 - setup.rb
@@ -60,6 +61,7 @@ files:
 - tasks/svn.rake
 - tasks/test.rake
 - test/test_editing_types.rb
+- test/test_elisp_functions.rb
 - test/test_programming_types.rb
 - test/test_slaves.rb
 has_rdoc: true
@@ -107,4 +109,5 @@ summary: Call ruby from emacs and call elisp from ruby. If you never did you sho
 test_files: 
 - test/test_editing_types.rb
 - test/test_programming_types.rb
+- test/test_elisp_functions.rb
 - test/test_slaves.rb