class_source 0.0.0

data/lib/class_source/collator.rb

@@ -0,0 +1,80 @@
+require 'ruby_parser'
+
+module ClassSource
+  class Collator
+    def initialize(target_class, index)
+      @klass = target_class
+      @source = index
+    end
+
+    def to_hash(options = {})
+      full_sources = @source.locations(options).inject({}) do |results, location|
+        results[ location ] = source_helper(location)
+        results
+      end
+
+      return full_sources unless options[:include_nested] == false
+      full_sources.inject({}) do |clean_sources, (location, source)|
+        if nested_class_line_ranges[location.first]
+          complete_file = full_file(location)
+          target_range =  (location.last - 1)..(location.last + source.lines.count - 2)
+          clean_sources[location] = complete_file.lines.to_a.select.with_index do |line, index|
+            target_range.include?(index) &&
+            nested_class_line_ranges[location.first].all? { |range| !range.include?(index) }
+          end.join("")
+        else
+          clean_sources[location] = source
+        end
+        clean_sources
+      end
+    end
+
+    def nested_class_line_ranges
+      nested_classes = @klass.constants.select { |c| @klass.const_get(c).is_a?(Class) }.map {|c| @klass.const_get(c) }
+      return @nested_class_ranges if @nested_class_ranges
+      @nested_class_ranges = {}
+      nested_classes.each do |klass| 
+        # (klass.source_location.last-1)..(klass.source_location.last + klass.source.lines.count - 2)
+        klass.__source__.all.each do |(file, line), source| 
+          @nested_class_ranges[file] ||= []
+          @nested_class_ranges[file] << ((line - 1)..(line + source.lines.count - 2))
+        end
+      end
+
+      @nested_class_ranges
+    end
+
+    def full_file(location)
+      File.read(location.first)
+    end
+
+    # source_helper and valid_expression? are lifted from method_source
+    # (c) 2011 John Mair (banisterfiend)
+    def source_helper(source_location)
+      return nil if !source_location.is_a?(Array)
+
+      file_name, line = source_location
+      File.open(file_name) do |file|
+        (line - 1).times { file.readline }
+
+        code = ""
+        loop do
+          val = file.readline
+          code << val
+
+          return code if valid_expression?(code)
+        end
+      end
+    end
+
+
+    def valid_expression?(code)
+      RubyParser.new.parse(code)
+    rescue Racc::ParseError, SyntaxError
+      false
+    else
+      true
+    end
+
+  end
+end

data/lib/class_source/declarations.rb

@@ -0,0 +1,21 @@
+module ClassSource
+  class Declarations
+    def self.[](key)
+      @declarations ||= {}
+      @declarations[key]
+    end
+
+    def self.add(klass_name, locations)
+      @declarations ||= {}
+      @declarations[klass_name] ||= []
+      @declarations[klass_name] += locations
+    end
+
+    def self.save(declarations)
+      declarations.each do |klass_name, locations|
+        add(klass_name, locations)
+      end
+    end
+  end
+end
+

data/lib/class_source/guesser.rb

@@ -0,0 +1,25 @@
+module ClassSource
+  class Guesser
+    def initialize(klass, source_files)
+      @source_files = source_files
+      @klass = klass
+    end
+
+    def locations
+      return if @source_files.empty?
+      @source_files.map do |file|
+        [file, find_module_name(File.read(file))]
+      end.select { |result| !result.last.nil? }
+    end
+
+    private
+
+    def find_module_name(text)
+      submodule_name = @klass.name.split("::").last
+      text.lines.each.with_index do |line, index|
+        return index + 1 if line.match /\b#{submodule_name}\b/
+      end
+      nil
+    end
+  end
+end

data/lib/class_source/index.rb

@@ -0,0 +1,41 @@
+module ClassSource
+  class Index
+    def initialize(target_class, options = {})
+      @target_class = target_class
+      @options = options
+    end
+
+    def to_s(options={})
+      all(options).values.join("")
+    end
+
+    def ==(value)
+      to_s == value
+    end
+
+    def all(options={})
+      @collator ||= Collator.new(@target_class, self).to_hash(options)
+    end
+
+    def locations(options={})
+      locator.to_a
+    end
+
+    def methods
+      @method_details ||= MethodIndex.new(@target_class)
+    end
+
+    def class_methods
+      methods.klass
+    end
+
+    def locator
+      @locator ||= Locator.new(@target_class, @options)
+    end
+
+    def files
+      locator.files
+    end
+
+  end
+end

