protocol 0.8.2 → 0.9.0

data/CHANGES

@@ -1,3 +1,5 @@
+0.9.0 - 2009-08-05
+  * Supporting Ruby >= 1.9.2 via ruby_parser
 0.8.2 - 2008-07-20
   * Some cleanup.
   * Bumped up dependency on ParseTree to 3.0.

data/Rakefile

@@ -1,5 +1,3 @@
-# vim: set et sw=2 ts=2:
-
 begin
   require 'rake/gempackagetask'
 rescue LoadError
@@ -11,7 +9,7 @@ include Config
 PKG_NAME = 'protocol'
 PKG_VERSION = File.read('VERSION').chomp
 PKG_FILES = FileList['**/*'].exclude(/(CVS|\.svn|pkg|coverage)/)
-CLEAN.include 'coverage', 'doc'
+CLEAN.include 'coverage', 'doc', Dir['benchmarks/data/*.*']
 
 desc "Installing library"
 task :install  do
@@ -51,6 +49,7 @@ EOT
 
     s.require_path = 'lib'
     s.add_dependency 'ParseTree', '~> 3.0'
+    s.add_dependency 'ruby_parser', '~> 2.0'
 
     s.has_rdoc = true
     s.rdoc_options << '--main' << 'doc-main.txt'

data/VERSION

@@ -1 +1 @@
-0.8.2
+0.9.0

data/benchmarks/method_parser.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+require 'bullshit'
+require 'protocol'
+
+class MethodParserBenchmark < Bullshit::RepeatCase
+  include Protocol
+
+  class Foo
+    def foo(a, b = nil, *c)
+      yield
+    end
+  end
+
+  warmup              yes
+
+  iterations          500
+
+  truncate_data do
+    alpha_level 0.05
+    window_size 10
+    slope_angle 0.003
+  end
+
+  output_dir File.join(File.dirname(__FILE__), 'data')
+  data_file  yes
+  histogram  yes
+
+  autocorrelation do
+    alpha_level 0.05
+    max_lags    50
+    file        yes
+  end
+
+  def benchmark_standard
+    @mp = MethodParser.new(Foo, :foo)
+  end
+
+  def after_standard
+    @mp.args == [ :a, :b, :'*c', :'&block' ] or raise "wrong result"
+  end
+
+  def benchmark_nocache
+    @mp = MethodParser.new(Foo, :foo)
+  end
+
+  def after_nocache
+    @mp.args == [ :a, :b, :'*c', :'&block' ] or raise "wrong result"
+    MethodParser.flush_source_cache
+  end
+end

data/examples/comparing.rb

@@ -18,9 +18,9 @@ goliath = Person.new 'Goliath', 2_60
 david = Person.new 'David', 1_40
 symbol = Person.new 'The artist formerly known as Prince', 1_40
 
-david < goliath   # => true
-david >= goliath  # => false
-david == symbol   # => true
+puts "david < goliath   = #{david < goliath} (true)"
+puts "david >= goliath  = #{david >= goliath} (false)"
+puts "david == symbol   = #{david == symbol} (true)"
 
 begin
   class NoPerson
@@ -32,6 +32,7 @@ begin
 
     conform_to Comparing
   end
+  puts "Should have thrown Protocol::CheckFailed!"
 rescue Protocol::CheckFailed => e
-  e.to_s # => "Comparing#<=>(1): method '<=>' not implemented in NoPerson"
+  p e
 end

data/examples/enumerating.rb

@@ -1,4 +1,12 @@
-require 'protocol/core'
+require 'protocol'
+
+Enumerating = Protocol do
+  # Iterate over each element of this Enumerating class and pass it to the
+  # _block_.
+  def each(&block) end
+
+  include Enumerable
+end
 
 begin
   class FailAry
@@ -11,8 +19,9 @@ begin
 
     conform_to Enumerating
   end
+  puts "Should have thrown Protocol::CheckFailed!"
 rescue Protocol::CheckFailed => e
-  e.to_s # => "Enumerating#each(0&): expected a block argument for FailAry"
+  p e # => "Enumerating#each(0&): expected a block argument for FailAry"
 end
 
 class Ary
@@ -27,9 +36,9 @@ class Ary
   conform_to Enumerating
 end
 
-Ary.new.map { |x| x * x }        # => [1, 4, 9]
-Ary.conform_to?(Enumerating)     # => true
-Ary.new.conform_to?(Enumerating) # => true
+puts Ary.new.map { |x| x * x }.inspect      + " ([1, 4, 9])"
+puts Ary.conform_to?(Enumerating).to_s      + " (true)"
+puts Ary.new.conform_to?(Enumerating).to_s  + " (true)"
 
 Enumerating.check_failure :none
 
@@ -43,5 +52,5 @@ class FailAry2
   conform_to Enumerating
 end
 
