Rename Target(List) to Flow(s)

Since a flow will significantly affect the representation of a log event
over its life before being persistet by the final adapter, the new term
better reflects what it is responsible for.

It also helps to avoid the dupliction of meaning between Sink, Target,
Adapter.

lib/rackstash/flow.rb

@@ -4,7 +4,7 @@
 # of the MIT license. See the LICENSE.txt file for details.
 
 module Rackstash
-  class Target
+  class Flow
     def initialize(adapter = nil)
       @adapter = adapter
     end

lib/rackstash/flows.rb

@@ -0,0 +1,57 @@
+# Copyright 2017 Holger Just
+#
+# This software may be modified and distributed under the terms
+# of the MIT license. See the LICENSE.txt file for details.
+
+require 'rackstash/flow'
+
+module Rackstash
+  class Flows
+    def initialize(*flows)
+      @flows = Concurrent::Array.new
+
+      flows.flatten.each do |flow|
+        add(flow)
+      end
+    end
+
+    def <<(flow)
+      flow = Flow.new(flow) unless flow.is_a?(Flow)
+      @flows << flow
+      self
+    end
+    alias add <<
+
+    def [](index)
+      @flows[index]
+    end
+
+    def []=(index, flow)
+      flow = Flow.new(flow) unless flow.is_a?(Flow)
+      @flows[index] = flow
+    end
+
+    def empty?
+      @flows.empty?
+    end
+
+    def inspect
+      id_str = (object_id << 1).to_s(16).rjust(DEFAULT_OBJ_ID_STR_WIDTH, '0')
+      "#<#{self.class.name}:0x#{id_str} #{self}>"
+    end
+
+    def length
+      @flows.length
+    end
+    alias size length
+
+    def to_ary
+      @flows.to_a
+    end
+    alias to_a to_ary
+
+    def to_s
+      @flows.to_s
+    end
+  end
+end

lib/rackstash/target_list.rb

@@ -1,50 +0,0 @@
-module Rackstash
-  class TargetList
-    def initialize(*targets)
-      @targets = Concurrent::Array.new
-
-      targets.flatten.each do |target|
-        add(target)
-      end
-    end
-
-    def <<(target)
-      target = Target.new(target) unless target.is_a?(Target)
-      @targets << target
-      self
-    end
-    alias add <<
-
-    def [](index)
-      @targets[index]
-    end
-
-    def []=(index, target)
-      target = Target.new(target) unless target.is_a?(Target)
-      @targets[index] = target
-    end
-
-    def empty?
-      @targets.empty?
-    end
-
-    def inspect
-      id_str = (object_id << 1).to_s(16).rjust(DEFAULT_OBJ_ID_STR_WIDTH, '0')
-      "#<#{self.class.name}:0x#{id_str} #{self}>"
-    end
-
-    def length
-      @targets.length
-    end
-    alias size length
-
-    def to_ary
-      @targets.to_a
-    end
-    alias to_a to_ary
-
-    def to_s
-      @targets.to_s
-    end
-  end
-end

spec/rackstash/flows_spec.rb