data/lib/class_source/locator.rb

@@ -0,0 +1,74 @@
+require 'tempfile'
+require 'yaml'
+
+module ClassSource
+  class Locator
+    def initialize(target_class, options={})
+      @klass = target_class
+      @options=options
+    end
+
+    def to_a
+      source_locations
+    end
+
+    def methods
+      MethodIndex.new(@klass)
+    end
+
+    def files(options={})
+      @source_files ||= methods.locations.map(&:first).uniq
+      return @source_files + [@options[:file]] if @options[:file]
+      @source_files
+    end
+
+    def source_locations(options={})
+      return @locations if @locations
+      t = Tempfile.new('class_creation_events')
+      fork do
+        declarations = files(options).inject({}) do |declarations, source_file|
+          trace_declarations(source_file, declarations)
+        end
+        YAML.dump(declarations, t)
+      end
+      Process.wait
+      Declarations.save YAML.load_file(t.path)
+      t.close
+      @locations = if !Declarations[@klass.name].nil?
+        Declarations[@klass.name].uniq 
+      else
+        Guesser.new(@klass, files).locations || [] 
+      end
+    end
+
+    def trace_declarations(source_file, declarations)
+      set_trace_func lambda { |event, file, line, id, binding, classname|
+        defined_class = standard_class_declared(event, binding) || dynamic_class_declared(id, classname, file, line)
+        break unless defined_class
+        defined_class_name = defined_class.is_a?(String) ? defined_class : defined_class.name
+        declarations[defined_class_name] ||= []
+        declarations[defined_class_name] << [ file, line ]
+      }
+      silence_warnings { load source_file }
+      declarations
+    end
+
+    def dynamic_class_declared(id, classname, file, line)
+      return unless id == :new && classname == Class 
+      File.read(file).lines.to_a[line-1][/[A-Z][\w_:]*/, 0]
+    end
+
+    def standard_class_declared(event, binding)
+      return unless event == 'class'
+      event_class = eval( "Module.nesting", binding )
+      event_class.first
+    end
+
+    def silence_warnings
+      old_verbose, $VERBOSE = $VERBOSE, nil
+      yield
+    ensure
+      $VERBOSE = old_verbose
+    end
+  end
+end

data/lib/class_source/method_index.rb

@@ -0,0 +1,72 @@
+module ClassSource
+  class MethodIndex
+    def initialize(target_class)
+      @target_class = target_class
+    end
+
+    def locations
+      @locations ||= (unique.map do |m|
+        @target_class.instance_method(m).source_location
+      end + klass.unique.map do |m|
+        @target_class.method(m).source_location
+      end).compact
+    end
+
+    def unique
+      uniquely_named_methods = all(:include_inherited_methods => false)
+      overridden_methods = (all - uniquely_named_methods).select do |m|
+        @target_class.instance_method(m).source_location != @target_class.superclass.instance_method(m).source_location
+      end
+      overridden_methods + uniquely_named_methods
+    end
+
+
+    def all(options={})
+      include_inherited_methods = options.has_key?(:include_inherited_methods) ? options[:include_inherited_methods] : true
+      target = options[:target] || @target_class
+      target.public_instance_methods(include_inherited_methods) +
+        target.private_instance_methods(include_inherited_methods) +
+        target.protected_instance_methods(include_inherited_methods)
+    end
+
+    def klass
+      ClassMethodIndex.new(@target_class)
+    end
+
+    class ClassMethodIndex
+      def initialize(target_class)
+        @target_class = target_class
+      end
+
+      def unique
+        uniquely_named + overridden - extended
+      end
+
+      def extended 
+        @target_class.singleton_class.ancestors.map do |mod|
+          mod.instance_methods.select { |m| mod.instance_method(m).source_location == @target_class.method(m).source_location }
+        end.flatten
+      end
+
+      def uniquely_named
+        @target_class.singleton_methods(false)
+      end
+
+      def overridden
+        (@target_class.methods - uniquely_named).select do |m|
+          !ancestral_sources(m).include?(@target_class.method(m).source_location)
+        end
+      end
+
+      def ancestral_sources(method)
+        superclasses.map { |mod| mod.respond_to?(method) && mod.method(method).source_location }.compact
+      end
+
+      def superclasses
+        @target_class.ancestors - [@target_class]
+      end
+
+    end
+
+  end
+end

