sexp_processor 4.9.0 → 4.10.0b1

data/lib/sexp_processor.rb

@@ -1,6 +1,6 @@
 $TESTING = false unless defined? $TESTING
 
-require 'sexp'
+require "sexp"
 
 ##
 # SexpProcessor provides a uniform interface to process Sexps.
@@ -33,7 +33,8 @@ require 'sexp'
 
 class SexpProcessor
 
-  VERSION = "4.9.0"
+  # duh
+  VERSION = "4.10.0b1"
 
   ##
   # Automatically shifts off the Sexp type before handing the
@@ -102,7 +103,7 @@ class SexpProcessor
 
     dirs.flatten.map { |p|
       if File.directory? p then
-        Dir[File.join(p, '**', "*.{#{extensions.join(',')}}")]
+        Dir[File.join(p, "**", "*.{#{extensions.join ","}}")]
       else
         p
       end
@@ -160,7 +161,10 @@ class SexpProcessor
     end
   end
 
-  def assert_empty(meth, exp, exp_orig)
+  ##
+  # Raise if +exp+ is not empty.
+
+  def assert_empty meth, exp, exp_orig
     unless exp.empty? then
       msg = "exp not empty after #{self.class}.#{meth} on #{exp.inspect}"
       msg += " from #{exp_orig.inspect}" if $DEBUG
@@ -168,30 +172,39 @@ class SexpProcessor
     end
   end
 
-  def rewrite(exp)
-    type = exp.first
+  ##
+  # Rewrite +exp+ using rewrite_* method for +exp+'s sexp_type, if one
+  # exists.
+
+  def rewrite exp
+    type = exp.sexp_type
+
+    comments = exp.comments
 
-    if @debug.has_key? type then
+    if @debug.key? type then
       str = exp.inspect
       puts "// DEBUG (original ): #{str}" if str =~ @debug[type]
     end
 
     in_context type do
-      exp.map! { |sub| Array === sub ? rewrite(sub) : sub }
+      exp = exp.map { |sub| Array === sub ? rewrite(sub) : sub }
     end
 
-    begin
+    loop do
       meth = @rewriters[type]
       exp  = self.send(meth, exp) if meth
       break unless Sexp === exp
 
-      if @debug.has_key? type then
+      if @debug.key? type then
         str = exp.inspect
         puts "// DEBUG (rewritten): #{str}" if str =~ @debug[type]
       end
 
-      old_type, type = type, exp.first
-    end until old_type == type
+      old_type, type = type, exp.sexp_type
+      break if old_type == type
+    end
+
+    exp.comments = comments
 
     exp
   end
@@ -201,8 +214,13 @@ class SexpProcessor
   # the Sexp type given.  Performs additional checks as specified by
   # the initializer.
 
-  def process(exp)
+  def process exp
     return nil if exp.nil?
+
+    unless Sexp === exp then
+      raise SexpTypeError, "exp must be a Sexp, was #{exp.class}:#{exp.inspect}"
+    end
+
     if self.context.empty? then
       p :rewriting unless debug.empty?
       exp = self.rewrite(exp)
@@ -210,7 +228,7 @@ class SexpProcessor
     end
 
     unless @unsupported_checked then
-      m = public_methods.grep(/^process_/) { |o| o.to_s.sub(/^process_/, '').to_sym }
+      m = public_methods.grep(/^process_/) { |o| o.to_s.sub(/^process_/, "").to_sym }
       supported = m - (m - @unsupported)
 
       raise UnsupportedNodeError, "#{supported.inspect} shouldn't be in @unsupported" unless supported.empty?
@@ -220,19 +238,19 @@ class SexpProcessor
 
     result = self.expected.new
 
-    type = exp.first
+    type = exp.sexp_type
     raise "type should be a Symbol, not: #{exp.first.inspect}" unless
       Symbol === type
 
     in_context type do
-      if @debug.has_key? type then
+      if @debug.key? type then
         str = exp.inspect
         puts "// DEBUG:(original ): #{str}" if str =~ @debug[type]
       end
 
       exp_orig = nil
       exp_orig = exp.deep_clone if $DEBUG or
-        @debug.has_key? type or @exceptions.has_key?(type)
+        @debug.key? type or @exceptions.key?(type)
 
       raise UnsupportedNodeError, "'#{type}' is not a supported node type" if
         @unsupported.include? type
@@ -245,40 +263,44 @@ class SexpProcessor
           warn "WARNING: Using default method #{meth} for #{type}"
         end
 
-        exp.shift if @auto_shift_type and meth != @default_method
+        exp = exp.sexp_body if @auto_shift_type and meth != @default_method # HACK
 
-        result = error_handler(type, exp_orig) do
-          self.send(meth, exp)
-        end
+        result = error_handler(type, exp_orig) {
+          self.send meth, exp
+        }
 
-        if @debug.has_key? type then
+        if @debug.key? type then
           str = exp.inspect
           puts "// DEBUG (processed): #{str}" if str =~ @debug[type]
         end
 
-        raise SexpTypeError, "Result must be a #{@expected}, was #{result.class}:#{result.inspect}" unless @expected === result
+        raise SexpTypeError, "Result of #{type} must be a #{@expected}, was #{result.class}:#{result.inspect}" unless
+          @expected === result
 
         self.assert_empty(meth, exp, exp_orig) if @require_empty
       else
         unless @strict then
           until exp.empty? do
-            sub_exp = exp.shift
+            sub_exp, *exp = exp # HACK
             sub_result = nil
             if Array === sub_exp then
               sub_result = error_handler(type, exp_orig) do
                 process(sub_exp)
               end
               raise "Result is a bad type" unless Array === sub_exp
-              raise "Result does not have a type in front: #{sub_exp.inspect}" unless Symbol === sub_exp.first unless sub_exp.empty?
+              raise "Result does not have a type in front: #{sub_exp.inspect}" unless
+                Symbol === sub_exp.sexp_type unless
+                sub_exp.empty?
             else
               sub_result = sub_exp
             end
-            result << sub_result
+            # result << sub_result
+            result = result.class.new(*result, sub_result) # HACK
           end
 
           # NOTE: this is costly, but we are in the generic processor
           # so we shouldn't hit it too much with RubyToC stuff at least.
-          result.sexp_type = exp.sexp_type if Sexp === exp and exp.sexp_type
+          result.c_type ||= exp.c_type if Sexp === exp and exp.respond_to?(:c_type)
         else
           msg = "Bug! Unknown node-type #{type.inspect} to #{self.class}"
           msg += " in #{exp_orig.inspect} from #{caller.inspect}" if $DEBUG
@@ -293,28 +315,26 @@ class SexpProcessor
   ##
   # Raises unless the Sexp type for +list+ matches +typ+
 
-  def assert_type(list, typ)
+  def assert_type list, typ
     raise SexpTypeError, "Expected type #{typ.inspect} in #{list.inspect}" if
       not Array === list or list.first != typ
   end
 
-  def error_handler(type, exp=nil) # :nodoc:
-    begin
-      return yield
-    rescue StandardError => err
-      if @exceptions.has_key? type then
-        return @exceptions[type].call(self, exp, err)
-      else
-        warn "#{err.class} Exception thrown while processing #{type} for sexp #{exp.inspect} #{caller.inspect}" if $DEBUG
-        raise
-      end
-    end
+  def error_handler type, exp = nil # :nodoc:
+    yield
+  rescue StandardError => err
+    return @exceptions[type].call self, exp, err if @exceptions.key? type
+
+    warn "#{err.class} Exception thrown while processing #{type} for sexp #{exp.inspect} #{caller.inspect}" if
+      $DEBUG
+
+    raise
   end
 
   ##
   # Registers an error handler for +node+
 
-  def on_error_in(node_type, &block)
+  def on_error_in node_type, &block
     @exceptions[node_type] = block
   end
 
@@ -329,13 +349,9 @@ class SexpProcessor
   #     return s(:dummy, process(exp), s(:extra, 42))
   #   end
 
-  def process_dummy(exp)
+  def process_dummy exp
     result = @expected.new(:dummy) rescue @expected.new
-
-    until exp.empty? do
-      result << self.process(exp.shift)
-    end
-
+    result << self.process(exp.shift) until exp.empty?
     result
   end
 
@@ -362,11 +378,16 @@ class SexpProcessor
     env.scope(&block)
   end
 
+  ##
+  # Track a stack of contexts that the processor is in, pushing on
+  # +type+ yielding, and then removing the context from the stack.
+
   def in_context type
     self.context.unshift type
 
     yield
 
+  ensure
     self.context.shift
   end
 
@@ -376,35 +397,55 @@ class SexpProcessor
   # itches too much...
 
   class Environment
-    def initialize
+    def initialize #:nodoc:
       @env = []
       @env.unshift({})
     end
 
+    ##
+    # Flatten out all scopes and return all key/value pairs.
+
     def all
       @env.reverse.inject { |env, scope| env.merge scope }
     end
 
+    ##
+    # Return the current number of scopes.
+
     def depth
       @env.length
     end
 
     # TODO: depth_of
 
+    ##
+    # Get +name+ from env at whatever scope it is defined in, or return nil.
+
     def [] name
-      hash = @env.find { |closure| closure.has_key? name }
+      hash = @env.find { |closure| closure.key? name }
       hash[name] if hash
     end
 
+    ##
+    # If +name+ exists in the env, set it to +val+ in whatever scope
+    # it is in. If it doesn't exist, set +name+ to +val+ in the
+    # current scope.
+
     def []= name, val
-      hash = @env.find { |closure| closure.has_key? name } || current
+      hash = @env.find { |closure| closure.key? name } || current
       hash[name] = val
     end
 
+    ##
+    # Get the current/top environment.
+
     def current
       @env.first
     end
 
+    ##
+    # Create a new scope and yield to the block passed.
+
     def scope
       @env.unshift({})
       begin
@@ -423,7 +464,7 @@ end
 # AKA, an interpreter.
 
 class SexpInterpreter < SexpProcessor
-  def initialize
+  def initialize #:nodoc:
     super
 
     self.expected        = Object
@@ -442,9 +483,30 @@ class MethodBasedSexpProcessor < SexpProcessor
   @@no_class  = :main
   @@no_method = :none
 
-  attr_reader :class_stack, :method_stack, :sclass, :method_locations
+  ##
+  # A stack of the classes/modules that are being processed
 
-  def initialize
+  attr_reader :class_stack
+
+  ##
+  # A stack of the methods that are being processed. You'd think it'd
+  # only ever be 1 deep, but you'd be wrong. People do terrible things
+  # in/to ruby.
+
+  attr_reader :method_stack
+
+  ##
+  # A stack of the singleton classes that are being processed.
+
+  attr_reader :sclass
+
+  ##
+  # A lookup table of all the method locations that have been
+  # processed so far.
+
+  attr_reader :method_locations
+
+  def initialize #:nodoc:
     super
     @sclass              = []
     @class_stack         = []
@@ -458,7 +520,7 @@ class MethodBasedSexpProcessor < SexpProcessor
 
   def in_klass name
     if Sexp === name then
-      name = case name.first
+      name = case name.sexp_type
              when :colon2 then
                name = name.flatten
                name.delete :const
@@ -483,7 +545,7 @@ class MethodBasedSexpProcessor < SexpProcessor
   ##
   # Adds name to the method stack, for the duration of the block
 
-  def in_method name, file, line, line_max=nil
+  def in_method name, file, line, line_max = nil
     method_name = Regexp === name ? name.inspect : name.to_s
     @method_stack.unshift method_name
     line_max = "-#{line_max}" if line_max
@@ -514,10 +576,10 @@ class MethodBasedSexpProcessor < SexpProcessor
   def klass_name
     name = @class_stack.first
 
-    if Sexp === name then
-      raise "you shouldn't see me"
-    elsif @class_stack.any?
-      @class_stack.reverse.join("::").sub(/\([^\)]+\)$/, '')
+    raise "you shouldn't see me" if Sexp === name
+
+    if @class_stack.any?
+      @class_stack.reverse.join("::").sub(/\([^\)]+\)$/, "")
     else
       @@no_class
     end
