reflexive 0.0.3 → 0.0.4

data/Gemfile

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+
+# keeping this in sync with reflexive.gemspec manually
+
+gem "rack"
+gem "sinatra"
+gem "sinatra_more"
+gem "coderay"
+gem "rdiscount"
+
+group :development do
+  gem "rails", "3.0.0.beta3"
+  gem "rspec", "2.0.0.beta.8"
+  gem "sinatra-reloader"
+  gem "thin"
+end

data/Rakefile

@@ -0,0 +1,31 @@
+$LOAD_PATH.unshift(File.expand_path("../lib", __FILE__))
+
+desc "Run specs (without Rails integration spec - requires rvm, run manually with `spec ./spec/rails_integration_spec.rb')"
+task :spec do
+  sh "spec #{ (Dir["./spec/*_spec.rb"] - ["./spec/rails_integration_spec.rb"]).join(" ") }"
+end
+
+GEM_NAME = "reflexive"
+
+desc "Relese next version of reflexive gem"
+task :release do
+  require "rubygems"
+  require "rubygems/version"
+  require "yaml"
+
+  current_version = YAML.load(`gem specification #{ GEM_NAME } -r`)["version"] || Gem::Version.new("0.0.0")
+  new_version = (current_version.segments[0..-2] + [current_version.segments[-1].succ]).join(".")
+  ENV["GEM_VERSION"] = new_version
+
+  puts "Releasing #{ GEM_NAME } #{ new_version }"
+
+  sh "gem build #{ GEM_NAME }.gemspec --verbose"
+
+  sh "gem push #{ GEM_NAME }-#{ new_version }.gem --verbose"
+
+  sh "gem install #{ GEM_NAME } --version=#{ new_version } --local --verbose"
+
+  File.delete("#{ GEM_NAME }-#{ new_version }.gem")
+end
+
+task :default => :spec

data/config.ru

@@ -0,0 +1,3 @@
+require File.expand_path("../lib/reflexive/application", __FILE__)
+
+run Reflexive::Application

data/reflexive.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
   s.homepage    = "http://github.com/dolzenko/reflexive"
   s.summary     = "Reflexive"
 
-  s.files       = Dir.glob("{lib,public,views}/**/*") + %w(reflexive.gemspec)
+  s.files       = Dir.glob("{lib,public,views,spec}/**/*") + %w(reflexive.gemspec Rakefile Gemfile config.ru)
 
   s.required_ruby_version = '>= 1.9.1'
 

data/spec/coderay_html_encoder_spec.rb

@@ -0,0 +1,57 @@
+require "reflexive/coderay_html_encoder"
+
+describe Reflexive::CodeRayHtmlEncoder do
+  def encoder
+    Reflexive::CodeRayHtmlEncoder.new(:wrap => :div, :css => :style)
+  end
+  
+  it "emits links for :constant tokens" do
+    encoder = Reflexive::CodeRayHtmlEncoder.new(:wrap => :div, :css => :style)
+    encoder.encode_tokens([["Cons", :constant,
+                            {:constant_access=>{:name=>"Cons", :scope=>[]}}]]).should(include("<a href"))
+  end
+
+  it "emits links with proper nesting info" do
+    tokens = [["Cons", :constant,
+               {:constant_access=>{:name=>"Cons", :scope=>["A", "B"]}}]]
+    
+    encoder.encode_tokens(tokens).should include("constant_lookup?name=Cons&scope=A%3A%3AB")
+  end
+
+  it "emits load_path links" do
+    tokens = [["f", :content, { :load_path => true }]]
+    encoder.encode_tokens(tokens).should include("?path=f")
+  end
+
+  it "emits class method links" do
+    tokens = [ [
+                  "m!", :ident,
+                  {:method_call=>{:name=>"m!", :receiver=>["A"]} }
+             ] ]
+    encoder.encode_tokens(tokens).should include("/constants/A/class_methods/m%21")
+  end
+
+  it "emits instance method links" do
+    tokens = [ [
+                  "m!", :ident,
+                  {:method_call=>{:name=>"m!", :receiver=>["A", :instance]} }
+             ] ]
+    encoder.encode_tokens(tokens).should include("/constants/A/instance_methods/m%21")
+  end
+
+  it "emits variable assignment id" do
+    tokens = [ [
+                  "a", :ident,
+                  {:local_variable_assignment=>"1:a"}
+             ] ]
+    encoder.encode_tokens(tokens).should include("span id='lv:1:a'")
+  end
+
+  it "emits variable access links" do
+    tokens = [ [
+                  "a", :ident,
+                  {:local_variable_access=>"1:a"}
+             ] ]
+    encoder.encode_tokens(tokens).should include("href='#lv:1:a'")
+  end
+end