data/lib/class_source/version.rb

@@ -0,0 +1,3 @@
+module ClassSource
+  VERSION="0.0.0"
+end

data/lib/class_source.rb

@@ -0,0 +1,13 @@
+require 'class_source/declarations'
+require 'class_source/index'
+require 'class_source/method_index'
+require 'class_source/locator'
+require 'class_source/guesser'
+require 'class_source/collator'
+
+module ClassSource
+  def __source__(options={})
+    Index.new(self, options)
+  end
+end
+

data/spec/class_source_spec.rb

@@ -0,0 +1,223 @@
+require 'spec_helper'
+
+describe ClassSource do
+  after { test_unload_all }
+
+  describe "for a simple class with only an initializer" do
+    before do
+      test_load 'SimpleClass'
+    end
+    it "knows the unique methods of the class" do
+      SimpleClass.__source__.methods.unique.should == [:initialize]
+    end
+
+    it "knows the method location for each of the unique methods of the class" do
+      SimpleClass.__source__.methods.locations.should == [[fixtures_path(:simple_class), 4]]
+    end
+
+    it "can pinpoint the opening of a simple class" do
+      SimpleClass.__source__.locations.should == [[fixtures_path(:simple_class), 3]]
+    end
+
+    it "can return the full source of a simple class" do
+      SimpleClass.__source__.should == File.read(fixtures_path(:simple_class)).lines.to_a[2..-1].join("")
+    end
+  end
+
+  describe "for a class with public, private and protected methods" do
+    before { test_load 'ProtectedMethodClass' }
+
+    it "knows the unique methods of the class" do
+      ProtectedMethodClass.__source__.methods.unique.should =~ [:initialize, :talk, :think, :whisper]
+    end
+
+    it "knows the method location for each of the unique methods of the class" do
+      ProtectedMethodClass.__source__.methods.locations.should =~ [
+        [fixtures_path(:protected_method_class), 2],
+        [fixtures_path(:protected_method_class), 6],
+        [fixtures_path(:protected_method_class), 11],
+        [fixtures_path(:protected_method_class), 16]
+      ]
+    end
+
+    it "can pinpoint the opening" do
+      ProtectedMethodClass.__source__.locations.should == [[fixtures_path(:protected_method_class), 1]]
+    end
+
+    it "can return the full source" do
+      ProtectedMethodClass.__source__.should == File.read(fixtures_path(:protected_method_class)).lines.to_a[0..-1].join("")
+    end
+  end
+
+  describe "for a subclass of a user class" do
+    before { test_load 'ProtectedMethodClass', 'SubClass' }
+
+    it "knows the unique methods of the class" do
+      SubClass.__source__.methods.unique.should =~ [:talk, :think]
+    end
+
+    it "knows the method location for each of the unique methods of the class" do
+      SubClass.__source__.methods.locations.should =~ [
+        [fixtures_path(:sub_class), 2],
+        [fixtures_path(:sub_class), 6]
+      ]
+    end
+
+    it "can pinpoint the opening" do
+      SubClass.__source__.locations.should == [[fixtures_path(:sub_class), 1]]
+    end
+
+    it "can return the full source" do
+      SubClass.__source__.should == File.read(fixtures_path(:sub_class)).lines.to_a[0..-1].join("")
+    end
+  end
+
+  describe "for a nested class" do
+    before { test_load 'OuterClass' }
+    it "can return the full source" do
+      OuterClass::NestedClass.__source__.should == File.read(fixtures_path(:outer_class)).lines.to_a[12..16].join("")
+    end
+  end
+
+  describe "for a class with no unique methods" do
+    before { test_load 'NoMethodsClass' }
+    it "can return the full source if you pass a source file" do
+      NoMethodsClass.__source__(:file => fixtures_path(:no_methods_class)).should == File.read(fixtures_path(:no_methods_class)).lines.to_a[0..4].join("")
+    end
+    describe "for a nested class with no unique methods" do
+      it "can return the full source" do
+        NoMethodsClass::NestedClass.__source__(:file => fixtures_path(:no_methods_class)).should == File.read(fixtures_path(:no_methods_class)).lines.to_a[1..3].join("")
+      end
+    end
+  end
+
+  describe "for an outer class" do
+    before { test_load 'OuterClass' }
+    it "can return the full source" do
+      OuterClass.__source__.should == File.read(fixtures_path(:outer_class)).lines.to_a[0..-1].join("")
+    end
+
+    it "can also return the source minus any nested classes" do
+      source_lines = File.read(fixtures_path(:outer_class)).lines.to_a
+      non_nested_lines = (source_lines[0..3] + source_lines[8..11] + source_lines[17..-1]).join("")
+      OuterClass.__source__.to_s(:include_nested => false).should == non_nested_lines
+    end
+  end
+
+  describe "for dynamically defined classes" do
+    before do
+      test_load 'DynamicClass'
+    end
+
+    it "should have a single source location" do
+      DynamicClass.__source__.should have(1).locations
+    end
+
+    it "can return the full source" do
+      DynamicClass.__source__.should == File.read(fixtures_path(:dynamic_class)).lines.to_a[0..4].join("")
+    end
+
+    it "can return the source for a class named later in the file" do
+      LateNamedDynamicClass.send :extend, ClassSource
+      LateNamedDynamicClass.__source__.should == File.read(fixtures_path(:dynamic_class)).lines.to_a[11]
+    end
+
+    describe "with no methods" do
+      it "knows the source" do
+        MethodlessDynamicClass.send :extend, ClassSource
+        MethodlessDynamicClass.__source__.should == "MethodlessDynamicClass = Class.new\n"
+      end
+    end
+  end
+
+  describe "for duplicated classes" do
+    before { test_load 'DuplicatedClass' }
+    it "should point to the duplication point" do
+      DuplicateClass.__source__.locations.should == [
+        [fixtures_path(:duplicated_class), 5]
+      ]
+    end
+  end
+
+  describe "for cloned classes" do
+    before { test_load 'ClonedClass' }
+    it "should point to the cloning point" do
+      CloneClass.__source__.locations.should == [
+        [fixtures_path(:cloned_class), 5]
+      ]
+    end
+  end
+
+  describe "for classes defined within eval" do 
+    before { test_load 'EvalClass' }
+    it "should point to the evaluation point" do
+      EvalClass.__source__.locations.should == [
+        [fixtures_path(:eval_class), 11]
+      ]
+    end
+  end 
+
+  describe "for classes that are reopened in separate files" do
+    before { test_load 'ReOpenedClass' }
+    it "should have more than one source file" do
+      ReOpenedClass.__source__.files.length.should == 2
+    end
+
+    it "should have more than one source location" do
+      ReOpenedClass.__source__.locations.length.should == 2
+    end
+
+    it "should have the full source in its source" do
+      ReOpenedClass.__source__.all.should == {
+        [fixtures_path(:re_opened_class), 3] => File.read(fixtures_path(:re_opened_class)).lines.to_a[2..-1].join(""), 
+        [fixtures_path(:re_opened_class_2), 1] => File.read(fixtures_path(:re_opened_class_2))
+      }
+    end
+
+    it "should be able to display without nested classes if needed" do
+      reopened_source = File.read(fixtures_path(:re_opened_class)).lines.to_a
+      reopened_source_2 = File.read(fixtures_path(:re_opened_class_2)).lines.to_a
+      ReOpenedClass.__source__.all(:include_nested => false).should == {
+        [fixtures_path(:re_opened_class), 3] => (reopened_source[2..6] + reopened_source[15..-1]).join(""),
+        [fixtures_path(:re_opened_class_2), 1] => (reopened_source_2[0..4] + reopened_source_2[10..-1]).join("")
+      }
+    end
+  end
+
+  describe "for a nested class that is reopened within the parent" do 
+    before { test_load 'ReOpenedClass' }
+    it "should have more than one source location" do
+      ReOpenedClass::NestedClass.__source__.all.should == {
+        [fixtures_path(:re_opened_class), 8] => File.read(fixtures_path(:re_opened_class)).lines.to_a[7..10].join(""), 
+        [fixtures_path(:re_opened_class), 12] => File.read(fixtures_path(:re_opened_class)).lines.to_a[11..14].join("") 
+      }
+    end
+  end
+
+  describe "for class with only class methods" do
+    before do
+      test_load 'ClassMethodsClass'
+    end
+    it "knows the unique class methods of the class" do
+      ClassMethodsClass.__source__.class_methods.unique.should == [:simple_method]
+    end
+    it "can find the source" do
+      ClassMethodsClass.__source__.should == File.read(fixtures_path(:class_methods_class)).lines.to_a[0..-1].join("")
+    end
+  end
+
+  describe "it doesn't cause side effects for class-scoped code" do
+    before do
+      test_load 'SideEffectClass'
+    end
+
+    it "should retain the same values as set" do
+      SideEffectClass.should be_active
+      SideEffectClass.deactivate!
+      SideEffectClass.should_not be_active
+      SideEffectClass.__source__.should == File.read(fixtures_path(:side_effect_class)).lines.to_a[0..-1].join("")
+      SideEffectClass.should_not be_active
+    end
+  end
+
+end

