reflexive 0.0.1

data/lib/reflexive/faster_open_struct.rb

@@ -0,0 +1,116 @@
+module Faster
+  # ## Faster::OpenStruct
+  #
+  # Up to 40 (!) times more memory efficient version of OpenStruct
+  #
+  # Differences from Ruby MRI OpenStruct:
+  #
+  # 1. Doesn't `dup` passed initialization hash (NOTE: only reference to hash is stored)
+  #
+  # 2. Doesn't convert hash keys to symbols (by default string keys are used,
+  #    with fallback to symbol keys)
+  #
+  # 3. Creates methods on the fly on `OpenStruct` class, instead of singleton class.
+  #    Uses `module_eval` with string to avoid holding scope references for every method.
+  #
+  # 4. Refactored, crud clean, spec covered :)
+  #
+  class OpenStruct
+    # Undefine particularly nasty interfering methods on Ruby 1.8
+    undef :type if method_defined?(:type)
+    undef :id if method_defined?(:id)
+    
+    def initialize(hash = nil)
+      @hash = hash || {}
+      @initialized_empty = hash == nil
+    end
+
+    def method_missing(method_name_sym, *args)
+      if method_name_sym.to_s[-1] == ?=
+        if args.size != 1
+          raise ArgumentError, "wrong number of arguments (#{args.size} for 1)", caller(1)
+        end
+
+        if self.frozen?
+          raise TypeError, "can't modify frozen #{self.class}", caller(1)
+        end
+
+        __new_ostruct_member__(method_name_sym.to_s.chomp("="))
+        send(method_name_sym, args[0])
+      elsif args.size == 0
+        __new_ostruct_member__(method_name_sym)
+        send(method_name_sym)
+      else
+        raise NoMethodError, "undefined method `#{method_name_sym}' for #{self}", caller(1)
+      end
+    end
+
+    def __new_ostruct_member__(method_name_sym)
+      self.class.module_eval <<-END_EVAL, __FILE__, __LINE__ + 1
+      def #{ method_name_sym }
+        @hash.fetch("#{ method_name_sym }", @hash[:#{ method_name_sym }]) # read by default from string key, then try symbol
+                                                                          # if string key doesn't exist
+      end
+      END_EVAL
+
+      unless method_name_sym.to_s[-1] == ?? # can't define writer for predicate method
+        self.class.module_eval <<-END_EVAL, __FILE__, __LINE__ + 1
+        def #{ method_name_sym }=(val)
+          if @hash.key?("#{ method_name_sym }") || @initialized_empty       # write by default to string key (when it is present
+                                                                            # in initialization hash or initialization hash
+                                                                            # wasn't provided)
+            @hash["#{ method_name_sym }"] = val                             # if it doesn't exist - write to symbol key
+          else
+            @hash[:#{ method_name_sym }] = val
+          end
+        end
+        END_EVAL
+      end
+    end
+
+    def empty?
+      @hash.empty?
+    end
+
+    #
+    # Compare this object and +other+ for equality.
+    #
+    def ==(other)
+      return false unless other.is_a?(self.class)
+      @hash == other.instance_variable_get(:@hash)
+    end
+
+    InspectKey = :__inspect_key__ # :nodoc:    
+
+    #
+    # Returns a string containing a detailed summary of the keys and values.
+    #
+    def inspect
+      str = "#<#{ self.class }"
+      str << " #{ @hash.map { |k, v| "#{ k }=#{ v.inspect }" }.join(", ") }" unless @hash.empty?
+      str << ">"
+    end
+
+    def inspect_with_reentrant_guard(default = "...")
+      Thread.current[InspectKey] ||= []
+
+      if Thread.current[InspectKey].include?(self)
+        return default # reenter detected
+      end
+
+      Thread.current[InspectKey] << self
+
+      begin
+        inspect_without_reentrant_guard
+      ensure
+        Thread.current[InspectKey].pop
+      end
+    end
+
+    alias_method :inspect_without_reentrant_guard, :inspect
+    alias_method :inspect, :inspect_with_reentrant_guard
+
+    alias :to_s :inspect
+  end
+end
+

data/lib/reflexive/helpers.rb

@@ -0,0 +1,189 @@
+require "reflexive/routing_helpers"
+require "reflexive/coderay_ruby_scanner"
+require "reflexive/coderay_html_encoder"
+
+module Reflexive
+  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))
+    end
+    feature
+  end
+
+  def self.loaded_features_lookup(path)
+    path_without_ext = path.sub(FILE_EXT, "")
+
+    $LOADED_FEATURES.reverse.reject do |feature|
+      feature =~ DL_EXT
+    end.detect do |feature|
+      feature_without_ext = feature.sub(FILE_EXT, "")
+
+      feature_without_ext =~ /\/#{ Regexp.escape(path_without_ext) }\z/
+    end    
+  end
+
+  module Helpers
+    include RoutingHelpers
+
+    def filter_existing_constants(constants)
+      constants.
+              select { |c| Kernel.const_defined?(c) }.
+              map { |c| Kernel.const_get(c) }
+    end
+
+    CODERAY_ENCODER_OPTIONS = {
+      :wrap => :div,
+      :css => :class,
+      :line_numbers => :inline
+    }.freeze
+
+    def highlight_file(path, options = {})
+      options = CODERAY_ENCODER_OPTIONS.merge(options)
+      if path =~ /\.rb$/
+        src = IO.read(path)
+        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
+      else
+        CodeRay.scan_file(path).html(options).div
+      end
+    end    
+    
+    def constant_name(klass)
+      klass.name || klass.to_s
+    end
+
+    def link_to_file(path, options = {})
+      link_text = if options[:file_name_only]
+        File.basename(path) + (path[-1] == ?/ ? "/" : "")
+      else
+        shorten_file_path(path)
+      end
+
+      link_to(link_text,
+              file_path(path),
+              :title => path,
+              :class => "path")
+    end
+
+    def shorten_file_path(path)
+      require "rbconfig"
+      path.
+        gsub(/\A#{ Regexp.escape(Gem.dir) }\/gems/, '#{gems}').
+        gsub(/\A#{ Config::CONFIG["rubylibdir"] }/, '#{rubylib}')
+    end
+
+    def load_and_highlight(location)
+      tokens = CodeRay.scan(IO.read(location), :ruby)
+
+      tokens.html(:line_numbers => :inline, :wrap => :page)
+    end
+
+    def methods_table(constant, lookup_path)
+      linked_methods = lookup_path.map do |name, visibility|
+        link_to_method(lookup_path.module_name.gsub(/\[|\]/, ""),
+                       name,
+                       visibility)
+      end
+
+      Reflexive::Columnizer.columnize(linked_methods, 120)
+    end
+
+    def new_methods_table(constant, level, methods)
+      linked_methods = methods.sort.map do |name|
+        new_link_to_method(constant, level, name)
+      end
+      Reflexive::Columnizer.columnize(linked_methods, 120)
+    end
+
+    def constants_table(base_constant, constants, width = 120)
+      Reflexive::Columnizer.columnize(constants_links(base_constant, constants), width)
+    end
+
+    def constants_list(base_constant, constants)
+      constants_links(base_constant, constants).join("<br/>")
+    end
+
+    def constants_links(base_constant, constants)
+      constants.map do |constant|
+        full_name = constant_name(constant)
+        [ full_name, constant ]
+      end.sort_by(&:first).map do |full_name, constant|
+        link_text = full_name.gsub("#{ base_constant }::", "")
+        link_to(link_text, constant_path(constant), :title => full_name)
+      end      
+    end
+
+    def instance_methods_table(lookup_path)
+      linked_methods = []
+
+      %w(public protected private).each do |visibility|
+        methods = lookup_path.module.send("#{ visibility }_instance_methods", false)
+        
+        linked_methods += methods.map do |name|
+          link_to_method(lookup_path.module_name.gsub(/\[|\]/, ""),
+                         name,
+                         visibility)
+        end
+      end
+
+      Reflexive::Columnizer.columnize(linked_methods, 120)
+    end
+
+    def just_methods_table(klass)
+      linked_methods = []
+
+      ancestors_with_methods = ActiveRecord::Base.ancestors.map do |a|
+        [a, a.methods(false).sort] unless a.methods(false).empty?
+      end.compact
+
+      ancestors_with_methods.each do |ancestor, ancestor_methods|
+        linked_methods += ancestor_methods.map do |name|
+          link_to_method(ancestor.name, name)
+        end
+      end
+      
+      Reflexive::Columnizer.columnize(linked_methods, 120)
+    end
+
+    def link_to_method(constant, method_name, visibility = nil)
+      link_text = truncate(method_name)
+      link_to(Rack::Utils.escape_html(link_text),
+              method_path(constant, method_name),
+              :title => (method_name if link_text.include?("...")))
+    end
+
+    def new_link_to_method(constant, level, method_name)
+      link_text = truncate(method_name)
+      link_to(Rack::Utils.escape_html(link_text),
+              new_method_path(constant, level, method_name),
+              :title => (method_name if link_text.include?("...")))
+    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.
+    #
+    # ==== Examples
+    #
+    #   truncate("Once upon a time in a world far far away", :length => 8) => "Once upon..."
+    #
+    def truncate(text, options={})
+      options.reverse_merge!(:length => 30, :omission => "...")
+      if text
+        len = options[:length] - options[:omission].length
+        chars = text
+        (chars.length > options[:length] ? chars[0...len] + options[:omission] : text).to_s
+      end
+    end
+  end
+end

data/lib/reflexive/methods.rb

@@ -0,0 +1,140 @@
+module Reflexive
+  class Methods
+    def initialize(klass_or_module, options = {})
+      @klass_or_module = klass_or_module
+      @ancestor_name_formatter = options.fetch(:ancestor_name_formatter,
+                                               default_ancestor_name_formatter)
+      @exclude_trite = options.fetch(:exclude_trite, true)
+    end
+
+    def all
+      @all ||= find_all
+    end
+
+    def files
+      @files ||= find_all_files
+    end
+
+    def constants
+      @constants ||= @klass_or_module.constants(true).map do |c|
+        @klass_or_module.const_get(c) rescue nil
+      end.compact.select do |c|
+        c.instance_of?(Class) || c.instance_of?(Module)
+      end # rescue r(@klass_or_module.constants)
+    end
+
+    def descendants
+      @descendants ||= Reflexive.descendants(@klass_or_module)
+    end
+
+    VISIBILITIES = [ :public, :protected, :private ].freeze
+
+    protected
+
+    def each_immediate_class_and_instance_method(&block)
+      VISIBILITIES.each do |visibility|
+        [ @klass_or_module, @klass_or_module.singleton_class ].each do |klass|
+          methods = klass.send("#{ visibility }_instance_methods", false)
+          methods.each { |m| block.call(klass.instance_method(m)) }
+        end
+      end
+    end
+
+    def find_all_files
+      source_locations = []
+      each_immediate_class_and_instance_method do |meth|
+        if location = meth.source_location
+          source_locations << location[0] unless source_locations.include?(location[0])
+        end
+      end
+      source_locations
+    end
+
+    def default_ancestor_name_formatter
+      proc do |ancestor, singleton|
+        ancestor_name(ancestor, singleton)
+      end
+    end
+
+    def find_all
+      ancestors = [] # flattened ancestors (both normal and singleton)
+
+      (@klass_or_module.ancestors - trite_ancestors).each do |ancestor|
+        ancestor_singleton = ancestor.singleton_class
+
+        # Modules don't inherit class methods from included modules
+        unless @klass_or_module.instance_of?(Module) && ancestor != @klass_or_module
+          class_methods = collect_instance_methods(ancestor_singleton)
+        end
+
+        instance_methods = collect_instance_methods(ancestor)
+
+        append_ancestor_entry(ancestors, @ancestor_name_formatter[ancestor, false],
+                              class_methods, instance_methods)
+
+        (singleton_ancestors(ancestor) || []).each do |singleton_ancestor|
+          class_methods = collect_instance_methods(singleton_ancestor)
+          append_ancestor_entry(ancestors, @ancestor_name_formatter[singleton_ancestor, true],
+                                class_methods)
+        end
+      end
+
+      ancestors
+    end
+
+    # singleton ancestors with ancestor introduced
+    def singleton_ancestors(ancestor)
+      @singleton_ancestors ||= all_singleton_ancestors
+      @singleton_ancestors[ancestor]
+    end
+
+    def all_singleton_ancestors
+      all = {}
+      seen = []
+      (@klass_or_module.ancestors - trite_ancestors).reverse.each do |ancestor|
+        singleton_ancestors = ancestor.singleton_class.ancestors - trite_singleton_ancestors
+        introduces = singleton_ancestors - seen
+        all[ancestor] = introduces unless introduces.empty?
+        seen.concat singleton_ancestors
+      end
+      all
+    end
+
+    def ancestor_name(ancestor, singleton)
+      "#{ singleton ? "S" : ""}[#{ ancestor.is_a?(Class) ? "C" : "M" }] #{ ancestor.name || ancestor.to_s }"
+    end
+
+    # ancestor is included only when contributes some methods
+    def append_ancestor_entry(ancestors, ancestor, class_methods, instance_methods = nil)
+      if class_methods || instance_methods
+        ancestor_entry = {}
+        ancestor_entry[:class] = class_methods if class_methods
+        ancestor_entry[:instance] = instance_methods if instance_methods
+        ancestors << {ancestor => ancestor_entry}
+      end
+    end
+
+    # Returns hash { :public => [...public methods...],
+    #                :protected => [...private methods...],
+    #                :private => [...private methods...] }
+    # keys with empty values are excluded,
+    # when no methods are found - returns nil
+    def collect_instance_methods(klass)
+      methods_with_visibility = VISIBILITIES.map do |visibility|
+        methods = klass.send("#{ visibility }_instance_methods", false)
+        [visibility, methods] unless methods.empty?
+      end.compact
+      Hash[methods_with_visibility] unless methods_with_visibility.empty?
+    end
+
+    def trite_singleton_ancestors
+      return [] unless @exclude_trite
+      @trite_singleton_ancestors ||= Class.new.singleton_class.ancestors
+    end
+
+    def trite_ancestors
+      return [] unless @exclude_trite
+      @trite_ancestors ||= Class.new.ancestors
+    end
+  end
+end