pants 0.1.0

data/pants.gemspec

@@ -0,0 +1,31 @@
+$:.push File.expand_path("../lib", __FILE__)
+require 'pants/version'
+
+
+Gem::Specification.new do |s| 
+  s.name =          "pants"
+  s.version =       Pants::VERSION
+  s.author =        %q(Steve Loveless)
+  s.homepage =      %q(http://github.com/turboladen/pants)
+  s.email =         %q(steve.loveless@gmail.com)
+  s.summary =       %q(Easy, fast, I/O multiplexer)
+  s.description =   %q[Pants redirects IO using EventMachine from one input source
+to many different destinations. In some senses, pants is like a *nix pipe that
+(works on Windows and) allows for duplicating data across many pipes (like
+splice and tee).]
+
+  s.required_rubygems_version = ">=1.8.0"
+  s.files =         `git ls-files`.split($/)
+  s.test_files =    s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = %w(lib)
+  s.executables =   %w(pants)
+
+  s.add_dependency "eventmachine", ">= 1.0.0"
+  s.add_dependency "log_switch", ">= 0.4.0"
+  s.add_dependency "thor"
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", ">= 2.6.0"
+  s.add_development_dependency "simplecov", ">= 0"
+  s.add_development_dependency "yard", ">= 0.7.2"
+end

data/spec/acceptance/file_reads_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'pants'
+
+
+describe "File reads" do
+  let(:original_file_path) do
+    File.expand_path(File.dirname(__FILE__) + "/../support/pants.wav")
+  end
+
+  let(:dest_file_path) { 'acceptance_test_dest_file' }
+
+  after do
+    FileUtils.rm(dest_file_path)
+  end
+
+  it "reads from a file and copies all data to all other writer types" do
+    Pants.read(original_file_path) do |reader|
+      reader.write_to(dest_file_path)
+      reader.write_to('udp://127.0.0.1:0')
+    end
+
+    original_file_path.should be_the_same_size_as dest_file_path
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'simplecov'
+
+SimpleCov.start
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |f| require f }
+
+require 'pants'
+Pants.log = true
+

data/spec/support/matchers/file_same_size_as.rb

@@ -0,0 +1,20 @@
+RSpec::Matchers.define :be_the_same_size_as do |expected|
+  match do |actual|
+    actual_size = File.stat(actual).size
+    expected_size = File.stat(expected).size
+    @difference = expected_size - actual_size
+    @difference == 0
+  end
+
+  failure_message_for_should do |actual|
+    "expected #{actual} to be the same size as #{expected}; diff: #{@difference}"
+  end
+
+  failure_message_for_should_not do |actual|
+    "expected #{actual} to not be the same size as #{expected}"
+  end
+
+  description do
+    "be the same size as #{expected}"
+  end
+end