@@ -535,10 +597,10 @@ class MethodBasedSexpProcessor < SexpProcessor
 
   ##
   # Process a class node until empty. Tracks all nesting. If you have
-  # to subclass and override this method, you can clall super with a
+  # to subclass and override this method, you can call super with a
   # block.
 
-  def process_class(exp)
+  def process_class exp
     exp.shift unless auto_shift_type # node type
     in_klass exp.shift do
       if block_given? then
@@ -555,7 +617,7 @@ class MethodBasedSexpProcessor < SexpProcessor
   # have to subclass and override this method, you can clall super
   # with a block.
 
-  def process_defn(exp)
+  def process_defn exp
     exp.shift unless auto_shift_type # node type
     name = @sclass.empty? ? exp.shift : "::#{exp.shift}"
 
@@ -574,7 +636,7 @@ class MethodBasedSexpProcessor < SexpProcessor
   # If you have to subclass and override this method, you can clall
   # super with a block.
 
-  def process_defs(exp)
+  def process_defs exp
     exp.shift unless auto_shift_type # node type
     process exp.shift # recv
     in_method "::#{exp.shift}", exp.file, exp.line, exp.line_max do
@@ -592,7 +654,7 @@ class MethodBasedSexpProcessor < SexpProcessor
   # to subclass and override this method, you can clall super with a
   # block.
 
-  def process_module(exp)
+  def process_module exp
     exp.shift unless auto_shift_type # node type
     in_klass exp.shift do
       if block_given? then
@@ -609,7 +671,7 @@ class MethodBasedSexpProcessor < SexpProcessor
   # you have to subclass and override this method, you can clall super
   # with a block.
 
-  def process_sclass(exp)
+  def process_sclass exp
     exp.shift unless auto_shift_type # node type
     in_sklass do
       if block_given? then
@@ -651,7 +713,7 @@ class MethodBasedSexpProcessor < SexpProcessor
   end
 end
 
-class Object
+class Object # :nodoc:
 
   ##
   # deep_clone is the usual Marshalling hack to make a deep copy.

data/lib/strict_sexp.rb

@@ -0,0 +1,126 @@
+# :stopdoc:
+
+##
+# I'm starting to warm up to this idea!
+# ENV["STRICT_SEXP"] turns on various levels of conformance checking
+#
+# 1 = sexp[0]         => sexp_type
+# 1 = sexp.first      => sexp_type
+# 1 = sexp[0] = x     => sexp_type = x
+# 1 = sexp[1..-1]     => sexp_body
+# 1 = sexp[1..-1] = x => sexp_body = x
+# 1 = sexp[-1]        => last
+# 2 = sexp[1]         => no
+# 2 = sexp[1] = x     => no
+# 3 = sexp[n]         => no
+# 3 = sexp[n] = x     => no
+# 3 = sexp.node_name  => no (ie, method_missing)
+# 4 = sexp.replace x  => no
+# 4 = sexp.concat x   => no
+# 4 = sexp.collect!   => no
+# 4 = sexp.compact!   => no
+# 4 = sexp.flatten!   => no
+# 4 = sexp.map!       => no
+# 4 = sexp.reject!    => no
+# 4 = sexp.reverse!   => no
+# 4 = sexp.rotate!    => no
+# 4 = sexp.select!    => no
+# 4 = sexp.shuffle!   => no
+# 4 = sexp.slice!     => no
+# 4 = sexp.sort!      => no
+# 4 = sexp.sort_by!   => no
+# 4 = sexp.uniq!      => no
+# 4 = sexp.unshift    => no
+# 4 = sexp.push       => no
+# 4 = sexp.pop        => no
+# 4 = sexp <<         => no
+
+class Sexp
+  alias :safe_idx   :[]
+  alias :safe_asgn  :[]=
+  alias :sexp_type= :sexp_type=
+  alias :sexp_body= :sexp_body=
+  alias :shift :shift
+
+  def self.nuke_method name, level
+    define_method name do |*args|
+      raise "no: %p.%s %p" % [self, name, args]
+    end if __strict >= level
+  end
+
+  def self.__strict
+    ENV["STRICT_SEXP"].to_i
+  end
+
+  def __strict
+    self.class.__strict
+  end
+
+  undef_method :method_missing if __strict > 2
+
+  def method_missing msg, *args
+    raise "don't call method_missing on Sexps: %p.(%s)" % [msg, args.inspect[1..-2]]
+  end if __strict > 2
+
+  def [] i
+    raise "no idx: #{inspect}[#{i}]" if __strict > 2
+    raise "no idx>1: #{inspect}[#{i}]" if Integer === i && i > 1 if __strict > 1
+    raise "use sexp_type" if i == 0
+    raise "use sexp_body" if i == (1..-1)
+    raise "use last" if i == -1
+    self.safe_idx i
+  end
+
+  def []= i, v
+    raise "use sexp_type=" if i == 0
+    raise "use sexp_body=" if i == (1..-1)
+    raise "no asgn>1: #{inspect}[#{i}] = #{v.inspect}" if Integer === i && i > 1 if
+      __strict > 1
+    raise "no asgn: #{inspect}[#{i}] = #{v.inspect}" if
+      __strict > 2
+    self.safe_asgn i, v
+  end
+
+  def first
+    raise "use sexp_type"
+  end
+
+  nuke_method :collect!, 4
+  nuke_method :compact!, 4
+  nuke_method :concat,   4
+  nuke_method :flatten!, 4
+  nuke_method :map!,     4
+  nuke_method :pop,      4
+  nuke_method :push,     4
+  nuke_method :reject!,  4
+  nuke_method :replace,  4
+  nuke_method :reverse!, 4
+  nuke_method :rotate!,  4
+  nuke_method :select!,  4
+  nuke_method :shuffle!, 4
+  nuke_method :slice!,   4
+  nuke_method :sort!,    4
+  nuke_method :sort_by!, 4
+  nuke_method :uniq!,    4
+  nuke_method :unshift,  4
+  nuke_method :<<,       5
+  nuke_method :shift,    5
+
+  def sexp_type
+    safe_idx 0
+  end
+
+  def sexp_body from = 1
+    safe_idx from..-1
+  end
+
+  def sexp_type= v
+    self.safe_asgn 0, v
+  end
+
+  def sexp_body= v
+    self.safe_asgn 1..-1, v
+  end
+end unless Sexp.new.respond_to? :safe_asgn if ENV["STRICT_SEXP"]
+
+# :startdoc: