exegesis 0.0.2

data/spec/integration/flyweight_registerable_spec.rb

@@ -0,0 +1,78 @@
+require 'integration_spec_helper'
+
+describe Flyweight, "mixin", "other objects" do
+  before do
+    class Example
+      include Registerable
+      def initialize(parent, name, *args)
+        @parent = parent
+        @name = name
+        @args = args
+      end
+
+      attr_reader :parent, :name
+
+      def self.build_path(parent, child)
+        [parent.path, child].join('/')
+      end
+    end
+
+    class ParentObject
+      def path
+        "the_parent_path"
+      end
+    end
+  end
+
+  let(:parent) { ParentObject.new }
+
+  after do
+    Object.send(:remove_const, :Example)
+    Object.send(:remove_const, :ParentObject)
+  end
+
+  describe 'api' do
+    context 'class' do
+      subject { Example }
+      it { should respond_to :create }
+
+      context 'required' do
+        it { should respond_to :build_path }
+      end
+    end
+
+    context 'instance' do
+      subject { Example.send(:new, parent, 'n') } # to test instance API
+      it { should respond_to :path }
+    end
+  end
+
+  describe 'instantiation' do
+    it 'disallows instantiation via #new' do
+      expect { Example.new(parent, 'n') }.to raise_error NoMethodError
+    end
+  end
+
+  describe 'creating a new instance' do
+    subject { Example.create(parent, 'n') }
+  end
+
+  describe 'creating an instance that is already registered' do
+    let!(:existing_entry) { Example.create(parent, 'n') }
+    subject               { Example.create(parent, 'n') }
+
+    it { should be existing_entry }
+  end
+
+  describe 'deleting an instance' do
+  end
+
+  describe 'retrieving an already created instance' do
+    context 'via #create' do
+    end
+
+    #find semantics, something like ['/foo/bar']
+    context 'via #[]' do
+    end
+  end
+end

data/spec/integration/visitor_spec.rb

@@ -0,0 +1,86 @@
+require 'integration_spec_helper'
+
+describe '#visit' do
+  let (:dir) { BaseDirectory.create('./spec/fake_project') }
+
+  context 'visitor with a proc' do
+    subject { proc { } }
+
+    before do
+      subject.stub(:call)
+
+      dir.visit(subject)
+    end
+
+
+    it { should have_received(:call).with(dir.class, dir) }
+    it { should_not have_received(:on_enter) }
+    it { should_not have_received(:on_exit) }
+  end
+
+  context 'visitor with a class' do
+    let (:visitor) { double('visitor instance') }
+    subject { visitor }
+
+    before do
+      visitor.stub(:call)
+    end
+
+    describe 'a visitor class with no hooks defined' do
+      before do
+        visitor.stub(:respond_to?).with(:on_enter).and_return(false)
+        visitor.stub(:respond_to?).with(:on_exit).and_return(false)
+
+        dir.visit(visitor)
+      end
+
+      it { should have_received(:call).with(dir.class, dir) }
+      it { should_not have_received(:on_enter) }
+      it { should_not have_received(:on_exit) }
+    end
+
+    describe 'a visitor class with the #on_enter hook defined' do
+      before do
+        visitor.stub(:respond_to?).with(:on_enter).and_return(true)
+        visitor.stub(:respond_to?).with(:on_exit).and_return(false)
+        visitor.stub(:on_enter)
+
+        dir.visit(visitor)
+      end
+
+      it { should have_received(:call).with(dir.class, dir) }
+      it { should have_received(:on_enter) }
+      it { should_not have_received(:on_exit) }
+    end
+
+    describe 'a visitor class with the #on_exit hook defined' do
+      before do
+        visitor.stub(:respond_to?).with(:on_enter).and_return(false)
+        visitor.stub(:respond_to?).with(:on_exit).and_return(true)
+        visitor.stub(:on_exit)
+
+        dir.visit(visitor)
+      end
+
+
+      it { should have_received(:call).with(dir.class, dir) }
+      it { should_not have_received(:on_enter) }
+      it { should have_received(:on_exit) }
+    end
+
+    describe 'a visitor class with the both hooks defined' do
+      before do
+        visitor.stub(:respond_to?).with(:on_enter).and_return(true)
+        visitor.stub(:respond_to?).with(:on_exit).and_return(true)
+        visitor.stub(:on_enter)
+        visitor.stub(:on_exit)
+
+        dir.visit(visitor)
+      end
+
+      it { should have_received(:call).with(dir.class, dir) }
+      it { should have_received(:on_enter) }
+      it { should have_received(:on_exit) }
+    end
+  end
+end

