reflexive 0.0.6 → 0.1.0

data/Gemfile

@@ -2,15 +2,17 @@ source "http://rubygems.org"
 
 # keeping this in sync with reflexive.gemspec manually
 
-gem "rack"
-gem "sinatra"
-gem "sinatra_more"
-gem "coderay"
-gem "rdiscount"
+gem "rack", "1.1.0"
+gem "sinatra", "1.0"
+gem "sinatra_more", "0.3.40"
+gem "coderay", "0.9.3"
+# gem "rdiscount"
 
 group :development do
   gem "rails", "3.0.0.beta3"
   gem "rspec", "2.0.0.beta.8"
-  gem "sinatra-reloader"
-  gem "thin"
+  gem "sinatra-reloader", "0.4.1"
+  gem "thin", "1.2.7"
+  gem "rack-test", "0.5.3"
+  gem "webrat", "0.7.1"
 end

data/Rakefile

@@ -8,14 +8,20 @@ end
 GEM_NAME = "reflexive"
 
 desc "Relese next version of reflexive gem (do that just after `git commit')"
-task :release do
+task :release => :spec 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
+  if ENV["GEM_VERSION"]
+    # release version passed in ENV["GEM_VERSION"]
+    new_version = ENV["GEM_VERSION"]
+  else
+    # by default release next minor version
+    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
+  end
 
   puts "Releasing #{ GEM_NAME } #{ new_version }"
 

data/config.ru

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

data/lib/reflexive/application.rb

@@ -12,10 +12,12 @@ require "reflexive/columnizer"
 require "reflexive/constantize"
 require "reflexive/descendants"
 require "reflexive/methods"
+require "reflexive/method_lookup"
 
 if ENV["SINATRA_RELOADER"]
   require "rails/all"
   require "arel"
+  require File.expand_path("../../../spec/integration_spec_fixture", __FILE__)
 
   module ::Kernel
     def r(*args)
@@ -60,10 +62,11 @@ module Reflexive
     end
 
     action "constant_lookup" do
-      if klass = Reflexive.constant_lookup(*params.values_at(:name, :scope))
+      if (klass = Reflexive.constant_lookup(*params.values_at(:name, :scope))) &&
+              (klass.instance_of?(Class) || klass.instance_of?(Module)) 
         redirect(constant_path(klass.to_s))
       else
-        e "failed to lookup constant `#{ params[:name] }' in scope #{ params[:scope] }"
+        e "failed to lookup class/module with name `#{ params[:name] }' in scope #{ params[:scope] }"
       end
     end
 
@@ -87,54 +90,71 @@ module Reflexive
       end
     end
 