data/spec/fixtures/class_methods_class.rb

@@ -0,0 +1,5 @@
+class ClassMethodsClass
+  def self.simple_method
+
+  end
+end

data/spec/fixtures/cloned_class.rb

@@ -0,0 +1,5 @@
+class ClonedClass
+  def simple_method
+  end
+end
+CloneClass = ClonedClass.clone

data/spec/fixtures/duplicated_class.rb

@@ -0,0 +1,5 @@
+class DuplicatedClass
+  def simple_method
+  end
+end
+DuplicateClass = DuplicatedClass.dup

data/spec/fixtures/dynamic_class.rb

@@ -0,0 +1,14 @@
+DynamicClass = Class.new do
+  def example_method
+
+  end
+end
+
+class_to_be_named_later = Class.new do
+  def example_method
+  end
+end
+
+LateNamedDynamicClass = class_to_be_named_later
+MethodlessDynamicClass = Class.new
+

data/spec/fixtures/eval_class.rb

@@ -0,0 +1,11 @@
+method_name = "simple_method"
+class_name = "EvalClass"
+
+code = <<-CODE 
+  class #{class_name}
+    def #{method_name}
+    end
+  end
+CODE
+
+eval code, binding, __FILE__, __LINE__ 

data/spec/fixtures/example_code.rb

