reflexive 0.0.1

data/lib/reflexive/application.rb

@@ -0,0 +1,171 @@
+require "sinatra/base"
+require "sinatra/reloader" if ENV["SINATRA_RELOADER"]
+require "sinatra_more/markup_plugin"
+
+require "coderay"
+require "andand"
+require "ostruct"
+require "open-uri"
+
+require "looksee"
+Looksee.styles.each { |k, _| Looksee.styles[k] = "%s" }
+
+require "reflexive/faster_open_struct"
+require "reflexive/helpers"
+require "reflexive/columnizer"
+require "reflexive/constantize"
+require "reflexive/descendants"
+require "reflexive/methods"
+
+if ENV["SINATRA_RELOADER"]
+  require "rails/all"
+  require "arel"
+
+  module ::Kernel
+    def r(*args)
+      raise((args.size == 1 ? args[0] : args).inspect)
+    end
+  end
+end
+
+module Reflexive
+  class Application < Sinatra::Base
+    register SinatraMore::MarkupPlugin
+    include Reflexive::Helpers
+
+    configure(:development) do
+      if ENV["SINATRA_RELOADER"]
+        register Sinatra::Reloader
+        also_reload "lib/**/*.rb"
+      end
+    end    
+
+    class << self
+      def root
+        require "pathname"
+        Pathname("../../../").expand_path(__FILE__)
+      end
+    end
+
+    set :public, self.root + "public"
+    set :views, self.root + "views"
+
+    def self.action(path, &block)
+      get("/reflexive/#{ path }", &block)
+    end
+
+    def e(message)
+      @message = message
+      erb :error
+    end
+
+    action "dashboard" do
+      erb :dashboard
+    end
+
+    action "constant_lookup" do
+      if klass = Reflexive.constant_lookup(*params.values_at(:name, :scope))
+        redirect(constant_path(klass.to_s))
+      else
+        e "failed to lookup constant `#{ params[:name] }' in scope #{ params[:scope] }"
+      end
+    end
+
+    action "files/*" do |path|
+      @path = "/" + path
+      if File.stat(@path).directory?
+        erb :directories_show
+      else
+        @source = highlight_file(@path)
+        erb :files_show
+      end
+    end
+
+    get "/reflexive/load_path_lookup" do
+      path = params[:path]
+      feature = Reflexive.loaded_features_lookup(path) || Reflexive.load_path_lookup(path)
+      if feature
+        redirect(file_path(feature))
+      else
+        e "failed to find feature: #{ path }"
+      end
+    end
+
+    get %r</reflexive/constants/([^/&#]+)/class_methods/([^/&#]+)/definition> do |klass, method|
+      find_klass(klass)
+      @method_name = method
+      @path, @line = @klass.method(@method_name).source_location
+      @source = highlight_file(@path, :highlight_lines => [@line])
+      erb :methods_definition
+    end
+
+    get %r</reflexive/constants/([^/&#]+)/instance_methods/([^/&#]+)/definition> 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
+    end
+
+    get %r</reflexive/constants/([^/&#]+)/methods/([^/&#]+)/apidock> do |klass, method|
+      find_klass(klass)
+      @method_name = method
+      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")
+        else
+          redirect(method_documentation_path(klass, method))
+        end
+      rescue NameError
+        e "failed to find `#{ method }' class method for #{ klass }"
+      end
+    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
+    end
+
+    get %r</reflexive/constants/([^/&#]+)> do |klass|
+      find_klass(klass)
+
+      exclude_trite = ![ BasicObject, Object ].include?(@klass)
+      @methods = Reflexive::Methods.new(@klass, :exclude_trite => exclude_trite)
+
+      ancestors_without_self_and_super = @klass.ancestors[2..-1] || []
+      class_ancestors = ancestors_without_self_and_super.select { |ancestor| ancestor.class == Class }
+      @class_ancestors = class_ancestors if class_ancestors.size > 0
+      
+      if @klass.respond_to?(:superclass) &&
+          @klass.superclass != Object &&
+          @klass.superclass != nil
+        @superclass = @klass.superclass  
+      end
+
+      erb :constants_show
+    end
+
+    protected
+
+    error(404) { @app.call(env) if @app }
+
+    def find_klass(klass = params[:klass])
+      @klass = Reflexive.constantize(klass) if klass 
+    end
+  end
+end

data/lib/reflexive/coderay_html_encoder.rb

@@ -0,0 +1,46 @@
+require "reflexive/routing_helpers"
+
+require "coderay"
+require "coderay/encoder"
+require "coderay/encoders/html"
+
+module Reflexive
+  class CodeRayHtmlEncoder < ::CodeRay::Encoders::HTML
+    include RoutingHelpers
+    
+    def token(text, type = :plain, tags = {})
+      if constant_access = tags[:constant_access]
+        name, scope = constant_access.values_at(:name, :scope)
+        @out << "<a href='#{ constant_lookup_path(name, scope) }'>"
+        super(text, type)
+        @out << "</a>"
+      elsif type == :meta_scope
+        # pass
+      elsif type == :content && tags[:load_path]
+        @out << "<a href='#{ load_path_lookup_path(text) }'>"
+        super(text, type)
+        @out << "</a>"
+      elsif method_call = tags[:method_call]
+        @out << "<a href='#{ method_call_path(method_call) }'>"
+        super(text, type)
+        @out << "</a>"
+      elsif local_variable_assignment = tags[:local_variable_assignment]
+        @out << "<span id='lv:#{ local_variable_assignment }'>"
+        super(text, type)
+        @out << "</span>"
+      elsif local_variable_access = tags[:local_variable_access]
+        @out << "<a href='#lv:#{ local_variable_access }' class='lva'>"
+        super(text, type)
+        @out << "</a>"
+      else
+        super(text, type) rescue raise([text, type].inspect)
+      end
+    end
+
+    def compile(tokens, options)
+      for token in tokens
+        token(*token)
+      end
+    end
+  end
+end

data/lib/reflexive/coderay_ruby_scanner.rb

@@ -0,0 +1,234 @@
+require "coderay"
+
+module Reflexive
+  require "reflexive/reflexive_ripper"
+
+  # TODO Heredocs in args are royally screwed
+  class CodeRayRubyScanner < ::CodeRay::Scanners::Scanner
+    SCANNER_EVENT_TO_CODERAY_TOKEN =
+            {
+                    :kw => :reserved,
+                    :nl => :space,
+                    :sp => :space,
+                    :ignored_nl => :space,
+                    # :tstring_beg => :delimiter,
+                    # :tstring_end => :delimiter,
+                    :tstring_content => :content,
+                    # Кipper reports rbrace always, CodeRay differentiates
+                    # between blocks, and rbraces in string interpol
+                    # :embexpr_beg => :inline_delimiter,
+                    :lbrace => :operator,
+                    :rbrace => :operator,
+                    :lparen => :operator,
+                    :rparen => :operator,
+                    :lbracket => :operator,
+                    :rbracket => :operator,
+                    :comma => :operator,
+                    :op => :operator,
+                    :int => :integer,
+                    :period => :operator,
+                    :const => :constant,
+                    :cvar => :class_variable,
+                    :ivar => :instance_variable,
+                    :gvar => :global_variable,
+                    :embvar => :escape, # ?
+                    :embdoc_beg => :comment,
+                    :embdoc => :comment,
+                    :embdoc_end => :comment,
+                    :qwords_beg => :content,
+                    :words_sep => :content,
+                    :CHAR => :integer,
+                    # * :constant => :class, CodeRay reports `class` token for
+                    #   class def, we report just `const` always
+                    # * Ripper doesn't have `char` event
+                    # * `42 if true` - CodeRay reports `pre_constant`
+            }
+
+    def coderay_tokens(scanner_events)
+      @coderay_tokens = []
+      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)
+        
+        #        if event == :meta_scope
+        #          @coderay_tokens << [token_val, event]
+        #          next
+        #        end
+        #
+        #        if token_val == :method_call
+        #          @coderay_tokens << [token_val, event, tags]
+        #          next
+        #        end
+
+        ripper_token = SCANNER_EVENT_TO_CODERAY_TOKEN[event.to_sym] || event.to_sym
+        if in_backtick && event == :lparen
+          @coderay_tokens.pop # remove [:open, :shell], [token_val, :delimiter]
+          @coderay_tokens.pop # and replace with method declaration
+          @coderay_tokens << ["`", :method]
+          @coderay_tokens << ["(", :operator]
+        elsif in_embexpr_nesting > 0 && event == :rbrace
+          @coderay_tokens << [token_val, :inline_delimiter]
+          @coderay_tokens << [:close, :inline]
+          in_embexpr_nesting -= 1
+        elsif event == :embexpr_beg
+          @coderay_tokens << [:open, :inline]
+          @coderay_tokens << [token_val, :inline_delimiter]
+          in_embexpr_nesting += 1
+        elsif in_symbol && [:ident, :const, :ivar, :cvar, :gvar, :op, :kw].include?(event)
+          # parse.y
+          #
+          # symbol		: tSYMBEG sym
+          #
+          #          sym		: fname
+          #              | tIVAR
+          #              | tGVAR
+          #              | tCVAR
+          #              ;
+          #
+          #          fname		: tIDENTIFIER
+          #              | tCONSTANT
+          #              | tFID
+          #              | op
+          #                  {
+          #                lex_state = EXPR_ENDFN;
+          #                $$ = $1;
+          #                  }
+          #              | reswords
+          #                  {
+          #                lex_state = EXPR_ENDFN;
+          #                  /*%%%*/
+          #                $$ = $<id>1;
+          #                  /*%
+          #                $$ = $1;
+          #                  %*/
+          #                  }
+          #              ;
+          @coderay_tokens << [token_val, :content]
+          @coderay_tokens << [:close, :symbol]
+          in_symbol = false
+        elsif ripper_token == :regexp_beg
+          @coderay_tokens << [:open, :regexp]
+          @coderay_tokens << [token_val, :delimiter]
+        elsif ripper_token == :regexp_end
+          @coderay_tokens << [token_val, :delimiter]
+          @coderay_tokens << [:close, :regexp]
+        elsif ripper_token == :tstring_beg
+          @coderay_tokens << [:open, :string]
+          @coderay_tokens << [token_val, :delimiter]
+        elsif ripper_token == :tstring_end
+          @coderay_tokens << [token_val, :delimiter]
+          if in_backtick
+            @coderay_tokens << [:close, :shell]
+            in_backtick = false
+          elsif in_symbol
+            @coderay_tokens << [:close, :symbol]
+            in_symbol = false
+          else
+            @coderay_tokens << [:close, :string]
+          end
+        elsif ripper_token == :symbeg
+          if in_symbol # nesting not supported
+            @coderay_tokens << [token_val, :symbol]
+          else
+            @coderay_tokens << [:open, :symbol]
+            @coderay_tokens << [token_val, :delimiter]
+            in_symbol = true
+          end
+        elsif ripper_token == :backtick
+          if in_backtick # nesting not supported 
+            @coderay_tokens << [token_val, :operator]
+          else
+            @coderay_tokens << [:open, :shell]
+            @coderay_tokens << [token_val, :delimiter]
+            in_backtick = true
+          end
+        else
+          if @coderay_tokens.size > 0 && @coderay_tokens[-1][1] == ripper_token
+            @coderay_tokens.last[0] << token_val # same consequent tokens get squeezed
+          else
+            @coderay_tokens << [token_val, ripper_token]
+            @coderay_tokens.last << tags if tags
+          end
+        end
+      end
+
+      tokens = @coderay_tokens
+      # tokens = squeeze_constants(tokens)
+      # tokens = inject_constant_tags(tokens)
+      tokens = inject_load_path_tags(tokens)
+      tokens
+    end
+
+    def squeeze_constants(coderay_tokens)
+      tokens = []
+      coderay_tokens.reverse_each do |token|
+        if tokens.size > 0
+          if token[1] == :constant &&
+            tokens[-1][1] == :constant
+            tokens[-1][0] = "#{ token[0] }#{ tokens[-1][0] }"
+          elsif token == [ "::", :operator ] &&
+            tokens[-1][1] == :constant
+            tokens[-1][0] = "#{ token[0] }#{ tokens[-1][0] }"
+          else
+            tokens << token
+          end
+        else
+          tokens << token
+        end
+      end
+      tokens.reverse
+    end
+
+    def inject_constant_tags(coderay_tokens)
+      scope = nil
+      coderay_tokens.each do |token|
+        if token[1] == :constant
+          token << { :scope => scope }
+        elsif token[0] == :method_call &&
+                token[1] == :open
+          begin
+          token[2][:scope] = scope
+          rescue Exception
+            r(token)
+            end
+          
+        elsif token[1] == :meta_scope
+          scope = token[0]
+          scope = nil if scope.empty?
+        end
+      end
+      coderay_tokens
+    end
+
+    def inject_load_path_tags(coderay_tokens)
+      state = nil
+      coderay_tokens.each do |token|
+        value, type = token
+        if state == nil && type == :ident && value =~ /\A(require|load)\z/
+          state = :ident
+        elsif state == :ident && [ :operator, :space ].include?(type)
+          # skip
+        elsif state == :ident && value == :open && type == :string
+          state = :open_string
+        elsif state == :open_string && type == :delimiter
+          # skip
+        elsif state == :open_string && type == :content
+          token << { :load_path => true }
+        else
+          state = nil
+        end
+      end
+      coderay_tokens
+    end
+
+    def scan_tokens(tokens, options)
+      parser = ReflexiveRipper.new(code)
+      parser.parse
+      tokens.replace(coderay_tokens(parser.scanner_events))
+      tokens
+    end
+  end
+end

data/lib/reflexive/columnizer.rb

@@ -0,0 +1,73 @@
+require "cgi"
+
+module Reflexive
+  module Columnizer
+    class << self
+      #
+      # Arrange the given strings in columns, restricted to the given
+      # width.  Smart enough to ignore content in terminal control
+      # sequences.
+      #
+      def columnize(strings, width)
+        return '' if strings.empty?
+        num_columns = 1
+        layout = [strings]
+        loop do
+          break if layout.first.length <= 1
+          next_layout = layout_in_columns(strings, num_columns + 1)
+          break if layout_width(next_layout) > width
+          layout = next_layout
+          num_columns += 1
+        end
+
+        pad_strings(layout)
+        rectangularize_layout(layout)
+        layout.transpose.map do |row|
+          '  ' + row.compact.join('  ')
+        end.join("\n") << "\n"
+      end
+
+      private # -----------------------------------------------------
+
+      def layout_in_columns(strings, num_columns)
+        strings_per_column = (strings.length / num_columns.to_f).ceil
+        (0...num_columns).map { |i| strings[i*strings_per_column...(i+1)*strings_per_column] || [] }
+      end
+
+      def layout_width(layout)
+        widths = layout_column_widths(layout)
+        widths.inject(0) { |sum, w| sum + w } + 2*layout.length
+      end
+
+      def layout_column_widths(layout)
+        layout.map do |column|
+          column.map { |string| display_width(string) }.max || 0
+        end
+      end
+
+      def display_width(string)
+        CGI.unescapeHTML(string.gsub(/<\/?.+?>/, '')).size
+      end
+
+      def pad_strings(layout)
+        widths = layout_column_widths(layout)
+        layout.each_with_index do |column, i|
+          column_width = widths[i]
+          column.each do |string|
+            padding = column_width - display_width(string)
+            string << ' '*padding
+          end
+        end
+      end
+
+      def rectangularize_layout(layout)
+        return if layout.length == 1
+        height = layout[0].length
+        layout[1..-1].each do |column|
+          column.length == height or
+                  column[height - 1] = nil
+        end
+      end
+    end
+  end
+end

data/lib/reflexive/constantize.rb

@@ -0,0 +1,71 @@
+module Reflexive
+  module_function
+
+  def constant_lookup(name, scope)
+    if name =~ /^::/
+      begin
+        return Reflexive.constantize(name)
+      rescue NameError, ArgumentError
+        return nil
+      end
+    end
+
+    scope_parts = scope.split("::")
+    
+    begin
+      name_with_scope = "#{ scope_parts.join("::") }::#{ name }"
+      return Reflexive.constantize(name_with_scope)
+    rescue NameError, ArgumentError
+      # For defined top-level module, when looked up from another class:
+      # ArgumentError: Object is not missing constant TopLevelConst!
+      #        from .../activesupport-2.3.5/lib/active_support/dependencies.rb:417:in `load_missing_constant'
+      retry if scope_parts.pop
+    end
+    
+    nil
+  end
+
+  # from C:\Users\work\Documents\ubuntu_shared\edge\vendor\rails\activesupport\lib\active_support\inflector\methods.rb
+  # Ruby 1.9 introduces an inherit argument for Module#const_get and
+  # #const_defined? and changes their default behavior.
+  if Module.method(:const_get).arity == 1
+    # Tries to find a constant with the name specified in the argument string:
+    #
+    #   "Module".constantize     # => Module
+    #   "Test::Unit".constantize # => Test::Unit
+    #
+    # The name is assumed to be the one of a top-level constant, no matter whether
+    # it starts with "::" or not. No lexical context is taken into account:
+    #
+    #   C = 'outside'
+    #   module M
+    #     C = 'inside'
+    #     C               # => 'inside'
+    #     "C".constantize # => 'outside', same as ::C
+    #   end
+    #
+    # NameError is raised when the name is not in CamelCase or the constant is
+    # unknown.
+    def constantize(camel_cased_word)
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      constant = Object
+      names.each do |name|
+        constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+      end
+      constant
+    end
+  else
+    def constantize(camel_cased_word) #:nodoc:
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      constant = Object
+      names.each do |name|
+        constant = constant.const_defined?(name, false) ? constant.const_get(name) : constant.const_missing(name)
+      end
+      constant
+    end
+  end
+end

data/lib/reflexive/descendants.rb

@@ -0,0 +1,39 @@
+module Reflexive
+  module_function
+  
+  # List all descedents of this class.
+  #
+  #   class X ; end
+  #   class A < X; end
+  #   class B < X; end
+  #   X.descendents  #=> [A,B]
+  #
+  # You may also limit the generational distance
+  # the subclass may be from the parent class.
+  #
+  #   class X ; end
+  #   class A < X; end
+  #   class B < A; end
+  #   X.descendents    #=> [A, B]
+  #   X.descendents(1) #=> [A]
+  #
+  # NOTE: This is a intensive operation. Do not
+  # expect it to be super fast.
+
+  def descendants(klass, generations=nil)
+    subclass = []
+    
+    ObjectSpace.each_object(Class) do |c|
+      next if c == klass
+      
+      ancestors = c.ancestors[0 .. (generations || -1)]
+      subclass << c if ancestors.include?(klass)
+
+      ancestors = c.singleton_class.ancestors[0 .. (generations || -1)]
+      subclass << c if ancestors.include?(klass)
+    end
+    
+    subclass
+  end
+end
+