-    get %r</reflexive/constants/([^/&#]+)/class_methods/([^/&#]+)/definition> do |klass, method|
+    def definition_action(klass, level, name)
       find_klass(klass)
-      @method_name = method
-      @path, @line = @klass.method(@method_name).source_location
-      @source = highlight_file(@path, :highlight_lines => [@line])
-      erb :methods_definition
+      @method_name = name
+      @path, @line = @klass.send(level == :class ? :method : :instance_method, @method_name).source_location
+      if @path.include?("(eval)")
+        e "#{ name } #{ level } method was generated using `eval' function and can't be browsed"
+      else
+        @source = highlight_file(@path, :highlight_lines => [@line])
+        erb :methods_definition
+      end
+    end
+
+    get %r</reflexive/constants/([^/&#]+)/class_methods/([^/&#]+)/definition> do |klass, method|
+      definition_action(klass, :class, method)
     end
 
     get %r</reflexive/constants/([^/&#]+)/instance_methods/([^/&#]+)/definition> do |klass, method|
+      definition_action(klass, :instance, method)
+    end
+
+    get %r</reflexive/constants/([^/&#]+)/instance_methods/([^/&#]+)/apidock> do |klass, method|
       find_klass(klass)
       @method_name = method
-      @path, @line = @klass.instance_method(@method_name).source_location
-      @source = highlight_file(@path, :highlight_lines => [@line])
-      erb :methods_definition
+      @level = :instance
+      erb :methods_apidock
     end
 
-    get %r</reflexive/constants/([^/&#]+)/methods/([^/&#]+)/apidock> do |klass, method|
+    get %r</reflexive/constants/([^/&#]+)/class_methods/([^/&#]+)/apidock> do |klass, method|
       find_klass(klass)
       @method_name = method
+      @level = :class
       erb :methods_apidock
     end
 
-    get %r</reflexive/constants/([^/&#]+)/class_methods/([^/&#]+)> do |klass, method|
-      find_klass(klass)
-      begin
-        if @klass.method(method).source_location
-          redirect(class_method_definition_path(klass, method) +
-                  "#highlighted")
+    def method_lookup_action(klass, level, name)
+      lookup = MethodLookup.new(klass: klass, level: level, name: name)
+      if definitions = lookup.definitions
+        if definitions.size == 1
+          redirect(new_method_definition_path(*definitions[0]) + "#highlighted")
+        else
+          @definitions, @klass, @level, @name, @last_resort_lookup_used =
+                  definitions, klass, level, name, lookup.last_resort_lookup_used?
+          erb :methods_choose
+        end
+      elsif documentations = lookup.documentations
+        if documentations.size == 1
+          redirect(method_documentation_path(*documentations[0]))
         else
-          redirect(method_documentation_path(klass, method))
+          raise ArgumentError, "don't know how to handle multiple documentations"
         end
-      rescue NameError
-        e "failed to find `#{ method }' class method for #{ klass }"
+      else
+        e "failed to find `#{ name }' #{ level } method for #{ klass }"
       end
+      #
+      # e "failed to find `#{ method }' instance method for #{ klass }"
+    end
+
+    get %r</reflexive/constants/([^/&#]+)/class_methods/([^/&#]+)> do |klass, method|
+      find_klass(klass)
+      method_lookup_action(@klass, :class, method)
     end
 
     get %r</reflexive/constants/([^/&#]+)/instance_methods/([^/&#]+)> do |klass, method|
       find_klass(klass)
-      begin
-        if @klass.instance_method(method).source_location
-          redirect(instance_method_definition_path(klass, method) +
-                  "#highlighted")
-        else
-          redirect(method_documentation_path(klass, method))
-        end
-      rescue NameError
-        e "failed to find `#{ method }' instance method for #{ klass }"
-      end
+      method_lookup_action(@klass, :instance, method)
     end
 
     get %r</reflexive/constants/([^/&#]+)> do |klass|

data/lib/reflexive/coderay_html_encoder.rb

@@ -33,7 +33,7 @@ module Reflexive
         super(text, type)
         @out << "</a>"
       else
-        super(text, type) rescue raise([text, type].inspect)
+        super(text, type)
       end
     end
 

data/lib/reflexive/coderay_ruby_scanner.rb

@@ -49,6 +49,7 @@ module Reflexive
       in_backtick = false
       in_symbol = false
       in_embexpr_nesting = 0
+
       scanner_events.each do |scanner_event|
         token_val, event, tags =
                 ReflexiveRipper.destruct_scanner_event(scanner_event)
@@ -107,6 +108,7 @@ module Reflexive
           #                  }
           #              ;
           @coderay_tokens << [token_val, :content]
+          @coderay_tokens.last << tags if tags
           @coderay_tokens << [:close, :symbol]
           in_symbol = false
         elsif ripper_token == :regexp_beg

data/lib/reflexive/core_ext/module/reflexive_instance_methods.rb

@@ -0,0 +1,44 @@
+class Module
+  if RUBY_VERSION > '1.9.1'
+    alias reflexive_public_instance_methods public_instance_methods
+    alias reflexive_private_instance_methods private_instance_methods
+    alias reflexive_protected_instance_methods protected_instance_methods
+  else
+    # Try to workaround 1.9.1 *_instance_methods issues
+    def reflexive_public_instance_methods(inc_super = true)
+      if inc_super
+        public_instance_methods(true)
+      else
+        methods = public_instance_methods(false)
+        methods -= Module.public_instance_methods(false) unless self === Module
+        methods -= Class.public_instance_methods(false) unless self === Class
+#        ancestors.each do |ancestor|
+#          methods -= ancestor.public_instance_methods(false)
+#        end
+        methods
+      end
+    end
+
+    def reflexive_protected_instance_methods(inc_super = true)
+      if inc_super
+        protected_instance_methods(true)
+      else
+        methods = protected_instance_methods(false)
+        methods -= Module.protected_instance_methods(false) unless self === Module
+        methods -= Class.protected_instance_methods(false) unless self === Class
+        methods
+      end
+    end
+
+    def reflexive_private_instance_methods(inc_super = true)
+      if inc_super
+        private_instance_methods(true)
+      else
+        methods = private_instance_methods(false)
+        methods -= Module.private_instance_methods(false) unless self === Module
+        methods -= Class.private_instance_methods(false) unless self === Class
+        methods
+      end
+    end
+  end
+end

data/lib/reflexive/descendants.rb

@@ -34,8 +34,18 @@ module Reflexive
       ancestors = c.singleton_class.ancestors[0 .. (generations || -1)]
       subclass << c if ancestors.include?(klass)
     end
-    
-    subclass
+
+    if klass.instance_of?(Module)
+      # descendants of module are also modules which include the module
+      ObjectSpace.each_object(Module) do |c|
+        next if c == klass
+
+        ancestors = c.ancestors[0 .. (generations || -1)]
+        subclass << c if ancestors.include?(klass)
+      end
+    end
+
+    subclass.uniq
   end
 end
 

data/lib/reflexive/helpers.rb

@@ -3,15 +3,26 @@ require "reflexive/coderay_ruby_scanner"
 require "reflexive/coderay_html_encoder"
 
 module Reflexive
+  def self.class_reloading_active?
+    if defined?(Rails)
+      !Rails.configuration.cache_classes rescue false
+    else
+      false
+    end
+  end
+
   FILE_EXT = /\.\w+\z/
   DL_EXT = /\.s?o\z/
   def self.load_path_lookup(path)
     path_with_rb_ext = path.sub(FILE_EXT, "") + ".rb"
-    feature = nil
-    $LOAD_PATH.detect do |load_path|
-      File.exists?(feature = File.join(load_path, path_with_rb_ext))
+
+    $LOAD_PATH.each do |load_path|
+      if feature = File.join(load_path, path_with_rb_ext)
+        return feature if File.exists?(feature)
+      end
     end
-    feature
+
+    nil
   end
 
   def self.loaded_features_lookup(path)
@@ -48,11 +59,11 @@ module Reflexive
         tokens = CodeRayRubyScanner.new(src).tokenize
         encoder = CodeRayHtmlEncoder.new(options)
         encoder.encode_tokens(tokens)
-      elsif path =~ /\.(markdown|md)$/
-        require "rdiscount"
-        src = IO.read(path)
-        markdown = RDiscount.new(src)
-        markdown.to_html
+#      elsif path =~ /\.(markdown|md)$/
+#        require "rdiscount"
+#        src = IO.read(path)
+#        markdown = RDiscount.new(src)
+#        markdown.to_html
       else
         CodeRay.scan_file(path).html(options).div
       end
@@ -169,6 +180,12 @@ module Reflexive
               :title => (method_name if link_text.include?("...")))
     end
 
+    def full_name_link_to_method(constant, level, method_name)
+      link_text = "#{ constant }#{ level == :instance ? "#" : "." }#{ method_name }"
+      link_to(Rack::Utils.escape_html(link_text),
+              new_method_path(constant, level, method_name))
+    end
+
     ##
     # Truncates a given text after a given :length if text is longer than :length (defaults to 30).
     # The last characters will be replaced with the :omission (defaults to "в_│") for a total length not exceeding :length.

data/lib/reflexive/method_lookup.rb

@@ -0,0 +1,199 @@
+require "reflexive/constantize"
+
+module Reflexive
+  class MethodLookup
+    def initialize(options)
+      unless (@klass, @level, @name = options.values_at(:klass, :level, :name)).all?
+        raise ArgumentError, "must pass :klass, :level, :name as named arguments"
+      end
+      @level, @name = @level.to_sym, @name.to_sym
+    end
+
+    def definitions
+      lookup unless @lookup_done
+      @definitions
+    end
+
+    def documentations
+      lookup unless @lookup_done
+      @documentations
+    end
+
+    def last_resort_lookup_used?
+      @last_resort_lookup_used
+    end
+
+    private
+
+    def lookup
+      begin
+        defined_method_lookup
+      rescue NameError => e
+        # don't swallow NameError if it's not related to the method we're looking for
+        raise unless e.message.include?(@name.to_s)
+        heuristic_lookup
+        last_resort_lookup unless lookup_succeed?
+      end
+      @lookup_done = true
+    end
+
+    def lookup_succeed?
+      @definitions && @definitions.size > 0 ||
+              @documentations && @documentations.size > 0
+    end
+
+    def defined_method_lookup
+      unbound_method = @klass.send(method_getter, @name)
+      if unbound_method.source_location
+        @definitions = [[@klass, @level, @name]]
+      elsif @klass.instance_of?(Class) && @level == :class && @name == :new &&
+              (@klass.instance_method(:initialize).source_location rescue false)
+        @definitions = [[@klass, :instance, :initialize]]
+      elsif core_klass = unbound_method.owner
+        if core_klass == Kernel
+          @documentations = [[Kernel, :instance, @name]]
+        elsif core_klass == Module || core_klass.to_s == "#<Class:Module>"
+          if (Module.methods(false) + Module.private_methods(false)).include?(@name)
+            @documentations = [[Module, :class, @name]]
+          else
+            @documentations = [[Module, :instance, @name]]
+          end
+        elsif core_klass == Class
+          if (Class.methods(false) + Class.private_methods(false)).include?(@name)
+            @documentations = [[Class, :class, @name]]
+          else
+            @documentations = [[Class, :instance, @name]]
+          end
+        else
+          if @level == :class
+            if core_klass == @klass
+              @documentations = [[core_klass, :class, @name]]
+            elsif core_klass.to_s =~ /^#<Class:(.+)>$/
+              # get class from singleton class
+             @documentations = [[Reflexive.constantize($1), :class, @name]]
+            end
+          else
+            @documentations = [[core_klass, @level, @name]]
+          end
+        end
+      end
+    end
+
+    def heuristic_lookup
+      if @klass.instance_of?(Module) && @level == :instance
+        # only instance methods are inherited from modules
+        potential_receivers = included_by_classes.select do |included_by_class|
+          all_instance_methods(included_by_class).include?(@name)
+        end
+
+        potential_receivers += included_by_modules.select do |included_by_module|
+          all_instance_methods(included_by_module).include?(@name)
+        end
+
+        potential_receivers.uniq.each do |receiver|
+          # TODO heuristic lookup shouldn't assume that found method is not core method
+          (@definitions ||= []) << [receiver, :instance, @name]
+        end
+
+        potential_class_receivers = included_by_singleton_classes.select do |included_by_singleton_class|
+          all_class_methods(included_by_singleton_class).include?(@name)
+        end
+
+        potential_class_receivers.uniq.each do |class_receiver|
+          (@definitions ||= []) << [class_receiver, :class, @name]
+        end
+      elsif @klass.instance_of?(Class)
+        # both instance and class methods are inherited by classes
+
+        potential_receivers = inherited_by_classes.select do |inherited_by_class|
+          all_level_methods(inherited_by_class).include?(@name)
+        end
+
+        potential_receivers.uniq.each do |receiver|
+
+          (@definitions ||= []) << [receiver, @level, @name]
+        end
+      end
+    end
+
+    def last_resort_lookup
+      @last_resort_lookup_used = true
+      seen = []
+      [Module, Class].each do |module_or_class|
+        ObjectSpace.each_object(module_or_class) do |m|
+          next if seen.include?(m)
+          if all_instance_methods(m).include?(@name)
+            (@definitions ||= []) << [m, :instance, @name]
+          end
+          if all_class_methods(m).include?(@name)
+            (@definitions ||= []) << [m, :class, @name]
+          end
+          seen << m
+        end
+      end
+    end
+
+    def all_instance_methods(klass)
+      klass.instance_methods(false) + klass.private_instance_methods(false)
+    end
+
+    def all_class_methods(klass)
+      klass.methods(false) + klass.private_methods(false)
+    end
+
+    def all_level_methods(klass)
+      @level == :instance ? all_instance_methods(klass) : all_class_methods(klass)
+    end
+
+    def included_by_classes
+      included_by = []
+      ObjectSpace.each_object(Class) do |c|
+        next if c == @klass
+
+        ancestors = c.ancestors
+        included_by << c if ancestors.include?(@klass)
+      end
+      included_by
+    end
+
+    alias inherited_by_classes included_by_classes
+
+    def included_by_modules
+      included_by = []
+      ObjectSpace.each_object(Module) do |m|
+        next if m == @klass
+
+        ancestors = m.ancestors
+        included_by << m if ancestors.include?(@klass)
+      end
+      included_by
+    end
+
+    def included_by_singleton_classes
+      included_by = []
+      ObjectSpace.each_object(Class) do |c|
+        next if c == @klass
+
+        ancestors = c.singleton_class.ancestors
+        included_by << c if ancestors.include?(@klass)
+      end
+      included_by
+    end
+
+    def method_getter
+      @level == :instance ? :instance_method : :method
+    end
+
+    def methods_getter
+      @level == :instance ? :instance_methods : :methods
+    end
+
+    def reverse_methods_getter
+      @level == :instance ? :methods : :instance_methods
+    end
+
+    def reverse_level
+      @level == :instance ? :class : :instance
+    end
+  end
+end