@@ -0,0 +1,162 @@
+# Copyright 2017 Holger Just
+#
+# This software may be modified and distributed under the terms
+# of the MIT license. See the LICENSE.txt file for details.
+
+require 'spec_helper'
+
+require 'rackstash/flows'
+require 'rackstash/flow'
+
+describe Rackstash::Flows do
+  let(:flows) { Rackstash::Flows.new }
+
+  def a_flow
+    flow = instance_double('Rackstash::Flow')
+    allow(flow).to receive(:is_a?).with(Rackstash::Flow).and_return(true)
+    flow
+  end
+
+  describe '#initialize' do
+    it 'accepts a single flow' do
+      list = Rackstash::Flows.new(a_flow)
+      expect(list.size).to eql 1
+    end
+
+    it 'accepts a list of flows' do
+      flows = 3.times.map { a_flow }
+
+      list_with_array = Rackstash::Flows.new(flows)
+      expect(list_with_array.size).to eql 3
+
+      list_with_splat = Rackstash::Flows.new(*flows)
+      expect(list_with_splat.size).to eql 3
+    end
+  end
+
+  describe '#<<' do
+    let(:flow) { a_flow }
+
+    it 'adds a new flow at the end of the list' do
+      expect(flows.size).to eql 0
+      flows << flow
+      expect(flows.size).to eql 1
+      expect(flows[0]).to equal flow
+    end
+
+    it 'tries to find a matching flow' do
+      wrapped = Object.new
+      flow = Object.new
+
+      flow_class = class_double('Rackstash::Flow').as_stubbed_const
+      expect(flow_class).to receive(:new).with(wrapped).and_return(flow)
+
+      expect(flows.size).to eql 0
+      flows << wrapped
+      expect(flows.size).to eql 1
+      expect(flows[0]).to equal flow
+    end
+
+    it 'can use the #add alias' do
+      expect(flows.size).to eql 0
+      flows.add flow
+      expect(flows.size).to eql 1
+      expect(flows[0]).to equal flow
+    end
+  end
+
+  describe '#[]' do
+    let(:flow) { a_flow }
+
+    it 'returns the index flow' do
+      flows << flow
+      expect(flows[0]).to equal flow
+      expect(flows[1]).to be_nil
+    end
+  end
+
+  describe '#[]=' do
+    it 'sets a flow' do
+      original_flow = a_flow
+      new_flow = a_flow
+
+      flows << original_flow
+      expect(flows[0]).to equal original_flow
+
+      flows[0] = new_flow
+      expect(flows[0]).to equal new_flow
+    end
+
+    it 'adds nil flows if necessary' do
+      flow = a_flow
+      flows[3] = flow
+      expect(flows.to_a).to eql [nil, nil, nil, flow]
+    end
+
+    it 'tries to find a matching flow' do
+      wrapped = Object.new
+      flow = Object.new
+
+      flow_class = class_double('Rackstash::Flow').as_stubbed_const
+      expect(flow_class).to receive(:new).with(wrapped).and_return(flow)
+
+      flows[0] = wrapped
+      expect(flows[0]).to equal flow
+    end
+  end
+
+  describe '#empty?' do
+    it 'is true if empty' do
+      expect(flows).to be_empty
+      flows << a_flow
+      expect(flows).not_to be_empty
+    end
+  end
+
+  describe '#inspect' do
+    it 'formats the object' do
+      expect(flows).to receive(:to_s).and_return('["<flow>"]')
+      expect(flows.inspect).to(
+        match %r{\A#<Rackstash::Flows:0x[a-f0-9]+ \["<flow>"\]>\z}
+      )
+    end
+  end
+
+  describe '#length' do
+    it 'returns the number of flows' do
+      expect { flows << a_flow}
+        .to change { flows.length }.from(0).to(1)
+    end
+
+    it 'can use size alias' do
+      expect { flows << a_flow}
+        .to change { flows.size }.from(0).to(1)
+    end
+  end
+
+  describe '#to_ary' do
+    it 'returns an array' do
+      flows << a_flow
+
+      expect(flows.to_a).to be_an_instance_of(::Array)
+      expect(flows.to_a).not_to be_empty
+    end
+
+    it 'returns a new object each time' do
+      array = flows.to_a
+      expect(flows.to_a).to eql array
+      expect(flows.to_a).not_to equal array
+
+      array << a_flow
+      expect(flows.to_a).not_to eql array
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns the array representation' do
+      flows << a_flow
+
+      expect(flows.to_s).to eql flows.to_a.to_s
+    end
+  end
+end

spec/rackstash/target_list_spec.rb

@@ -1,162 +0,0 @@
-# Copyright 2017 Holger Just
-#
-# This software may be modified and distributed under the terms
-# of the MIT license. See the LICENSE.txt file for details.
-
-require 'spec_helper'
-
-require 'rackstash/target_list'
-require 'rackstash/target'
-
-describe Rackstash::TargetList do
-  let(:target_list) { Rackstash::TargetList.new }
-
-  def a_target
-    target = instance_double('Rackstash::Target')
-    allow(target).to receive(:is_a?).with(Rackstash::Target).and_return(true)
-    target
-  end
-
-  describe '#initialize' do
-    it 'accepts a single target' do
-      list = Rackstash::TargetList.new(a_target)
-      expect(list.size).to eql 1
-    end
-
-    it 'accepts a list of targets' do
-      targets = 3.times.map { a_target }
-
-      list_with_array = Rackstash::TargetList.new(targets)
-      expect(list_with_array.size).to eql 3
-
-      list_with_splat = Rackstash::TargetList.new(*targets)
-      expect(list_with_splat.size).to eql 3
-    end
-  end
-
-  describe '#<<' do
-    let(:target) { a_target }
-
-    it 'adds a new target at the end of the list' do
-      expect(target_list.size).to eql 0
-      target_list << target
-      expect(target_list.size).to eql 1
-      expect(target_list[0]).to equal target
-    end
-
-    it 'tries to find a matching target' do
-      wrapped = Object.new
-      target = Object.new
-
-      target_class = class_double('Rackstash::Target').as_stubbed_const
-      expect(target_class).to receive(:new).with(wrapped).and_return(target)
-
-      expect(target_list.size).to eql 0
-      target_list << wrapped
-      expect(target_list.size).to eql 1
-      expect(target_list[0]).to equal target
-    end
-
-    it 'can use the #add alias' do
-      expect(target_list.size).to eql 0
-      target_list.add target
-      expect(target_list.size).to eql 1
-      expect(target_list[0]).to equal target
-    end
-  end
-
-  describe '#[]' do
-    let(:target) { a_target }
-
-    it 'returns the index target' do
-      target_list << target
-      expect(target_list[0]).to equal target
-      expect(target_list[1]).to be_nil
-    end
-  end
-
-  describe '#[]=' do
-    it 'sets a target' do
-      original_target = a_target
-      new_target = a_target
-
-      target_list << original_target
-      expect(target_list[0]).to equal original_target
-
-      target_list[0] = new_target
-      expect(target_list[0]).to equal new_target
-    end
-
-    it 'adds nil targets if necessary' do
-      target = a_target
-      target_list[3] = target
-      expect(target_list.to_a).to eql [nil, nil, nil, target]
-    end
-
-    it 'tries to find a matching target' do
-      wrapped = Object.new
-      target = Object.new
-
-      target_class = class_double('Rackstash::Target').as_stubbed_const
-      expect(target_class).to receive(:new).with(wrapped).and_return(target)
-
-      target_list[0] = wrapped
-      expect(target_list[0]).to equal target
-    end
-  end
-
-  describe '#empty?' do
-    it 'is true if empty' do
-      expect(target_list).to be_empty
-      target_list << a_target
-      expect(target_list).not_to be_empty
-    end
-  end
-
-  describe '#inspect' do
-    it 'formats the object' do
-      expect(target_list).to receive(:to_s).and_return('["<target>"]')
-      expect(target_list.inspect).to(
-        match %r{\A#<Rackstash::TargetList:0x[a-f0-9]+ \["<target>"\]>\z}
-      )
-    end
-  end
-
-  describe '#length' do
-    it 'returns the number of targets' do
-      expect { target_list << a_target}
-        .to change { target_list.length }.from(0).to(1)
-    end
-
-    it 'can use size alias' do
-      expect { target_list << a_target}
-        .to change { target_list.size }.from(0).to(1)
-    end
-  end
-
-  describe '#to_ary' do
-    it 'returns an array' do
-      target_list << a_target
-
-      expect(target_list.to_a).to be_an_instance_of(::Array)
-      expect(target_list.to_a).not_to be_empty
-    end
-
-    it 'returns a new object each time' do
-      array = target_list.to_a
-      expect(target_list.to_a).to eql array
-      expect(target_list.to_a).not_to equal array
-
-      array << a_target
-      expect(target_list.to_a).not_to eql array
-    end
-  end
-
-  describe '#to_s' do
-    it 'returns the array representation' do
-      target_list << a_target
-
-      expect(target_list.to_s).to eql target_list.to_a.to_s
-    end
-  end
-end