data/spec/coderay_ruby_scanner_spec.rb

@@ -0,0 +1,194 @@
+require "reflexive/coderay_ruby_scanner"
+require "coderay/scanners/ruby"
+
+describe Reflexive::CodeRayRubyScanner do
+  def reflexive_tokens(src)
+    Reflexive::CodeRayRubyScanner.new(src).tokenize
+  end
+
+  def reflexive_tokens_without_meta_and_tags(src)
+    Reflexive::CodeRayRubyScanner.new(src).tokenize.
+            reject { |t| t[1] == :meta_scope }.
+            reject { |t| t[0] == :method_call }.
+            map { |t| t[2].is_a?(Hash) ? t[0..1] : t }
+  end
+
+  def coderay_tokens(src)
+    squeezed_tokes = []
+    ::CodeRay::Scanners::Ruby.new(src).tokenize.each do |token|
+      if squeezed_tokes.size > 0 &&
+              squeezed_tokes[-1][1] == token[1]
+        squeezed_tokes[-1][0] << token[0]
+      else
+        squeezed_tokes << token
+      end
+    end
+  end
+
+  pending "squeezes constants" do
+    src = <<-RUBY
+      class ConstRef < Const::PathRef
+        RefenceConstInClassBody = ::TopConstRef
+        def m
+          Const::PathRef
+        end
+      end
+
+      class Const::PathRef < ::TopConstRef
+        def self.m
+          reference_in_method_body ::TopConstRef
+        end
+      end
+
+      class ::TopConstRef
+      end
+
+      class Const::Deeply::Nested::PathRef < ConstRef
+      end
+    RUBY
+    tokens = reflexive_tokens(src)
+    tokens.should include(["ConstRef", :constant, { :scope => nil }])
+    tokens.should include(["Const::PathRef", :constant, { :scope => ["ConstRef"] }])
+    tokens.should include(["Const::PathRef", :constant, { :scope => nil }])
+    tokens.should include(["::TopConstRef", :constant, { :scope => nil }])
+    tokens.should include(["::TopConstRef", :constant, { :scope => ["Const::PathRef"] }])
+    tokens.should include(["Const::Deeply::Nested::PathRef", :constant, { :scope => nil }])
+  end
+
+  it "injects load_path tags" do
+    reflexive_tokens("require('f')").should include(["f", :content, { :load_path => true }])
+    reflexive_tokens("require 'f'").should include(["f", :content, { :load_path => true }])
+  end
+
+  it "injects instance method tags"
+
+  ONE_LINERS = <<-RUBY.gsub(/^ */, "")
+    %Q{str}
+    %r<regexp>
+    :symbol
+    :@instance_var_symbol
+    :@@class_var_symbol
+    :$global_var_symbol
+    :ConstantSymbol
+    :+
+    :if
+    #!/usr/bin/env ruby
+    %q[haha! [nesting [rocks] ] ! ]
+    %Q[hehe! \#{ %Q]nesting \#{"really"} rocks] } ! ]
+    some_string.to_i /\\s+/
+    S = 'bla' * 100 + "\n" + "\t"*4
+    :"\#{undef :blubb}\#@@cv"
+    undef :"bla", /, :"\#{undef :blubb}\#@@cv"
+    @hash.delete_if { |o,| yield(o) }
+    "double quoted string"
+    # comment
+    "a \#{ b + "c"}"
+    42 if true
+    /regexp with modifiers/xm
+    a = ?s
+    q = "\\n"
+    call_something()
+    a = 1 && 2 || 3
+    @ivar = 123
+    @@cvar = 345
+    $gvar = 345
+    float = 1.2345
+    `shell`
+    v = %w(w1 w2)
+    "a\#{" b \#{@c} d" if @c} d \#{@e}; f."
+  RUBY
+
+  #  ONE_LINERS.split("\n").each do |src|
+  #    it "should parse `#{ src }' just as CodeRay parser does" do
+  #      reflexive_tokens(src).should == coderay_tokens(src)
+  #    end
+  #  end
+
+
+  it "generates CodeRay compatible token stream" do
+    src = <<-RUBY.gsub(/^ */, "")
+      #{ ONE_LINERS }
+      [].each do |*args, &block|
+        self.class.define_method do
+        end
+      end
+      class Qwe < Asd
+        alias qwe asd
+        module Sdf
+          def self.sm
+          end
+        end
+      end
+      =begin
+        heredoc1
+      =end
+      <<-QWE
+      QWE
+      if 1 > 0
+      elsif false
+      end
+      begin
+        42
+      rescue Exception => e
+        [] << 'q'
+      end
+      def `(cmd)
+      end
+    RUBY
+    expected_tokens = [
+    [:open, :string], ["%Q{", :delimiter], ["str", :content], ["}", :delimiter], [:close, :string], ["\n", :space],
+    [:open, :regexp], ["%r<", :delimiter], ["regexp", :content], [">", :delimiter], [:close, :regexp], ["\n", :space],
+    [:open, :symbol], [":", :delimiter], ["symbol", :content], [:close, :symbol], ["\n", :space],
+    [:open, :symbol], [":", :delimiter], ["@instance_var_symbol", :content], [:close, :symbol], ["\n", :space],
+    [:open, :symbol], [":", :delimiter], ["@@class_var_symbol", :content], [:close, :symbol], ["\n", :space],
+    [:open, :symbol], [":", :delimiter], ["$global_var_symbol", :content], [:close, :symbol], ["\n", :space],
+    [:open, :symbol], [":", :delimiter], ["ConstantSymbol", :content], [:close, :symbol], ["\n", :space],
+    [:open, :symbol], [":", :delimiter], ["+", :content], [:close, :symbol], ["\n", :space],
+    [:open, :symbol], [":", :delimiter], ["if", :content], [:close, :symbol], ["\n", :space],
+    ["#!/usr/bin/env ruby\n", :comment], [:open, :string], ["%q[", :delimiter], ["haha! [nesting [rocks] ] ! ", :content], ["]", :delimiter], [:close, :string], ["\n", :space],
+    [:open, :string], ["%Q[", :delimiter], ["hehe! ", :content], [:open, :inline], ["\#{", :inline_delimiter], [" ", :space], [:open, :string], ["%Q]", :delimiter], ["nesting ", :content], [:open, :inline], ["\#{", :inline_delimiter], [:open, :string], ["\"", :delimiter], ["really", :content], ["\"", :delimiter], [:close, :string], ["}", :inline_delimiter], [:close, :inline], [" rocks", :content], ["]", :delimiter], [:close, :string], [" ", :space], ["}", :inline_delimiter], [:close, :inline], [" ! ", :content], ["]", :delimiter], [:close, :string], ["\n", :space],
+    ["some_string", :ident], [".", :operator], ["to_i", :ident], [" ", :space], [:open, :regexp], ["/", :delimiter], ["\\s+", :content], ["/", :delimiter], [:close, :regexp], ["\n", :space],
+    ["S", :constant], [" ", :space], ["=", :operator], [" ", :space], [:open, :string], ["'", :delimiter], ["bla", :content], ["'", :delimiter], [:close, :string], [" ", :space], ["*", :operator], [" ", :space], ["100", :integer], [" ", :space], ["+", :operator], [" ", :space], [:open, :string], ["\"", :delimiter], ["\n", :content], ["\"", :delimiter], [:close, :string], [" ", :space], ["+", :operator], [" ", :space], [:open, :string], ["\"", :delimiter], ["\t", :content], ["\"", :delimiter], [:close, :string], ["*", :operator], ["4", :integer], ["\n", :space],
+    [:open, :symbol], [":\"", :delimiter], [:open, :inline], ["\#{", :inline_delimiter], ["undef", :content], [:close, :symbol], [" ", :space], [:open, :symbol], [":", :delimiter], ["blubb", :content], [:close, :symbol], ["}", :inline_delimiter], [:close, :inline], ["#", :escape], ["@@cv", :class_variable], ["\"", :delimiter], [:close, :string], ["\n", :space],
+    ["undef", :reserved], [" ", :space], [:open, :symbol], [":\"", :delimiter], ["bla", :content], ["\"", :delimiter], [:close, :symbol], [",", :operator], [" ", :space], ["/,", :operator], [" ", :space], [:open, :symbol], [":\"", :delimiter], [:open, :inline], ["\#{", :inline_delimiter], ["undef", :content], [:close, :symbol], [" ", :space], [:open, :symbol], [":", :delimiter], ["blubb", :content], [:close, :symbol], ["}", :inline_delimiter], [:close, :inline], ["#", :escape], ["@@cv", :class_variable], ["\"", :delimiter], [:close, :string], ["\n", :space],
+    ["@hash", :instance_variable], [".", :operator], ["delete_if", :ident], [" ", :space], ["{", :operator], [" ", :space], ["|", :operator], ["o", :ident], [",|", :operator], [" ", :space], ["yield", :reserved], ["(", :operator], ["o", :ident], [")", :operator], [" ", :space], ["}", :operator], ["\n", :space],
+    [:open, :string], ["\"", :delimiter], ["double quoted string", :content], ["\"", :delimiter], [:close, :string], ["\n", :space],
+    ["# comment\n", :comment], [:open, :string], ["\"", :delimiter], ["a ", :content], [:open, :inline], ["\#{", :inline_delimiter], [" ", :space], ["b", :ident], [" ", :space], ["+", :operator], [" ", :space], [:open, :string], ["\"", :delimiter], ["c", :content], ["\"", :delimiter], [:close, :string], ["}", :inline_delimiter], [:close, :inline], ["\"", :delimiter], [:close, :string], ["\n", :space],
+    ["42", :integer], [" ", :space], ["if", :reserved], [" ", :space], ["true", :reserved], ["\n", :space],
+    [:open, :regexp], ["/", :delimiter], ["regexp with modifiers", :content], ["/xm", :delimiter], [:close, :regexp], ["\n", :space],
+    ["a", :ident], [" ", :space], ["=", :operator], [" ", :space], ["?s", :integer], ["\n", :space],
+    ["q", :ident], [" ", :space], ["=", :operator], [" ", :space], [:open, :string], ["\"", :delimiter], ["\\n", :content], ["\"", :delimiter], [:close, :string], ["\n", :space],
+    ["call_something", :ident], ["()", :operator], ["\n", :space],
+    ["a", :ident], [" ", :space], ["=", :operator], [" ", :space], ["1", :integer], [" ", :space], ["&&", :operator], [" ", :space], ["2", :integer], [" ", :space], ["||", :operator], [" ", :space], ["3", :integer], ["\n", :space],
+    ["@ivar", :instance_variable], [" ", :space], ["=", :operator], [" ", :space], ["123", :integer], ["\n", :space],
+    ["@@cvar", :class_variable], [" ", :space], ["=", :operator], [" ", :space], ["345", :integer], ["\n", :space],
+    ["$gvar", :global_variable], [" ", :space], ["=", :operator], [" ", :space], ["345", :integer], ["\n", :space],
+    ["float", :ident], [" ", :space], ["=", :operator], [" ", :space], ["1.2345", :float], ["\n", :space],
+    [:open, :shell], ["`", :delimiter], ["shell", :content], ["`", :delimiter], [:close, :shell], ["\n", :space],
+    ["v", :ident], [" ", :space], ["=", :operator], [" ", :space], ["%w(w1 w2)", :content], ["\n", :space],
+    [:open, :string], ["\"", :delimiter], ["a", :content], [:open, :inline], ["\#{", :inline_delimiter], [:open, :string], ["\"", :delimiter], [" b ", :content], [:open, :inline], ["\#{", :inline_delimiter], ["@c", :instance_variable], ["}", :inline_delimiter], [:close, :inline], [" d", :content], ["\"", :delimiter], [:close, :string], [" ", :space], ["if", :reserved], [" ", :space], ["@c", :instance_variable], ["}", :inline_delimiter], [:close, :inline], [" d ", :content], [:open, :inline], ["\#{", :inline_delimiter], ["@e", :instance_variable], ["}", :inline_delimiter], [:close, :inline], ["; f.", :content], ["\"", :delimiter], [:close, :string], ["\n\n", :space], ["[].", :operator], ["each", :ident], [" ", :space], ["do", :reserved], [" ", :space], ["|*", :operator], ["args", :ident], [",", :operator], [" ", :space], ["&", :operator], ["block", :ident], ["|", :operator], ["\n", :space],
+    ["self", :reserved], [".", :operator], ["class", :ident], [".", :operator], ["define_method", :ident], [" ", :space], ["do", :reserved], ["\n", :space],
+    ["end", :reserved], ["\n", :space],
+    ["end", :reserved], ["\n", :space],
+    ["class", :reserved], [" ", :space], ["Qwe", :constant], [" ", :space], ["<", :operator], [" ", :space], ["Asd", :constant], ["\n", :space],
+    ["alias", :reserved], [" ", :space], ["qwe", :ident], [" ", :space], ["asd", :ident], ["\n", :space],
+    ["module", :reserved], [" ", :space], ["Sdf", :constant], ["\n", :space],
+    ["def", :reserved], [" ", :space], ["self", :reserved], [".", :operator], ["sm", :ident], ["\n", :space],
+    ["end", :reserved], ["\n", :space],
+    ["end", :reserved], ["\n", :space],
+    ["end", :reserved], ["\n", :space],
+    ["=begin\nheredoc1\n=end\n", :comment], ["<<-QWE", :heredoc_beg], ["\n", :space],
+    ["if", :reserved], [" ", :space], ["1", :integer], [" ", :space], [">", :operator], [" ", :space], ["0", :integer], ["\n", :space],
+    ["elsif", :reserved], [" ", :space], ["false", :reserved], ["\n", :space],
+    ["end", :reserved], ["\n", :space],
+    ["begin", :reserved], ["\n", :space],
+    ["42", :integer], ["\n", :space],
+    ["rescue", :reserved], [" ", :space], ["Exception", :constant], [" ", :space], ["=>", :operator], [" ", :space], ["e", :ident], ["\n", :space],
+    ["[]", :operator], [" ", :space], ["<<", :operator], [" ", :space], [:open, :string], ["'", :delimiter], ["q", :content], ["'", :delimiter], [:close, :string], ["\n", :space],
+    ["end", :reserved], ["\n", :space],
+    ["def", :reserved], [" ", :space], ["`", :method], ["(", :operator], ["cmd", :ident], [")", :operator], ["\n", :space],
+    ["end", :reserved], ["\n", :space]]
+    reflexive_tokens_without_meta_and_tags(src).should == expected_tokens
+  end
+end
+