-FailAry2.conform_to?(Enumerating)     # => false
-FailAry2.new.conform_to?(Enumerating) # => false
+puts FailAry2.conform_to?(Enumerating).to_s     + " (false)"
+puts FailAry2.new.conform_to?(Enumerating).to_s + " (false)"

data/examples/indexing.rb

@@ -21,7 +21,8 @@ if $0 == __FILE__
     class Proc
       conform_to Indexing
     end
+  puts "Should have thrown Protocol::CheckFailed!"
   rescue Protocol::CheckFailed => e
-    e.to_s # => "Indexing#[]=(): method '[]=' not implemented in Proc"
+    p e
   end
 end

data/examples/locking.rb

@@ -53,7 +53,7 @@ if $0 == __FILE__
   #  Locking '...'.
   #  Synchronized with '...'..
   #  Unlocking '...'.
-  mutex = FileMutex.new
+  p mutex = FileMutex.new
   mutex.synchronize do
     puts "Synchronized with '#{mutex.path}'."
   end
@@ -74,13 +74,13 @@ if $0 == __FILE__
     conform_to Locking # actually Mutex itself would conform as well ;)
   end
 
-  mutex = MemoryMutex.new
+  p mutex = MemoryMutex.new
   mutex.synchronize do
     puts "Synchronized in memory."
   end
 
-  MemoryMutex.conform_to? Locking     # => true
-  MemoryMutex.new.conform_to? Locking # => true
+  puts MemoryMutex.conform_to?(Locking).to_s     + ' (true)'
+  puts MemoryMutex.new.conform_to?(Locking).to_s + ' (true)'
 
   class MyClass
     def initialize
@@ -90,22 +90,22 @@ if $0 == __FILE__
     attr_reader :mutex
 
     def mutex=(mutex)
-      Locking.check mutex
+      Locking =~ mutex
       @mutex = mutex
     end
   end
 
   obj = MyClass.new
-  obj.mutex # => #<FileMutex:0xb788f9ac @tempfile=#<File:/tmp/file-mutex.26553.2>>
+  p obj.mutex # => #<FileMutex:0xb788f9ac @tempfile=#<File:/tmp/file-mutex.26553.2>>
   begin
     obj.mutex = Object.new
+    puts "Should have thrown Protocol::CheckFailed!"
   rescue Protocol::CheckFailed => e
-    e # => #<Protocol::CheckFailed: #<Protocol::NotImplementedErrorCheckError: Locking#lock(0): method 'lock' not responding in #<Object:0xb788f59c>>|#<Protocol::NotImplementedErrorCheckError: Locking#unlock(0): method 'unlock' not responding in #<Object:0xb788f59c>>
+    p e
   end
-  obj.mutex = MemoryMutex.new # => #<MemoryMutex:0xb788f038 @mutex=#<Mutex:0xb788eea8>>
+  p obj.mutex = MemoryMutex.new # => #<MemoryMutex:0xb788f038 @mutex=#<Mutex:0xb788eea8>>
   # This works as well:
-  obj.mutex = Mutex.new       # => #<Mutex:0xb788ecc8>
-  Locking.check Mutex         # => true
-  Mutex.conform_to? Locking   # => true
+  obj.mutex = Mutex.new
+  puts Locking.check(Mutex).to_s        + ' (true)'
+  puts Mutex.conform_to?(Locking).to_s  + ' (true)'
 end
-# >> "Locking '/tmp/file-mutex.26553.1'.\nSynchronized with '/tmp/file-mutex.26553.1'.\nUnlocking '/tmp/file-mutex.26553.1'.\nSynchronized in memory.\n"

data/examples/queue.rb

@@ -100,55 +100,58 @@ class Q
   conform_to QueueProtocol
 end
 
-if $0 == __FILE__
-  q = Q.new
-  q.observer = O.new
-  q.empty? # => true
-  begin
-    q.deq
-  rescue Protocol::CheckError => e
-    e # => #<Protocol::PreconditionCheckError: QueueProtocol#deq(0): precondition failed for Q>
-  end
-  q.empty? # => true
-  q.size   # => 0
-  q.first  # => nil
-  q.enq 2
-  q.empty? # => false
-  q.size   # => 1
-  q.first  # => 2
-  q.enq 2
-  q.size   # => 2
-  q.deq    # => 2
-  q.first  # => 2
-  q.size   # => 1
-
-  q = Q.new
-  q.observer = O.new
-  q.empty? # => true
-  begin
-    q.deq
-  rescue Protocol::CheckError => e
-    e # => #<Protocol::PreconditionCheckError: QueueProtocol#deq(0): precondition failed for Q>
-  end
-  q.empty? # => true
-  q.size   # => 0
-  q.first  # => nil
-  q.enq 2
-  q.empty? # => false
-  q.size   # => 1
-  q.first  # => 2
-  q.enq 2
-  q.size   # => 2
-  q.deq    # => 2
-  q.first  # => 2
-  q.size   # => 1
-  q.observer = SneakyO.new
-  q.deq    # => 2
-  q.empty? # => true
-  begin
-    q.enq 7
-  rescue Protocol::CheckError => e
-    e # => #<Protocol::PostconditionCheckError: ObserverProtocol#after_enq(1): postcondition failed for SneakyO, result = 7>
-  end
+def should_be(a1, a2)
+  puts "#{a1.inspect} (#{a2.inspect})"
+end
+
+q = Q.new
+q.observer = O.new
+should_be q.empty?, true
+begin
+  q.deq
+rescue Protocol::CheckError => e
+  p e
+end
+should_be q.empty?, true
+should_be q.size, 0
+should_be q.first, nil
+q.enq 2
+should_be q.empty?, false
+should_be q.size, 1
+should_be q.first, 2
+q.enq 2
+should_be q.size, 2
+should_be q.deq, 2
+should_be q.first, 2
+should_be q.size, 1
+
+q = Q.new
+q.observer = O.new
+should_be q.empty?, true
+begin
+  q.deq
+  puts "Should have thrown Protocol::CheckFailed!"
+rescue Protocol::CheckError => e
+  p e
+end
+should_be q.empty?, true
+should_be q.size, 0
+should_be q.first, nil
+q.enq 2
+should_be q.empty?, false
+should_be q.size, 1
+should_be q.first, 2
+q.enq 2
+should_be q.size, 2
+should_be q.deq, 2
+should_be q.first, 2
+should_be q.size, 1
+q.observer = SneakyO.new
+should_be q.deq, 2
+should_be q.empty?, true
+begin
+  q.enq 7
+  puts "Should have thrown Protocol::CheckFailed!"
+rescue Protocol::CheckError => e
+  p e
 end
-# >> "Enqueued.\nEnqueued.\nDequeued.\nEnqueued.\nEnqueued.\nDequeued.\nDequeued.\nEnqueued.\nDequeued.\n"

data/examples/stack.rb

@@ -53,23 +53,23 @@ end
 
 if $0 == __FILE__
   s = S.new
-  s.top # => nil
-  s.empty? # => true
-  s.size # => 0
+  puts s.top.inspect + " (nil)"
+  puts s.empty?.to_s + " (true)"
+  puts s.size.to_s   + " (0)"
   begin
     s.pop
   rescue Protocol::CheckError => e
-    e # => #<Protocol::PreconditionCheckError: StackProtocol#empty?(0): precondition failed for S>
+    p e # => #<Protocol::PreconditionCheckError: StackProtocol#empty?(0): precondition failed for S>
   end
-  s.empty? # => true
+  puts s.empty?.to_s  + " (true)"
   s.push 2
-  s.empty? # => false
-  s.size # => 1
-  s.top # => 2
+  puts s.empty?.to_s  + " (false)"
+  puts s.size.to_s    + " (1)"
+  puts s.top.to_s     + " (2)"
   s.push 4
-  s.top # => 4
-  s.size # => 2
-  s.pop # => 4
-  s.top # => 2
-  s.size # => 1
+  puts s.top.to_s     + " (4)"
+  puts s.size.to_s    + " (2)"
+  puts s.pop.to_s     + " (4)"
+  puts s.top.to_s     + " (2)"
+  puts s.size.to_s    + " (1)"
 end

data/install.rb

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
-# vim: set et sw=2 ts=2:
 
 require 'rbconfig'
 require 'fileutils'
@@ -16,3 +15,9 @@ mkdir_p dest
 for file in Dir['lib/protocol/*.rb']
   install(file, dest)
 end
+
+dest = File.join(CONFIG["sitelibdir"], 'protocol', 'method_parser')
+mkdir_p dest
+for file in Dir['lib/protocol/method_parser/*.rb']
+  install(file, dest)
+end

data/lib/protocol/method_parser/parse_tree.rb

@@ -0,0 +1,124 @@
+require 'parse_tree'
+require 'sexp_processor'
+
+module Protocol
+  # Parse protocol method definition to derive a Message specification.
+  class MethodParser < SexpProcessor
+    # Create a new MethodParser instance for method +methodname+ of module
+    # +modul+. For eigenmethods set +eigenclass+ to true, otherwise bad things
+    # will happen.
+    def initialize(modul, methodname, eigenclass = false)
+      super()
+      @method = Module === modul ?
+        modul.instance_method(methodname) :
+        modul.method(methodname)
+      self.strict = false
+      self.auto_shift_type = true
+      @complex      = false
+      @first_defn   = true
+      @first_block  = true
+      @args         = []
+      @arg_kinds    = []
+      @arity        = @method.arity
+      parsed = ParseTree.new.parse_tree_for_method(modul, methodname, eigenclass)
+      process parsed
+    end
+
+    # Process +exp+, but catch UnsupportedNodeError exceptions and ignore them.
+    def process(exp)
+      super
+    rescue UnsupportedNodeError => ignore
+    end
+
+    # Returns the names of the arguments of the parsed method.
+    attr_reader :args
+
+    def arg(i)
+      @args[i]
+    end
+
+    # Returns the names of the arguments of the parsed method.
+    attr_reader :arg_kinds
+
+    def arg_kind(i)
+      @arg_kinds[i]
+    end
+
+    # Returns the arity of the parsed method.
+    attr_reader :arity
+
+    # Return true if this protocol method is a complex method, which ought to
+    # be called for checking conformance to the protocol.
+    def complex?
+      @complex
+    end
+
+    # Return true if a block argument was detected.
+    def block_arg?
+      @arg_kinds.last == :block
+    end
+
+    # Only consider first the first defn, skip inner method definitions.
+    def process_defn(exp)
+      if @first_defn
+        @first_defn = false
+        _name, scope = exp
+        process scope
+      end
+      exp.clear
+      s :dummy
+    end
+
+    # Remember the argument names in +exp+ in the args attribute.
+    def process_args(exp)
+      @args.replace exp.select { |x| x.is_a? Symbol }
+      @arg_kinds = @args.map { |a| a.to_s[0] == ?* ? :rest : :req }
+      if block = exp.find { |x| x.is_a?(Array) and x.first == :block }
+        lasgns = block[1..-1].transpose[1]
+        i = args.size - 1
+        @args.reverse_each do |a|
+          exp.first
+          l = lasgns.last
+          if a == l
+            @arg_kinds[i] = :opt
+            lasgns.pop
+          end
+          i -= 1
+        end
+      end
+      exp.clear
+      s :dummy
+    end
+
+    # Remember if we encounter a block argument.
+    def process_block_arg(exp)
+      @args.push :"&#{exp.first}"
+      @arg_kinds.push :block
+      exp.clear
+      s :dummy
+    end
+
+    # Remember if we encounter a yield keyword.
+    def process_yield(exp)
+      if @arg_kinds.last != :block
+        @args.push :'&block'
+        @arg_kinds.push :block
+      end
+      exp.clear
+      s :dummy
+    end
+
+    # We only consider the first block in +exp+ (can there be more than one?),
+    # and then try to figure out, if this is a complex method or not. Continue
+    # processing the +exp+ tree after that.
+    def process_block(exp)
+      if @first_block
+        @first_block = false
+        @complex = exp.flatten.any? { |e| [ :call, :fcall, :vcall ].include?(e) }
+        exp.each { |e| process e }
+      end
+      exp.clear
+      s :dummy
+    end
+  end
+end

data/lib/protocol/method_parser/ruby_parser.rb

@@ -0,0 +1,123 @@
+require 'ruby_parser'
+
+module Protocol
+  # Parse protocol method definition to derive a Message specification.
+  class MethodParser
+    class << self
+      attr_accessor :__source_cache__
+
+      # Flushes the source cache.
+      def flush_source_cache
+        __source_cache__.clear
+        self
+      end
+    end
+    self.__source_cache__ = {}
+
+    # Create a new MethodParser instance for method +methodname+ of module
+    # +modul+. For eigenmethods set +eigenclass+ to true, otherwise bad things
+    # will happen.
+    def initialize(modul, methodname, eigenclass = false)
+      @method = Module === modul ?
+        modul.instance_method(methodname) :
+        modul.method(methodname)
+      compute_args
+      parse_method
+    end
+
+    # Returns the names of the arguments of the parsed method.
+    attr_reader :args
+
+    # Returns the i-th argument (beginning with 0).
+    def arg(i)
+      @args[i]
+    end
+
+    # Returns the kinds of the arguments of the parsed method.
+    attr_reader :arg_kinds
+
+    # Returns the i-th kind of an argument (beginning with 0).
+    def arg_kind(i)
+      @arg_kinds[i]
+    end
+
+    # Returns the arity of the parsed method.
+    attr_reader :arity
+
+    # Return true if this protocol method is a complex method, which ought to
+    # be called for checking conformance to the protocol.
+    def complex?
+      @complex
+    end
+
+    # Return true if a block argument was detected.
+    def block_arg?
+      @arg_kinds.last == :block
+    end
+
+    private
+
+    def compute_args
+      @arity    = @method.arity
+      if @method.respond_to?(:parameters)
+        parameters = @method.parameters
+        @args, @arg_kinds = parameters.map do |kind, name|
+          case  kind
+          when :req
+            [ name, kind ]
+          when :opt
+            [ name, kind ]
+          when :rest
+            [ :"*#{name}", kind ]
+          when :block
+            [ :"&#{name}", kind ]
+          end
+        end.compact.transpose
+      else
+        raise NotImplementedError,
+          "#{@method.class}#parameters as in ruby version >=1.9.2 is required"
+      end
+      @args         ||= []
+      @arg_kinds    ||= []
+    end
+
+    def cached_source(filename)
+      cache = self.class.__source_cache__
+      unless source = cache[filename]
+        begin
+          source = IO.readlines(filename)
+          cache[filename] = source
+        rescue SystemCallError => e
+          $DEBUG and warn "Caught #{e.class}: #{e}"
+          nil
+        end
+      end
+      source
+    end
+
+    def parse_method
+      @complex  = false
+      filename, lineno = @method.source_location
+      if filename
+        source = cached_source(filename) or return
+        source = source[(lineno - 1)..-1].join
+        current = 0
+        tree = nil
+        while current = source.index('end', current)
+          current += 3
+          begin
+            tree = RubyParser.new.parse(source[0, current], filename)
+            break
+          rescue SyntaxError, Racc::ParseError
+          end
+        end
+        ary = tree.to_a.flatten
+        @complex = ary.flatten.any? { |node| [ :call, :fcall, :vcall ].include?(node) }
+        if ary.index(:yield) and @arg_kinds.last != :block
+          @args.push :'&block'
+          @arg_kinds.push :block
+        end
+      end
+    end
+  end
+end

data/lib/protocol/version.rb

@@ -1,6 +1,6 @@
 module Protocol
   # Protocol version
-  VERSION         = '0.8.2'
+  VERSION         = '0.9.0'
   VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
   VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:

data/lib/protocol.rb

@@ -1,8 +1,12 @@
 require 'protocol/version'
-require 'parse_tree'
-require 'sexp_processor'
 
 module Protocol
+  if RUBY_VERSION[/\A1\.8\./]
+    require 'protocol/method_parser/parse_tree'
+  else
+    require 'protocol/method_parser/ruby_parser'
+  end
+
   class ::Object
     # Returns true if this object conforms to +protocol+, otherwise false.
     #
@@ -144,7 +148,7 @@ module Protocol
   # after the result of the wrapped method was determined.
   class Postcondition
     instance_methods.each do |m|
-      m =~ /\A(__|instance_eval\Z|inspect\Z)/ or undef_method m
+      m.to_s =~ /\A(__|object_id|instance_eval\Z|inspect\Z)/ or undef_method m
     end
 
     def initialize(object)
@@ -204,8 +208,9 @@ module Protocol
     # Creates a Message instance named +name+, with the arity +arity+.
     # If +arity+ is nil, the arity isn't checked during conformity tests.
     def initialize(protocol, name, arity = nil, block_expected = false)
+      name = name.to_s
       @protocol, @name, @arity, @block_expected =
-        protocol, name.to_s, arity, !!block_expected
+        protocol, name, arity, !!block_expected
     end
 
     # The protocol this message was defined in.
@@ -320,7 +325,7 @@ module Protocol
               (1..arity).map { |i| "x#{i}," }
             else
               (1..~arity).map { |i| "x#{i}," } << '*rest,'
-            end
+            end.join
           wrapped_call = %{
             alias_method :'#{inner_name}', :'#{name}'
 
@@ -395,7 +400,7 @@ module Protocol
             " in method '#{name}' (#{check_arity} for #{arity}) of #{object}")
       end
       if block_expected?
-        if object.singleton_methods(false).include?(name)
+        if object.singleton_methods(false).map { |m| m.to_s } .include?(name)
           parser = MethodParser.new(object, name, true)
         else
           ancestors = object.class.ancestors
@@ -446,90 +451,6 @@ module Protocol
     end
   end
 
-  # Parse protocol method definition to derive a Message specification.
-  class MethodParser < SexpProcessor
-    # Create a new MethodParser instance for method +methodname+ of module
-    # +modul+. For eigenmethods set +eigenclass+ to true, otherwise bad things
-    # will happen.
-    def initialize(modul, methodname, eigenclass = false)
-      super()
-      self.strict = false
-      self.auto_shift_type = true
-      @complex      = false
-      @block_arg    = false
-      @first_defn   = true
-      @first_block  = true
-      @args         = []
-      parsed = ParseTree.new.parse_tree_for_method(modul, methodname, eigenclass)
-      process parsed
-    end
-
-    # Process +exp+, but catch UnsupportedNodeError exceptions and ignore them.
-    def process(exp)
-      super
-    rescue UnsupportedNodeError => ignore
-    end
-
-    # Returns the names of the arguments of the parsed method.
-    attr_reader :args
-
-    # Returns the arity of the parsed method.
-    def arity
-      @args.size
-    end
-
-    # Return true if this protocol method is a complex method, which ought to
-    # be called for checking conformance to the protocol.
-    def complex?
-      @complex
-    end
-
-    # Return true if a block argument was detected.
-    def block_arg?
-      @block_arg
-    end
-
-    # Only consider first the first defn, skip inner method definitions.
-    def process_defn(exp)
-      if @first_defn
-        @first_defn = false
-        _name, scope = exp
-        process scope
-      end
-      exp.clear
-      s :dummy
-    end
-
-    # Remember the argument names in +exp+ in the args attribute.
-    def process_args(exp)
-      @args.replace exp
-      exp.clear
-      s :dummy
-    end
-
-    # Remember if we encounter a block argument or a yield keyword.
-    def process_block_arg(exp)
-      @block_arg = true
-      exp.clear
-      s :dummy
-    end
-
-    alias process_yield process_block_arg
-
-    # We only consider the first block in +exp+ (can there be more than one?),
-    # and then try to figure out, if this is a complex method or not. Continue
-    # processing the +exp+ tree after that.
-    def process_block(exp)
-      if @first_block
-        @first_block = false
-        @complex = exp[-1][0] != :nil rescue false
-        exp.each { |e| process e }
-      end
-      exp.clear
-      s :dummy
-    end
-  end
-
   # A ProtocolModule object 
   class ProtocolModule < Module
     # Creates an new ProtocolModule instance.