data/spec/integration_spec_helper.rb

@@ -0,0 +1 @@
+require 'spec_helper'

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+require 'bundler/setup'
+
+require 'pry'
+
+require 'exegesis'
+
+require 'bahia'
+
+require 'rspec-spies'
+
+#include helpers
+Dir["./spec/helpers/*.rb"].each { |file| require file }
+
+RSpec.configure do |config|
+  config.before do
+    allow_message_expectations_on_nil
+  end
+
+  config.after do
+    SourceFile.clear_registry!
+    Directory.clear_registry!
+  end
+
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+
+  config.include(Bahia)
+
+  config.extend(RSpec::Exegesis::DSL::Macros)
+  config.include(RSpec::Exegesis::DSL::Matchers)
+end
+
+class RSpec::Mocks::Mock
+  def inspect
+    "double(#{@name.inspect})"
+  end
+end

data/spec/unit/base_directory_spec.rb

@@ -0,0 +1,44 @@
+require 'unit_spec_helper'
+
+describe BaseDirectory do
+  let (:root)     { double('some path to a project directory').as_null_object }
+  let (:searcher) { double('directory searcher like FileSearcher') }
+  let (:dir)      { double('fake directory') }
+  let (:file)     { double('fake file') }
+
+  let (:project) { BaseDirectory.create(root, searcher) }
+
+
+  before do
+    searcher.stub(:[]).with(root + '*').and_return([dir, file])
+    searcher.stub(:new).and_return(searcher)
+    searcher.stub(:search).and_return(searcher)
+  end
+
+  context do
+    subject { project }
+
+    describe 'api' do
+      it { should be_a Directory }
+      it { should respond_to :root }
+      it { should respond_to :directories }
+      it { should respond_to :files }
+    end
+
+    describe '#root' do
+      subject { project.root }
+      it { should == root }
+    end
+
+    it { should delegate(:files).to(searcher) }
+    it { should delegate(:directories).to(searcher) }
+
+    #it should also provide interface for
+    #  * creating files/directories
+    #    - something like `directories << Directory('foo')` ?
+    #
+    #  *
+    #
+    #it should also have a #visit method, see the NOTES doc for details on that
+  end
+end

data/spec/unit/directory_spec.rb

@@ -0,0 +1,44 @@
+require 'unit_spec_helper'
+
+describe Directory do
+  let (:parent)      { double('parent directory')               }
+  let (:parent_path) { 'parent/'                                }
+  let (:name)        { 'subdir/'                                }
+  let (:searcher)    { double('searcher')                       }
+  let (:directory)   { Directory.create(parent, name, searcher) }
+
+  before do
+    parent.stub(:is_a?).with(Directory).and_return(true)
+    parent.stub(:path).and_return(parent_path)
+
+    searcher.stub(:new).and_return(searcher)
+  end
+
+  subject { directory }
+
+  describe 'instantiation' do
+    it 'disallows instantiation via #new' do
+      expect { Directory.new(parent, name, searcher) }.to raise_error NoMethodError
+    end
+  end
+
+  describe 'api' do
+    it { should respond_to :directories }
+    it { should respond_to :parent      }
+    it { should respond_to :files       }
+    it { should respond_to :path        }
+    it { should respond_to :children    }
+
+    its(:class) { should respond_to :create }
+  end
+
+  it { should delegate(:files).to(searcher) }
+  it { should delegate(:directories).to(searcher) }
+
+  describe '#path' do
+    subject { directory.path }
+
+    it { should be_a String }
+    it { should == File.join(parent_path, name) }
+  end
+end

data/spec/unit/file_searcher_spec.rb