data/spec/io_interceptor.rb

@@ -0,0 +1,64 @@
+# Safe way to intercept IO stream
+# where just replacing STDOUT doesn't work:
+# http://rubyforge.org/tracker/index.php?func=detail&aid=5217&group_id=426&atid=1698
+#
+module IoInterceptor
+  def intercept
+    begin
+      @intercept = true
+      @intercepted = ""
+      yield
+    ensure
+      @intercept = false
+    end
+    @intercepted
+  end
+
+  def supress
+    begin
+      @supress = true
+      yield
+    ensure
+      @supress = false
+    end
+  end
+
+  def write(str)
+    if @supress || @intercept
+      @intercepted << str.to_s unless @supress 
+      str.size
+    else
+      super
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  require 'spec'
+
+  describe IoInterceptor do
+    before do
+      STDOUT.extend(IoInterceptor)
+    end
+
+    it "intercepts output to stream when the stream is extended with it" do
+      STDOUT.intercept { STDOUT.puts("42") }.should == "42\n"
+      STDOUT.intercept { STDOUT.puts("24") }.should == "24\n"
+    end
+
+    it "intercepted IO#write still returns the number of bytes written" do
+      STDOUT.intercept { STDOUT.write("42").should == 2 }
+    end
+
+    it "intercepted IO#write argument is converted using to_s" do
+      obj = "42"
+      def obj.to_s
+        "custom to_s"
+      end
+      
+      STDOUT.intercept { STDOUT.puts(obj) }.should == "#{ obj.to_s }\n"
+    end
+  end
+
+  exit ::Spec::Runner::CommandLine.run
+end