@@ -546,7 +467,7 @@ module Protocol
     def descriptors
       descriptors = []
       protocols.each do |a|
-        descriptors << a.instance_variable_get('@descriptor')
+        descriptors << a.instance_variable_get(:@descriptor)
       end
       descriptors
     end
@@ -578,8 +499,7 @@ module Protocol
     # have to call #reset_messages, if you want to recompute the array in the
     # next call to #messages.
     def messages
-      @messages and return @messages
-      @messages = []
+      result = []
       seen = {}
       descriptors.each do |d|
         dm = d.messages
@@ -588,10 +508,9 @@ module Protocol
           seen[m.name] = true
           delete
         end
-        @messages.concat dm
+        result.concat dm
       end
-      @messages.sort!
-      @messages
+      result.sort!
     end
 
     alias to_a messages
@@ -820,8 +739,14 @@ module Protocol
     # This Method tries to find the first module that implements the method
     # named +methodname+ in the array of +ancestors+. If this fails nil is
     # returned.
-    def find_method_module(methodname, ancestors) ancestors.each do |a|
-        return a if a.instance_methods(false).include? methodname
+    def find_method_module(methodname, ancestors)
+      methodname = methodname.to_s
+      ancestors.each do |a|
+        begin
+          a.instance_method(methodname)
+          return a
+        rescue NameError
+        end
       end
       nil
     end

data/make_doc.rb

@@ -1,6 +1,5 @@
 #!/usr/bin/env ruby
-# vim: set et sw=2 ts=2:
 
 $outdir = 'doc/'
 puts "Creating documentation in '#$outdir'."
-system "rdoc --main=doc-main.txt -o #$outdir doc-main.txt lib/protocol.rb"
+system "rdoc --main=doc-main.txt -o #$outdir doc-main.txt #{Dir['lib/**/*.rb'] * ' '}"

data/protocol.gemspec

@@ -1,8 +1,8 @@
 # -*- encoding: utf-8 -*-
 Gem::Specification.new do |s|
     s.name = 'protocol'
-    s.version = '0.8.2'
-    s.files = ["CHANGES", "COPYING", "Rakefile", "VERSION", "doc-main.txt", "examples", "examples/comparing.rb", "examples/enumerating.rb", "examples/game.rb", "examples/hello_world_patternitis.rb", "examples/indexing.rb", "examples/locking.rb", "examples/queue.rb", "examples/stack.rb", "install.rb", "lib", "lib/protocol", "lib/protocol.rb", "lib/protocol/core.rb", "lib/protocol/version.rb", "make_doc.rb", "protocol.gemspec", "tests", "tests/test_protocol.rb"]
+    s.version = '0.9.0'
+    s.files = ["CHANGES", "COPYING", "Rakefile", "VERSION", "benchmarks", "benchmarks/data", "benchmarks/method_parser.rb", "doc-main.txt", "examples", "examples/comparing.rb", "examples/enumerating.rb", "examples/game.rb", "examples/hello_world_patternitis.rb", "examples/indexing.rb", "examples/locking.rb", "examples/queue.rb", "examples/stack.rb", "install.rb", "lib", "lib/protocol", "lib/protocol.rb", "lib/protocol/core.rb", "lib/protocol/method_parser", "lib/protocol/method_parser/parse_tree.rb", "lib/protocol/method_parser/ruby_parser.rb", "lib/protocol/version.rb", "make_doc.rb", "protocol.gemspec", "tests", "tests/test_protocol.rb", "tests/test_protocol_method_parser.rb"]
     s.summary = 'Method Protocols for Ruby Classes'
     s.description = <<EOT
 This library offers an implementation of protocols against which you can check
@@ -14,6 +14,7 @@ EOT
 
     s.require_path = 'lib'
     s.add_dependency 'ParseTree', '~> 3.0'
+    s.add_dependency 'ruby_parser', '~> 2.0'
 
     s.has_rdoc = true
     s.rdoc_options << '--main' << 'doc-main.txt'

data/tests/test_protocol.rb

@@ -19,25 +19,25 @@ class TestProtocol < Test::Unit::TestCase
   end
 
   TestProtocol_foo_bar_1 = Protocol do
-    include TestProtocol_foo
+    include TestProtocol::TestProtocol_foo
     understand :bar
   end
 
   TestProtocol_foo_bar_1_fail = Protocol do