@@ -0,0 +1,82 @@
+require 'unit_spec_helper'
+
+describe FileSearcher do
+  let (:root)          { double('a fake backend')                  }
+  let (:root_path)     { double('a fake path')                     }
+  let (:globbed_path)  { double('a fake glob of root_path with *') }
+  let (:file_searcher) { FileSearcher.new(root)                    }
+  let (:dir)           { double('a fake directory')                }
+  let (:file)          { double('a fake file')                     }
+  let (:file_path)     { double('the fake file path')              }
+  let (:dir_path)      { double('the directory file path')         }
+
+  let (:fake_source_file_instance) { double('a fake SourceFile instance') }
+  let (:fake_directory_instance)   { double('a fake Directory instance')  }
+
+  before do
+    File.stub(:directory?).with(dir).and_return(true)
+    File.stub(:file?).with(dir).and_return(false)
+    File.stub(:basename).with(dir).and_return(dir)
+
+    File.stub(:directory?).with(file).and_return(false)
+    File.stub(:file?).with(file).and_return(true)
+    File.stub(:basename).with(file).and_return(file)
+
+    File.stub(:join).with(root_path, '*').and_return(globbed_path)
+    File.stub(:join).with(root_path, file).and_return(file_path)
+    File.stub(:join).with(root_path, dir).and_return(dir_path)
+
+    Directory.stub(:new).with(root, dir).and_return(fake_directory_instance)
+    SourceFile.stub(:new).with(root, file).and_return(fake_source_file_instance)
+
+    fake_source_file_instance.stub(:is_a?).with(SourceFile).and_return(true)
+    fake_directory_instance.stub(:is_a?).with(Directory).and_return(true)
+
+    root.stub(:path).and_return(root_path)
+  end
+
+  subject { file_searcher }
+
+  describe 'api' do
+    it { should respond_to :directories }
+    it { should respond_to :files }
+    it { should respond_to :content }
+  end
+
+  describe '#content' do
+    before do
+      Dir.stub(:[])
+      file_searcher.content
+    end
+
+    the(Dir) { should have_received(:[]).with(globbed_path) }
+  end
+
+  context do
+    before do
+      file_searcher.stub(:content).and_return([dir, file])
+    end
+
+    describe '#directories' do
+      let! (:directories) { file_searcher.directories }
+      subject { directories }
+
+      it { should contain(fake_directory_instance)   }
+      it { should exclude(fake_source_file_instance) }
+
+      the_class(Directory) { should have_received(:new).with(root, dir) }
+      the_class(SourceFile) { should_not have_received(:new) }
+    end
+
+    describe '#files' do
+      let! (:files) { file_searcher.files }
+      subject { files }
+
+      it { should contain(fake_source_file_instance) }
+      it { should exclude(fake_directory_instance)   }
+
+      the_class(Directory) { should_not have_received(:new) }
+      the_class(SourceFile) { should have_received(:new).with(root, file) }
+    end
+  end
+end

data/spec/unit/flyweight_spec.rb

@@ -0,0 +1,137 @@
+require 'unit_spec_helper'
+
+describe Flyweight do
+  let (:processor)          { proc { instance_key }     }
+  let (:flyweight)          { Flyweight.new(&processor) }
+  let (:instance)           { double('instance')        }
+  let (:instance_key)       { double('instance_key')    }
+
+  subject { flyweight }
+
+  before do
+    processor.stub(:call).and_return(instance_key)
+  end
+
+  context 'shared examples' do
+    shared_examples_for 'flyweight unregistration' do
+      before { flyweight.unregister!(key) }
+
+      it { should_not have_key instance_key }
+      it { should_not have_key instance }
+
+      describe 'unregistering an unused key' do
+        it 'raises an error' do
+          expect { flyweight.unregister!(key) }.to raise_error Flyweight::NoEntryError
+        end
+
+        describe '#unregister' do
+          it 'raises an error' do
+            expect { flyweight.unregister(key) }.to_not raise_error Flyweight::NoEntryError
+          end
+        end
+      end
+    end
+  end
+
+  describe 'api' do
+    it { should respond_to :register! }
+    it { should respond_to :unregister! }
+    it { should respond_to :[] }
+
+    it { should respond_to :has_key? }
+
+    it { should respond_to :clear! }
+    it { should respond_to :reset! }
+  end
+
+  describe 'implementation' do
+    before { flyweight.register!(instance) }
+
+    describe '#register! and #register' do
+      the(:processor) { should have_received(:call).with(instance) }
+
+      describe 'registering an instance with an already-used key' do
+        it 'raises an error' do
+          expect { flyweight.register!(instance) }.to raise_error Flyweight::AlreadyRegisteredError
+        end
+
+        describe '#register' do
+          it 'does not raise an error' do
+            expect { flyweight.register(instance) }.to_not raise_error Flyweight::AlreadyRegisteredError
+          end
+        end
+      end
+    end
+
+    describe '#has_key?' do
+      subject { flyweight }
+
+      context 'when it has an entry for the given value' do
+        before { flyweight.register(instance) }
+
+        context 'by key' do
+          it { should have_key instance_key }
+        end
+
+        context 'by instance' do
+          it { should have_key instance }
+        end
+      end
+
+      context 'when it has no entry for the given value' do
+        before { flyweight.clear! }
+
+        context 'by key' do
+          it { should_not have_key instance_key }
+        end
+
+        context 'by instance' do
+          it { should_not have_key instance }
+        end
+      end
+    end
+
+    describe '#[]' do
+      context 'by instance' do
+        subject { flyweight[instance] }
+
+        it { should be instance }
+      end
+
+      context 'by key' do
+        subject { flyweight[instance_key] }
+
+        it { should be instance }
+      end
+
+      describe 'when flyweight does not have an entry for the value' do
+        before { flyweight.clear! }
+
+        context 'by instance' do
+          subject { flyweight[instance] }
+
+          it { should be_nil }
+        end
+
+        context 'by key' do
+          subject { flyweight[instance_key] }
+
+          it { should be_nil }
+        end
+
+      end
+    end
+
+    describe '#unregister!' do
+      context 'by key' do
+        let (:key) { instance_key }
+        it_behaves_like 'flyweight unregistration'
+      end
+
+      context 'by instance' do
+        let (:key) { instance }
+        it_behaves_like 'flyweight unregistration'
+      end
+    end
+  end
+end