data/spec/methods_spec.rb

@@ -0,0 +1,202 @@
+require "reflexive/methods"
+
+Rspec::Matchers.define :generate_methods do |expected|
+  match do |actual|
+    Reflexive::Methods.new(actual).all == eval(expected)
+  end
+
+  failure_message_for_should do |actual|
+    require "pp"
+    require "stringio"
+    pp_out = StringIO.new
+    PP.pp(Reflexive::Methods.new(actual).all, pp_out)
+    "expected:\n#{ expected }\ngot:\n#{ pp_out.string }"
+  end
+end
+
+describe Reflexive::Methods do
+  describe "ModuleInclusionC" do
+    module ModuleInclusionA
+      def module_instance_from_A_WTF!
+      end
+    end
+
+    module ModuleInclusionB
+      include ModuleInclusionA
+
+      def module_instance_from_B_WTF!
+      end
+    end
+
+    module ModuleInclusionC
+      include ModuleInclusionB
+    end
+
+    it "works" do
+      ModuleInclusionC.should generate_methods(<<-METHODS_PP)
+      [{"[M] ModuleInclusionB"=>
+       {:instance=>{:public=>[:module_instance_from_B_WTF!]}}},
+       {"[M] ModuleInclusionA"=>
+       {:instance=>{:public=>[:module_instance_from_A_WTF!]}}}]
+      METHODS_PP
+    end
+  end
+  describe "Inheritance" do
+    class InheritanceA
+      def self.singleton_inherited_from_A_WTF!
+      end
+    end
+
+    class InheritanceB < InheritanceA
+    end
+
+    class InheritanceC < InheritanceB
+      def test
+      end
+    end
+    
+    it "works" do
+      InheritanceC.should generate_methods(<<-METHODS_PP)
+      [{"[C] InheritanceC"=>{:instance=>{:public=>[:test]}}},
+       {"[C] InheritanceA"=>{:class=>{:public=>[:singleton_inherited_from_A_WTF!]}}}]
+      METHODS_PP
+    end
+  end
+
+  describe "SingletonAndInstance" do
+    module M
+      def instance_from_moduleWTF!
+      end
+    end
+
+    module SM
+      def singleton_from_moduleWTF!
+      end
+    end
+
+    class SingletonAndInstanceTest
+      include M
+      extend SM
+
+      def self.singletonWTF!
+      end
+
+      def instanceWTF!
+      end
+    end
+    
+    it "works" do
+      SingletonAndInstanceTest.should generate_methods(<<-METHODS_PP)
+      [{"[C] SingletonAndInstanceTest"=>
+         {:class=>{:public=>[:singletonWTF!]},
+          :instance=>{:public=>[:instanceWTF!]}}},
+       {"S[M] SM"=>{:class=>{:public=>[:singleton_from_moduleWTF!]}}},
+       {"[M] M"=>{:instance=>{:public=>[:instance_from_moduleWTF!]}}}]
+      METHODS_PP
+    end
+  end
+
+  describe "ExtendWithInstanceAndClass" do
+    module ExtendWithInstanceAndClassM
+      def self.singleton_WTF!
+      end
+
+      def instance_WTF!
+      end
+    end
+
+    class ExtendWithInstanceAndClass
+      extend ExtendWithInstanceAndClassM
+    end
+
+    it "works" do
+      ExtendWithInstanceAndClass.should generate_methods(<<-METHODS_PP)
+      [{"S[M] ExtendWithInstanceAndClassM"=>{:class=>{:public=>[:instance_WTF!]}}}]
+      METHODS_PP
+    end
+  end
+
+  describe "SingletonVisibility" do
+    class SingletonVisibility
+      def self.class_method
+      end
+
+      class << self
+
+        def public_singleton_method
+        end
+        public :public_singleton_method
+
+        def protected_singleton_method
+        end
+        protected :protected_singleton_method
+
+        def private_singleton_method
+        end
+        private :private_singleton_method
+      end
+    end
+
+    it "works" do
+      SingletonVisibility.should generate_methods(<<-METHODS_PP)
+      [{"[C] SingletonVisibility"=>
+         {:class=>
+           {:public=>[:class_method, :public_singleton_method],
+            :protected=>[:protected_singleton_method],
+            :private=>[:private_singleton_method]}}}]
+      METHODS_PP
+    end
+  end
+
+  describe "SingletonOverrides" do
+    class SingletonOverridesA
+      def self.overriden
+        puts "A"
+        # super
+      end
+    end
+
+    module SingletonOverridesMB
+      def overriden
+        puts "  MB"
+        super
+      end
+    end
+
+    class SingletonOverridesB < SingletonOverridesA
+      extend SingletonOverridesMB
+
+      def self.overriden
+      end
+    end
+
+    module SingletonOverridesMC
+      def overriden
+      end
+
+      def singleton_WTF
+      end
+    end
+
+    class SingletonOverridesC < SingletonOverridesB
+      extend SingletonOverridesMC
+
+      def self.class_WTF
+      end
+
+      def self.overriden
+      end
+    end
+    
+    it "works" do
+      SingletonOverridesC.should generate_methods(<<-METHODS_PP)
+        [{"[C] SingletonOverridesC"=>{:class=>{:public=>[:class_WTF, :overriden]}}},
+         {"S[M] SingletonOverridesMC"=>
+           {:class=>{:public=>[:overriden, :singleton_WTF]}}},
+         {"[C] SingletonOverridesB"=>{:class=>{:public=>[:overriden]}}},
+         {"S[M] SingletonOverridesMB"=>{:class=>{:public=>[:overriden]}}},
+         {"[C] SingletonOverridesA"=>{:class=>{:public=>[:overriden]}}}]
+      METHODS_PP
+    end
+  end
+end