-    include TestProtocol_foo
+    include TestProtocol::TestProtocol_foo
     understand :bar
   end
 
   TestProtocol_foo_bar_2 = Protocol do
-    include TestProtocol_foo
-    include TestProtocol_bar
+    include TestProtocol::TestProtocol_foo
+    include TestProtocol::TestProtocol_bar
   end
 
   TestProtocol_foo_bar_2_fail = Protocol do
     check_failure :error
 
-    include TestProtocol_foo
-    include TestProtocol_bar
+    include TestProtocol::TestProtocol_foo
+    include TestProtocol::TestProtocol_bar
   end
 
   TestProtocolArgs = Protocol do
@@ -47,7 +47,7 @@ class TestProtocol < Test::Unit::TestCase
   end
 
   TestProtocolArgsOverwritten = Protocol do
-    include TestProtocolArgs
+    include TestProtocol::TestProtocolArgs
 
     def bar(a, b, c)
     end
@@ -101,8 +101,8 @@ class TestProtocol < Test::Unit::TestCase
 
   TestProtocolWrapMethod = Protocol do
     def foo_bar(foo, bar)
-      TestProtocolWrapMethodPassedFoo =~ foo
-      TestProtocolWrapMethodPassedBar =~ bar
+      ::TestProtocol::TestProtocolWrapMethodPassedFoo =~ foo
+      ::TestProtocol::TestProtocolWrapMethodPassedBar =~ bar
     end
   end
 
@@ -128,7 +128,7 @@ class TestProtocol < Test::Unit::TestCase
   end
 
   TestProtocolInheritance = Protocol do
-    inherit MyClass, :one_with_block
+    inherit TestProtocol::MyClass, :one_with_block
   end
 
   TestProtocolInheritanceC = Protocol do
@@ -617,4 +617,3 @@ class TestProtocol < Test::Unit::TestCase
     end
   end
 end
-  # vim: set et sw=2 ts=2:

data/tests/test_protocol_method_parser.rb