data/spec/unit/helpers_spec.rb

@@ -0,0 +1,3 @@
+require 'unit_spec_helper'
+
+#intentionally blank

data/spec/unit/source_file_spec.rb

@@ -0,0 +1,127 @@
+require 'unit_spec_helper'
+
+describe SourceFile do
+  let(:basename)  { 'fake'               }
+  let(:extension) { '.c'                 }
+  let(:name)      { basename + extension }
+  let(:parent)    { double('directory')  }
+
+  let(:full_path) { File.join(parent.path, name) }
+  let(:content)   { double('content')            }
+
+  let(:source_file) { SourceFile.create(parent, name) }
+
+  subject { source_file }
+
+  before do
+    parent.stub(:path).and_return('/path/to/parent/')
+    parent.stub(:is_a?).with(Directory).and_return(true)
+    File.stub(:read).with(full_path).and_return(content)
+  end
+
+  describe 'instantiation' do
+    it 'disallows instantiation via #new' do
+      expect { SourceFile.new(parent, name) }.to raise_error NoMethodError
+    end
+  end
+
+  describe 'api' do
+    context 'basic interface' do
+      it { should respond_to :extension }
+      it { should respond_to :ext       }
+
+      it { should respond_to :basename }
+      it { should respond_to :name     }
+
+      it { should respond_to :path      }
+      it { should respond_to :content   }
+
+      it { should respond_to :parent    }
+      it { should respond_to :container }
+    end
+
+    context 'dependencies' do
+      it { should respond_to :dependencies }
+      it { should respond_to :depends_on }
+    end
+
+    pending 'language identification' do
+      it { should respond_to :language }
+      it { should respond_to :language? }
+    end
+  end
+
+  describe '#path' do
+    subject { source_file.path }
+
+    it { should == full_path }
+  end
+
+  describe '#extension' do
+    subject { source_file.extension }
+
+    it { should == subject.ext }
+    it { should == extension }
+  end
+
+  describe '#basename' do
+    subject { source_file.basename }
+
+    it { should == basename }
+  end
+
+  describe '#name' do
+    subject { source_file.name }
+
+    it { should == name }
+    it { should == source_file.basename + source_file.ext }
+  end
+
+  describe '#parent' do
+    subject { source_file.parent }
+
+    pending 'reimplementation' do
+      it 'raises an error if you try to give a parent that is not a Directory' do
+        expect { SourceFile.create(:not_a_dir, name) }.to raise_error ArgumentError
+      end
+    end
+    it { should == source_file.container }
+  end
+
+  describe '#content' do
+    before { source_file.content }
+
+    the_class(File) { should have_received(:read).with(full_path) }
+  end
+
+  describe '#dependencies' do
+    let(:file) { double('another sourcefile') }
+    let(:not_a_file) { double('not a sourcefile') }
+
+    before { file.stub(:is_a?).with(SourceFile).and_return(:true) }
+
+    subject { source_file.dependencies }
+
+    it { should respond_to :each }
+    it { should be_empty }
+
+    describe '#depends_on' do
+      before { source_file.depends_on(file) }
+
+      it { should =~ [file] }
+
+      it 'raises unless the dependency is a file' do
+        expect {
+          source_file.depends_on(not_a_file)
+        }.to raise_error InvalidDependency
+      end
+    end
+  end
+
+  #this should be a shared pattern between directories, sourcefiles, etc.
+  describe 'flyweight nature' do
+    #it should not create two identical instances
+  end
+
+  #deleting a file should delete it's instance from the flyweight
+end

data/spec/unit_spec_helper.rb

@@ -0,0 +1 @@
+require 'spec_helper'