@@ -0,0 +1,10 @@
+class Car
+  def initialize
+    @wheels = 3
+  end
+
+  def go
+    puts "Vroom vroom"
+    true
+  end
+end

data/spec/fixtures/nested_example.rb

@@ -0,0 +1,5 @@
+class ParentClass
+  class ChildClass
+
+  end
+end

data/spec/fixtures/no_methods_class.rb

@@ -0,0 +1,5 @@
+class NoMethodsClass
+  class NestedClass
+
+  end
+end

data/spec/fixtures/outer_class.rb

@@ -0,0 +1,22 @@
+class OuterClass
+  def simple_method_1
+  end
+
+  class OtherNestedClass
+    def example_method
+    end
+  end
+
+  def simple_method_2
+  end
+
+  class NestedClass
+    def example_method
+      puts "example"
+    end
+  end
+
+  def simple_method_3
+  end
+
+end

data/spec/fixtures/protected_method_class.rb

@@ -0,0 +1,19 @@
+class ProtectedMethodClass
+  def initialize(foo)
+
+  end
+
+  def talk(blab)
+    sku.foo = doo
+  end
+
+protected
+  def whisper(mutter)
+    foo.doo = sku
+  end
+
+private
+  def think(mentate)
+    doo.sku = foo
+  end
+end

data/spec/fixtures/re_opened_class.rb

@@ -0,0 +1,16 @@
+load fixtures_path(:re_opened_class_2)
+
+class ReOpenedClass
+  def method1
+    
+  end
+
+  class NestedClass
+    def simple_method
+    end
+  end
+  class NestedClass
+    def simple_method_2
+    end
+  end
+end

data/spec/fixtures/re_opened_class_2.rb

@@ -0,0 +1,11 @@
+class ReOpenedClass
+  def method2
+
+  end
+
+  class NestedClass2
+    def simple_method
+    end
+
+  end
+end

data/spec/fixtures/side_effect_class.rb

@@ -0,0 +1,11 @@
+class SideEffectClass
+  @@active = true
+
+  def self.deactivate!
+    @@active = false
+  end
+
+  def self.active?
+    @@active
+  end
+end

data/spec/fixtures/simple_class.rb

@@ -0,0 +1,6 @@
+
+
+class SimpleClass
+  def initialize
+  end
+end

data/spec/fixtures/sub_class.rb

@@ -0,0 +1,10 @@
+class SubClass < ProtectedMethodClass
+  def talk
+    "hallo"
+  end
+
+  def think
+    "howzit"
+  end
+
+end

data/spec/fixtures/unnested_child.rb

@@ -0,0 +1,3 @@
+class ChildClass
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+require 'rubygems'
+SOURCE_PATH=File.expand_path(File.dirname(__FILE__), '../lib')
+$LOAD_PATH << SOURCE_PATH
+require 'class_source'
+
+RSpec.configure do
+  def spec_path
+    @path ||= File.expand_path(File.dirname(__FILE__))
+  end
+
+  def fixtures_path(file_name)
+    "#{SOURCE_PATH}/fixtures/#{file_name}.rb"
+  end
+
+  def test_load(*args)
+    name = args.shift
+    file_name = name.to_s.gsub(/([A-Z])/) { |match| "_" + match.downcase }.slice(1..-1)
+    raise "can't find #{fixtures_path(file_name)}" unless File.exist?(fixtures_path(file_name))
+
+    @loaded_fixtures ||= []
+    @loaded_fixtures << name
+    existing_classes = Object.constants
+    load fixtures_path(file_name)
+    new_classes = Object.constants - existing_classes - [name.to_sym]
+    @loaded_fixtures += new_classes.map &:to_s
+    allow_source_inspection(name)
+
+    test_load(*args) unless args.empty?
+    new_classes.each { |new_name| allow_source_inspection(new_name) }
+  end
+
+  def allow_source_inspection(name, nesting = Object)
+    klass = nesting.const_get(name.to_sym)
+
+    klass.send :extend, ClassSource
+    klass.constants.select { |kc| klass.const_get(kc).is_a?(Class) }.each do |nested_class|
+      allow_source_inspection nested_class, klass
+    end
+  end
+
+  def test_unload_all
+    @loaded_fixtures.each do |klass_name|
+      Object.send :remove_const, klass_name if Object.const_defined?(klass_name)
+    end
+  end
+
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: class_source
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Austin Putman, austingfromboston
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-21 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2152549200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2152549200
+- !ruby/object:Gem::Dependency
+  name: ruby_parser
+  requirement: &2152548780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2152548780
+description: Expose source files and full source code for each class via a simple
+  API
+email:
+- austin@rawfingertips.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/class_source/collator.rb
+- lib/class_source/declarations.rb
+- lib/class_source/guesser.rb
+- lib/class_source/index.rb
+- lib/class_source/locator.rb
+- lib/class_source/method_index.rb
+- lib/class_source/version.rb
+- lib/class_source.rb
+- spec/class_source_spec.rb
+- spec/fixtures/class_methods_class.rb
+- spec/fixtures/cloned_class.rb
+- spec/fixtures/duplicated_class.rb
+- spec/fixtures/dynamic_class.rb
+- spec/fixtures/eval_class.rb
+- spec/fixtures/example_code.rb
+- spec/fixtures/nested_example.rb
+- spec/fixtures/no_methods_class.rb
+- spec/fixtures/outer_class.rb
+- spec/fixtures/protected_method_class.rb
+- spec/fixtures/re_opened_class.rb
+- spec/fixtures/re_opened_class_2.rb
+- spec/fixtures/side_effect_class.rb
+- spec/fixtures/simple_class.rb
+- spec/fixtures/sub_class.rb
+- spec/fixtures/unnested_child.rb
+- spec/spec_helper.rb
+homepage: http://github.com/austinfromboston/class_source
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: class_source
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: See where your classes are defined
+test_files:
+- spec/class_source_spec.rb
+- spec/fixtures/class_methods_class.rb
+- spec/fixtures/cloned_class.rb
+- spec/fixtures/duplicated_class.rb
+- spec/fixtures/dynamic_class.rb
+- spec/fixtures/eval_class.rb
+- spec/fixtures/example_code.rb
+- spec/fixtures/nested_example.rb
+- spec/fixtures/no_methods_class.rb
+- spec/fixtures/outer_class.rb
+- spec/fixtures/protected_method_class.rb
+- spec/fixtures/re_opened_class.rb
+- spec/fixtures/re_opened_class_2.rb
+- spec/fixtures/side_effect_class.rb
+- spec/fixtures/simple_class.rb
+- spec/fixtures/sub_class.rb
+- spec/fixtures/unnested_child.rb
+- spec/spec_helper.rb