@@ -0,0 +1,146 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'protocol'
+
+class TestProtocolMethodParser < Test::Unit::TestCase
+  include Protocol
+
+  class A
+    def empty
+    end
+
+    def none()
+    end
+
+    def one_req(a)
+    end
+
+    def two_req(a, b)
+    end
+
+    def one_req_one_opt(a, b = nil)
+    end
+
+    def one_opt(a = nil)
+    end
+
+    def two_opt(a = nil, b = nil)
+    end
+
+    def one_req_rest(a, *b)
+    end
+
+    def one_opt_rest(a = nil, *b)
+    end
+
+    def block(&b)
+    end
+
+    def one_req_block(a, &b)
+    end
+
+    def one_opt_block(a = nil, &b)
+    end
+
+    def yield
+      yield
+    end
+
+    def yield_block(&b)
+      yield
+    end
+
+    def complex_end
+      a = :end
+      foo { }
+    end
+
+    def complex
+      foo { }
+    end
+  end
+
+  def test_args
+    m = :empty; mp = MethodParser.new(A, m)
+    assert_equal 0, mp.arity, "arity failed for A##{m}"
+    assert_equal [ ], mp.args, "args failed for A##{m}"
+    assert_equal [ ], mp.arg_kinds, "args failed for A##{m}"
+    assert !mp.complex?
+    m = :none; mp = MethodParser.new(A, m)
+    assert_equal 0, mp.arity, "arity failed for A##{m}"
+    assert_equal [ ], mp.args, "args failed for A##{m}"
+    assert_equal [ ], mp.arg_kinds, "args failed for A##{m}"
+    assert !mp.complex?
+    m = :one_req; mp = MethodParser.new(A, m)
+    assert_equal 1, mp.arity, "arity failed for A##{m}"
+    assert_equal [ :a ], mp.args, "args failed for A##{m}"
+    assert_equal [ :req ], mp.arg_kinds, "args failed for A##{m}"
+    assert !mp.complex?
+    m = :two_req; mp = MethodParser.new(A, m)
+    assert_equal 2, mp.arity, "arity failed for A##{m}"
+    assert_equal [ :req, :req ], mp.arg_kinds, "args failed for A##{m}"
+    assert_equal [ :a, :b ], mp.args, "args failed for A##{m}"
+    assert !mp.complex?
+    m = :one_req_one_opt; mp = MethodParser.new(A, m)
+    assert_equal -2, mp.arity, "arity failed for A##{m}"
+    assert_equal [ :a, :b ], mp.args, "args failed for A##{m}"
+    assert_equal [ :req, :opt ], mp.arg_kinds, "args failed for A##{m}"
+    assert !mp.complex?
+    m = :one_opt; mp = MethodParser.new(A, m)
+    assert_equal -1, mp.arity, "arity failed for A##{m}"
+    assert_equal [ :a ], mp.args, "args failed for A##{m}"
+    assert_equal [ :opt ], mp.arg_kinds, "args failed for A##{m}"
+    assert !mp.complex?
+    m = :two_opt; mp = MethodParser.new(A, m)
+    assert_equal -1, mp.arity, "arity failed for A##{m}"
+    assert_equal [ :a, :b ], mp.args, "args failed for A##{m}"
+    assert_equal [ :opt, :opt ], mp.arg_kinds, "args failed for A##{m}"
+    assert !mp.complex?
+    m = :one_req_rest; mp = MethodParser.new(A, m)
+    assert_equal -2, mp.arity, "arity failed for A##{m}"
+    assert_equal [ :a, :'*b' ], mp.args, "args failed for A##{m}"
+    assert_equal [ :req, :rest ], mp.arg_kinds, "args failed for A##{m}"
+    assert !mp.complex?
+    m = :one_opt_rest; mp = MethodParser.new(A, m)
+    assert_equal -1, mp.arity, "arity failed for A##{m}"
+    assert_equal [ :a, :'*b' ], mp.args, "args failed for A##{m}"
+    assert_equal [ :opt, :rest ], mp.arg_kinds, "args failed for A##{m}"
+    assert !mp.complex?
+    m = :block; mp = MethodParser.new(A, m)
+    assert_equal 0, mp.arity, "arity failed for A##{m}"
+    assert_equal [ :'&b' ], mp.args, "args failed for A##{m}"
+    assert_equal [ :block ], mp.arg_kinds, "args failed for A##{m}"
+    assert !mp.complex?
+    m = :one_req_block; mp = MethodParser.new(A, m)
+    assert_equal 1, mp.arity, "arity failed for A##{m}"
+    assert_equal [ :a, :'&b' ], mp.args, "args failed for A##{m}"
+    assert_equal [ :req, :block ], mp.arg_kinds, "args failed for A##{m}"
+    assert !mp.complex?
+    m = :one_opt_block; mp = MethodParser.new(A, m)
+    assert_equal -1, mp.arity, "arity failed for A##{m}"
+    assert_equal [ :a, :'&b' ], mp.args, "args failed for A##{m}"
+    assert_equal [ :opt, :block ], mp.arg_kinds, "args failed for A##{m}"
+    assert !mp.complex?
+    m = :yield_block; mp = MethodParser.new(A, m)
+    assert_equal 0, mp.arity, "arity failed for A##{m}"
+    assert_equal [ :'&b' ], mp.args, "args failed for A##{m}"
+    assert_equal [ :block ], mp.arg_kinds, "args failed for A##{m}"
+    assert !mp.complex?
+    m = :yield; mp = MethodParser.new(A, m)
+    assert_equal 0, mp.arity, "arity failed for A##{m}"
+    assert_equal [ :'&block' ], mp.args, "args failed for A##{m}"
+    assert_equal [ :block ], mp.arg_kinds, "args failed for A##{m}"
+    assert !mp.complex?
+    m = :complex_end; mp = MethodParser.new(A, m)
+    assert_equal 0, mp.arity, "arity failed for A##{m}"
+    assert_equal [ ], mp.args, "args failed for A##{m}"
+    assert_equal [ ], mp.arg_kinds, "args failed for A##{m}"
+    assert mp.complex?
+    m = :complex; mp = MethodParser.new(A, m)
+    assert_equal 0, mp.arity, "arity failed for A##{m}"
+    assert_equal [ ], mp.args, "args failed for A##{m}"
+    assert_equal [ ], mp.arg_kinds, "args failed for A##{m}"
+    assert mp.complex?
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: protocol
 version: !ruby/object:Gem::Version 
-  version: 0.8.2
+  version: 0.9.0
 platform: ruby
 authors: 
 - Florian Frank
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-28 00:00:00 +02:00
+date: 2009-08-11 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,6 +22,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "3.0"
     version: 
+- !ruby/object:Gem::Dependency 
+  name: ruby_parser
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+    version: 
 description: This library offers an implementation of protocols against which you can check the conformity of your classes or instances of your classes. They are a bit like Java Interfaces, but as mixin modules they can also contain already implemented methods. Additionaly you can define preconditions/postconditions for methods specified in a protocol.
 email: flori@ping.de
 executables: []
@@ -35,6 +45,9 @@ files:
 - COPYING
 - Rakefile
 - VERSION
+- benchmarks
+- benchmarks/data
+- benchmarks/method_parser.rb
 - doc-main.txt
 - examples
 - examples/comparing.rb
@@ -50,11 +63,15 @@ files:
 - lib/protocol
 - lib/protocol.rb
 - lib/protocol/core.rb
+- lib/protocol/method_parser
+- lib/protocol/method_parser/parse_tree.rb
+- lib/protocol/method_parser/ruby_parser.rb
 - lib/protocol/version.rb
 - make_doc.rb
 - protocol.gemspec
 - tests
 - tests/test_protocol.rb
+- tests/test_protocol_method_parser.rb
 has_rdoc: true
 homepage: http://protocol.rubyforge.org
 post_install_message: