fabiokung-sexp_processor 3.0.1

data/History.txt

@@ -0,0 +1,23 @@
+=== 3.0.1 / 2009-01-20
+
+* 3 minor enhancements:
+
+  * Filled out README
+  * Promoted file/line/comments from ruby_parser.
+  * Added sexp_type to compliment sexp_body.
+
+=== 3.0.0 / 2008-10-22
+
+* 2 major enhancements:
+
+  * Released as its own project, splitting from ParseTree
+  * Added Environment to SexpProcessor and built it in. YAY!
+
+* 6 minor enhancements:
+
+  * Allowed CompositeSexpProcessor to be more ducktypey.
+  * Refactored Sexp#method_missing into find_node and find_nodes.
+  * Removed Sexp#for and other PT specific code.
+  * SexpProcessor#process now runs rewriters before everything else.
+  * SexpProcessor#rewrite context only for subs, EMPTY for top level rewrites.
+  * SexpProcessor#rewrite will stop iterating if the result isn't another Sexp.

data/Manifest.txt

@@ -0,0 +1,11 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/composite_sexp_processor.rb
+lib/sexp.rb
+lib/sexp_processor.rb
+test/test_composite_sexp_processor.rb
+test/test_environment.rb
+test/test_sexp.rb
+test/test_sexp_processor.rb

data/README.txt

@@ -0,0 +1,61 @@
+= SexpProcessor
+
+* http://rubyforge.org/projects/parsetree/
+
+== DESCRIPTION:
+
+sexp_processor branches from ParseTree bringing all the generic sexp
+processing tools with it. Sexp, SexpProcessor, Environment, etc... all
+for your language processing pleasure.
+
+== FEATURES/PROBLEMS:
+
+* Includes SexpProcessor and CompositeSexpProcessor.
+
+  * Allows you to write very clean filters.
+
+== SYNOPSIS:
+
+  class MyProcessor < SexpProcessor
+    def initialize
+      super
+      self.strict = false
+    end
+    def process_lit(exp)
+      val = exp.shift
+      return val
+    end
+  end
+
+== REQUIREMENTS:
+
+* rubygems
+
+== INSTALL:
+
+* sudo gem install sexp_processor
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Ryan Davis, Seattle.rb
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,16 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.add_include_dirs "lib"
+
+require './lib/sexp_processor.rb'
+
+Hoe.new('sexp_processor', SexpProcessor::VERSION) do |sexp|
+  sexp.rubyforge_name = 'parsetree'
+  sexp.developer('Ryan Davis', 'ryand-ruby@zenspider.com')
+  sexp.developer('Fabio Kung', 'fabio.kung@gmail.com')
+end
+
+# vim: syntax=Ruby

data/lib/composite_sexp_processor.rb

@@ -0,0 +1,49 @@
+require 'sexp_processor'
+
+##
+# Implements the Composite pattern on SexpProcessor. Need we say more?
+#
+# Yeah... probably. Implements a SexpProcessor of SexpProcessors so
+# you can easily chain multiple to each other. At some stage we plan
+# on having all of them run +process+ and but only ever output
+# something when +generate+ is called, allowing for deferred final
+# processing.
+
+class CompositeSexpProcessor < SexpProcessor
+
+  ##
+  # The list o' processors to run.
+
+  attr_reader :processors
+
+  def initialize # :nodoc:
+    super
+    @processors = []
+  end
+
+  ##
+  # Add a +processor+ to the list of processors to run.
+
+  def <<(processor)
+    raise ArgumentError, "Can only add sexp processors" unless
+      SexpProcessor === processor || processor.respond_to?(:process)
+    @processors << processor
+  end
+
+  ##
+  # Run +exp+ through all of the processors, returning the final
+  # result.
+
+  def process(exp)
+    @processors.each do |processor|
+      exp = processor.process(exp)
+    end
+    exp
+  end
+
+  def on_error_in(node_type, &block)
+    @processors.each do |processor|
+      processor.on_error_in(node_type, &block)
+    end
+  end
+end

data/lib/sexp.rb

@@ -0,0 +1,316 @@
+
+$TESTING ||= false # unless defined $TESTING
+
+##
+# Sexps are the basic storage mechanism of SexpProcessor.  Sexps have
+# a +type+ (to be renamed +node_type+) which is the first element of
+# the Sexp. The type is used by SexpProcessor to determine whom to
+# dispatch the Sexp to for processing.
+
+class Sexp < Array # ZenTest FULL
+
+  attr_writer :line
+  attr_writer :endline
+  attr_accessor :file, :comments
+
+  @@array_types = [ :array, :args, ]
+
+  ##
+  # Create a new Sexp containing +args+.
+
+  def initialize(*args)
+    super(args)
+  end
+
+  ##
+  # Creates a new Sexp from Array +a+.
+
+  def self.from_array(a)
+    ary = Array === a ? a : [a]
+
+    result = self.new
+
+    ary.each do |x|
+      case x
+      when Sexp
+        result << x
+      when Array
+        result << self.from_array(x)
+      else
+        result << x
+      end
+    end
+
+    result
+  end
+
+  def ==(obj) # :nodoc:
+    if obj.class == self.class then
+      super
+    else
+      false
+    end
+  end
+
+  ##
+  # Returns true if this Sexp's pattern matches +sexp+.
+
+  def ===(sexp)
+    return nil unless Sexp === sexp
+    pattern = self # this is just for my brain
+
+    return true if pattern == sexp
+
+    sexp.each do |subset|
+      return true if pattern === subset
+    end
+
+    return nil
+  end
+
+  ##
+  # Returns true if this Sexp matches +pattern+.  (Opposite of #===.)
+
+  def =~(pattern)
+    return pattern === self
+  end
+
+  ##
+  # Returns true if the node_type is +array+ or +args+.
+  #
+  # REFACTOR: to TypedSexp - we only care when we have units.
+
+  def array_type?
+    type = self.first
+    @@array_types.include? type
+  end
+
+  def compact # :nodoc:
+    self.delete_if { |o| o.nil? }
+  end
+
+  ##
+  # Enumeratates the sexp yielding to +b+ when the node_type == +t+.
+
+  def each_of_type(t, &b)
+    each do | elem |
+      if Sexp === elem then
+        elem.each_of_type(t, &b)
+        b.call(elem) if elem.first == t
+      end
+    end
+  end
+
+  ##
+  # Replaces all elements whose node_type is +from+ with +to+. Used
+  # only for the most trivial of rewrites.
+
+  def find_and_replace_all(from, to)
+    each_with_index do | elem, index |
+      if Sexp === elem then
+        elem.find_and_replace_all(from, to)
+      else
+        self[index] = to if elem == from
+      end
+    end
+  end
+
+  ##
+  # Replaces all Sexps matching +pattern+ with Sexp +repl+.
+
+  def gsub(pattern, repl)
+    return repl if pattern == self
+
+    new = self.map do |subset|
+      case subset
+      when Sexp then
+        subset.gsub(pattern, repl)
+      else
+        subset
+      end
+    end
+
+    return Sexp.from_array(new)
+  end
+
+  def inspect # :nodoc:
+    sexp_str = self.map {|x|x.inspect}.join(', ')
+    if line && ENV['VERBOSE'] then
+      "s(#{sexp_str}).line(#{line})"
+    else
+      "s(#{sexp_str})"
+    end
+  end
+
+  def find_node name, delete = false
+    matches = find_nodes name
+
+    case matches.size
+    when 0 then
+      nil
+    when 1 then
+      match = matches.first
+      delete match if delete
+      match
+    else
+      raise NoMethodError, "multiple nodes for #{name} were found in #{inspect}"
+    end
+  end
+
+  ##
+  # Find every node with type +name+.
+
+  def find_nodes name
+    find_all { | sexp | Sexp === sexp and sexp.first == name }
+  end
+
+  ##
+  # If passed a line number, sets the line and returns self. Otherwise
+  # returns the line number. This allows you to do message cascades
+  # and still get the sexp back.
+
+  def line(n=nil)
+    if n then
+      @line = n
+      self
+    else
+      @line ||= nil
+    end
+  end
+
+  ##
+  # If passed a line number, sets the endline and returns self. Otherwise
+  # returns the endline number. This allows you to do message cascades
+  # and still get the sexp back.
+
+  def endline(n=nil)
+    if n then
+      @endline = n
+      self
+    else
+      @endline ||= nil
+    end
+  end
+
+  ##
+  # Returns the node named +node+, deleting it if +delete+ is true.
+
+  def method_missing meth, delete = false
+    find_node meth, delete
+  end
+
+  def pretty_print(q) # :nodoc:
+    q.group(1, 's(', ')') do
+      q.seplist(self) {|v| q.pp v }
+    end
+  end
+
+  ##
+  # Returns the node type of the Sexp.
+
+  def sexp_type
+    first
+  end
+
+  ##
+  # Returns the Sexp body, ie the values without the node type.
+
+  def sexp_body
+    self[1..-1]
+  end
+
+  ##
+  # If run with debug, Sexp will raise if you shift on an empty
+  # Sexp. Helps with debugging.
+
+  def shift
+    raise "I'm empty" if self.empty?
+    super
+  end if $DEBUG or $TESTING
+
+  ##
+  # Returns the bare bones structure of the sexp.
+  # s(:a, :b, s(:c, :d), :e) => s(:a, s(:c))
+
+  def structure
+    result = self.class.new
+    if Array === self.first then
+      result = self.first.structure
+    else
+      result << self.first
+      self.grep(Array).each do |subexp|
+        result << subexp.structure
+      end
+    end
+    result
+  end
+
+  ##
+  # Replaces the Sexp matching +pattern+ with +repl+.
+
+  def sub(pattern, repl)
+    return repl.dup if pattern == self
+
+    done = false
+
+    new = self.map do |subset|
+      if done then
+        subset
+      else
+        case subset
+        when Sexp then
+          if pattern == subset then
+            done = true
+            repl.dup
+          elsif pattern === subset then
+            done = true
+            subset.sub pattern, repl
+          else
+            subset
+          end
+        else
+          subset
+        end
+      end
+    end
+
+    return Sexp.from_array(new)
+  end
+
+  def to_a # :nodoc:
+    self.map { |o| Sexp === o ? o.to_a : o }
+  end
+
+  def to_s # :nodoc:
+    inspect
+  end
+
+end
+
+class SexpMatchSpecial < Sexp; end
+
+class SexpAny < SexpMatchSpecial
+  def ==(o)
+    Sexp === o
+  end
+
+  def ===(o)
+    return Sexp === o
+  end
+
+  def inspect
+    "ANY"
+  end
+end
+
+module SexpMatchSpecials
+  def ANY(); return SexpAny.new; end
+end
+
+##
+# This is just a stupid shortcut to make indentation much cleaner.
+
+def s(*args)
+  Sexp.new(*args)
+end
+