data/spec/unit/pants/core_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require "pants/core"
+
+
+describe Pants::Core do
+  let(:callback) { double "EM.Callback" }
+
+  describe "#read" do
+    context "unknown URI scheme" do
+      it "raises an ArgumentError" do
+        expect {
+          subject.read("test://stuff")
+        }.to raise_error ArgumentError
+      end
+    end
+
+    context "known URI scheme" do
+      let(:test_reader) do
+        double "Pants::TestReader"
+      end
+
+      let(:readers) do
+        [{ uri_scheme: 'test', klass: test_reader }]
+      end
+
+      before do
+        Pants.stub(:readers).and_return readers
+      end
+
+      it "creates the new reader and adds it to @readers" do
+        uri = URI "test://somehost"
+
+        subject.should_receive(:new_reader_from_uri) do |arg1, arg2|
+          arg1.should == uri
+          arg2.should be_a EM.Callback
+        end.and_return(test_reader)
+
+        subject.read('test://somehost')
+      end
+    end
+  end
+
+  describe "#run" do
+    let(:reader) do
+      r = double "Pants::TestReader"
+      r.stub(:read_object)
+      r.stub_chain(:writers, :size)
+      r.stub_chain(:writers, :each_with_index)
+
+      r
+    end
+
+    let(:iterator) do
+      i = double "EventMachine::Iterator"
+      i.should_receive(:each).and_yield(reader, i)
+      i.stub(:next)
+
+      i
+    end
+
+    before do
+      EM.stub(:run).and_yield
+      EM::Iterator.stub(:new).and_return(iterator)
+    end
+
+    it "starts all of the readers" do
+      reader.should_receive(:start)
+      subject.instance_variable_set(:@readers, [reader])
+      subject.run
+    end
+  end
+
+  describe "#new_reader_from_uri" do
+    context "uri_scheme exists in readers" do
+      let(:test_reader) do
+        double "Pants::TestReader"
+      end
+
+      let(:readers) do
+        [{ uri_scheme: 'test', klass: test_reader, args: [:host] }]
+      end
+
+      before do
+        Pants.stub(:readers).and_return readers
+      end
+
+      it "creates a new Reader based on the scheme mapping" do
+        uri = URI "test://testhost"
+        test_reader.should_receive(:new).with("testhost", callback)
+
+        subject.send(:new_reader_from_uri, uri, callback)
+      end
+    end
+
+    context "uri_scheme does not exist in readers" do
+      it "raises" do
+        uri = URI "bobo://host:1234/path"
+
+        expect {
+          subject.send(:new_reader_from_uri, uri, callback)
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/unit/pants/readers/base_reader_spec.rb

@@ -0,0 +1,340 @@
+require 'spec_helper'
+require 'pants/readers/base_reader'
+
+
+describe Pants::Readers::BaseReader do
+  let(:test_writer) { double "Pants::Writers::TestWriter" }
+  let(:core_stopper_callback) { double "EM.Callback" }
+  subject { Pants::Readers::BaseReader.new(core_stopper_callback) }
+
+  describe "#initialize" do
+    it "creates a write_to_channel" do
+      reader = Pants::Readers::BaseReader.new(core_stopper_callback)
+      reader.write_to_channel.should be_a EM::Channel
+    end
+  end
+
+  describe "#start" do
+    around(:each) do |example|
+      EM.run do
+        example.run
+        EM.stop
+      end
+    end
+
+    let(:callback) { double "EventMachine.Callback" }
+
+    let(:em_iterator) do
+      EventMachine::Iterator.new([test_writer])
+    end
+
+    let(:tick_loop) do
+      t = double "EventMachine::TickLoop"
+      t.should_receive(:on_stop).and_yield
+
+      t
+    end
+
+    before do
+      subject.instance_variable_set(:@writers, [test_writer])
+    end
+
+    it "starts the writers first, then the readers" do
+      EventMachine.stub(:tick_loop).and_yield.and_return(tick_loop)
+      test_writer.stub(:running?).and_return(false, true)
+
+      em_iterator.should_receive(:each).and_yield(test_writer, em_iterator)
+      em_iterator.stub(:next)
+      EventMachine::Iterator.should_receive(:new).and_return(em_iterator)
+      test_writer.should_receive(:start)
+
+      callback.should_receive(:call)
+
+      subject.start(callback)
+    end
+  end
+
+  describe "#stop!" do
+    let(:stopper) do
+      s = double "EventMachine::Callback"
+      s.should_receive(:call)
+
+      s
+    end
+
+    it "calls succeed on the stopper" do
+      subject.should_receive(:stopper).and_return(stopper)
+
+      subject.stop!
+    end
+  end
+
+  describe "#write_to" do
+    context "unknown URI scheme" do
+      it "raises an ArgumentError" do
+        expect {
+          subject.write_to("test://stuff")
+        }.to raise_error ArgumentError
+      end
+    end
+
+    context "known URI scheme" do
+      it "creates the new writer, adds it to @writers, and returns it" do
+        uri = URI "test://somehost"
+        subject.should_receive(:new_writer_from_uri) do |arg1, arg2|
+          arg1.should == uri
+          arg2.should be_a EventMachine::Channel
+        end.and_return(test_writer)
+
+        subject.write_to('test://somehost').should == test_writer
+      end
+    end
+  end
+
+  describe "#add_writer" do
+    let(:obj_object) { double "TestWriter" }
+
+    context "obj is a Class" do
+      let(:obj) do
+        class TestWriter; self; end
+      end
+
+      it "creates a new object of that class with all args and the write channel" do
+        first_arg = double "first arg"
+        second_arg = double "second arg"
+
+        obj.should_receive(:new) do |arg1, arg2, arg3|
+          arg1.should == first_arg
+          arg2.should == second_arg
+          arg3.should be_a EventMachine::Channel
+        end.and_return(obj_object)
+
+        subject.add_writer(obj, first_arg, second_arg).should == obj_object
+      end
+    end
+
+    context "obj is a instantiated Writer object" do
+      it "adds that object to the list of writers and returns it" do
+        obj_object.should_receive(:kind_of?).with(Pants::Writers::BaseWriter).
+          and_return(true)
+
+        subject.add_writer(obj_object).should == obj_object
+      end
+    end
+
+    context "obj isn't a Class and isn't a Writer" do
+      it "raises a Pants::Error" do
+        expect {
+          subject.add_writer("meow")
+        }.to raise_error Pants::Error
+      end
+    end
+  end
+
+  describe '#remove_writer' do
+    before do
+      subject.instance_variable_set(:@writers, writers)
+    end
+
+    context "using URI" do
+      let(:writer1) do
+        double "Pants::Writers::FileWriter", file_path: "file1"
+      end
+
+      let(:writer2) do
+        double "Pants::Writers::FileWriter", file_path: "file2"
+      end
+
+      let(:writer3) do
+        double "Pants::Writers::UDPWriter",
+          host: '127.0.0.1',
+          port: 1234
+      end
+
+      let(:writer4) do
+        double "Pants::Writers::UDPWriter",
+          host: '127.0.0.2',
+          port: 1234
+      end
+
+      let(:writers) { [writer1, writer2, writer3, writer4] }
+
+      context "Pants.writers doesn't define a writer by the given scheme" do
+        it "raises an ArgumentError" do
+          expect {
+            subject.remove_writer("http://1.2.3.4")
+          }.to raise_error ArgumentError
+        end
+      end
+
+      context "@writers contains a writer type by the given URI" do
+        before do
+          writer1.should_receive(:is_a?).with(Pants::Writers::UDPWriter).and_return(false)
+          writer2.should_receive(:is_a?).with(Pants::Writers::UDPWriter).and_return(false)
+          writer3.should_receive(:is_a?).with(Pants::Writers::UDPWriter).and_return(true)
+          writer4.should_receive(:is_a?).with(Pants::Writers::UDPWriter).and_return(true)
+        end
+
+        context "but doesn't match criteria given by the URI" do
+          it "doesn't remove anything" do
+            subject.remove_writer("udp://127.0.0.1:9000")
+            subject.writers.should be writers
+          end
+        end
+
+        context "and criteria matches given key_value_pairs" do
+          it "removes the matching object" do
+            subject.remove_writer("udp://127.0.0.1:1234")
+            subject.writers.should == [writer1, writer2, writer4]
+          end
+        end
+      end
+    end
+
+    context "using class and args" do
+      let(:writers) do
+        [String.new, Hash.new, Array.new]
+      end
+
+      context "@writers doesn't contain a writer by the given class" do
+        it "doesn't remove anything" do
+          subject.remove_writer(URI, {})
+          subject.writers.size.should be 3
+        end
+      end
+
+      context "@writers contains a writer by the given class" do
+        context "but doesn't match criteria given by key_value_pairs" do
+          it "doesn't remove anything" do
+            subject.remove_writer(String, size: 1)
+            subject.writers.size.should be 3
+          end
+        end
+
+        context "and criteria matches given key_value_pairs" do
+          it "removes the matching object" do
+            subject.remove_writer(String, size: 0)
+            subject.writers.size.should be 2
+          end
+        end
+
+        context "and criteria of more than 1 object matches given key_value_pairs" do
+          let(:writers) do
+            [String.new, String.new, String.new]
+          end
+
+          it "removes the matching object" do
+            subject.remove_writer(String, size: 0)
+            subject.writers.size.should be 0
+          end
+        end
+      end
+    end
+  end
+
+  describe "#add_seam" do
+    context "klass doesn't exist" do
+      it "raises a NameError" do
+        expect {
+          subject.add_seam(BananaSplitPantsParty)
+        }.to raise_error NameError
+      end
+    end
+
+    context "klass exists" do
+      let(:channel) do
+        double "EventMachine::Channel"
+      end
+
+      let(:seam_class) do
+        s = double "Pants::Seam"
+        s.should_receive(:new).with(core_stopper_callback, channel).and_return(seam)
+
+        s
+      end
+
+      let(:seam) do
+        double "Pants::Seam"
+      end
+
+      before do
+        subject.instance_variable_set(:@write_to_channel, channel)
+      end
+
+      it "creates the new object and adds it to the internal list of writers" do
+        subject.add_seam(seam_class).should == seam
+      end
+    end
+  end
+
+  describe "#stopper" do
+    context "when called back with success" do
+      before do
+        subject.instance_variable_set(:@writers, [test_writer])
+        EM.stub(:next_tick).and_yield
+        EM.stub(:tick_loop).and_yield.and_return(tick_loop)
+        EM::Iterator.stub(:new).and_return(iterator)
+      end
+
+      let(:tick_loop) do
+        t = double "EventMachine::TickLoop"
+        t.should_receive(:on_stop).and_yield
+
+        t
+      end
+
+      let(:iterator) do
+        i = double "EventMachine::Iterator"
+        i.should_receive(:each).and_yield(test_writer, i)
+        i.stub(:next)
+
+        i
+      end
+
+      it "calls each writer's stopper and the main callback" do
+        core_stopper_callback.should_receive(:call)
+        test_writer.should_receive(:running?)
+        test_writer.should_receive(:stop)
+
+        subject.send(:stopper).call
+      end
+    end
+  end
+
+  describe "#new_writer_from_uri" do
+    let(:channel) do
+      double "EventMachine::Channel"
+    end
+
+    context "uri_scheme exists in Pants.writers" do
+      let(:test_writer) do
+        double "Pants::Writers::TestWriter"
+      end
+
+      let(:writers) do
+        [{ uri_scheme: 'test', klass: test_writer, args: [:host] }]
+      end
+
+      before do
+        Pants.stub(:writers).and_return writers
+      end
+
+      it "creates a new Writer based on the scheme mapping" do
+        uri = URI "test://testhost"
+        test_writer.should_receive(:new).with("testhost", channel)
+
+        subject.send(:new_writer_from_uri, uri, channel)
+      end
+    end
+
+    context "uri_scheme does not exist in writers" do
+      it "raises" do
+        uri = URI "bobo://host:1234/path"
+
+        expect {
+          subject.send(:new_writer_from_uri, uri, channel)
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end