circuits 0.7.0 → 0.8.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MzQwY2JkYzJjMDVkZWNmMjFlZTI0ZWQzZDNmOGQwMWIxODE5YmVlMw==
+    NzM4MzA1YTA1NmFhMjY1ZmMzYzY1ZTgxOWY2MDlhMTQ3YzVkY2Q3OA==
   data.tar.gz: !binary |-
-    YTY3NGI2Nzc3MzBlZjZjZDg1MWEyMzg0NDc3MWY5ODBhZDYxNWJjYg==
+    MzhmN2Y4ZTdiODliY2ZkYjQyNjRjODk0OWZmNmYwNmE4NDRjMGQ1Nw==
 SHA512:
   metadata.gz: !binary |-
-    ZjcwM2U4YzY1N2JiYWVmZWIwNWE3ZGFmYmFmNWRkMTg4MWVlYTU2MzRiMzM0
-    ZmFkMDI2MmM0NDBjY2I1Y2ViODJjMTMwN2EzNTY3ZmRhYjA1Zjk1MDhiNTA1
-    OGZlM2ZkYjBkMzU5ZjNkNmZhOGFmNTNkNWQxNmJjZTQzNjE2M2U=
+    ZGRlNzY4OThhNmRmNWE4MDQ1NzdjMDk2NmEzNzM1YTQ3ZWRiMGMzNGExMTM5
+    N2JiMmVhNDI3ODQ1MzM1YmQ1NmNiNjExZWJmZDA4MzI0YmUzMTc2YjE4NGI3
+    OWY5NGIzNjE3Nzc4NmQ4NDA4MTE2ZTExMWVjZGFmMTM3ZGViNzg=
   data.tar.gz: !binary |-
-    MWRjYmY5MjhhZTJiMWZiNjgwZjgyZjMzMTkxYWUwODBkZTVjMDRkNTVjZTUy
-    MWMxOTVmYWQ4M2RkZDdiYzUwYWMyMjAwNTkyMmQ1NzgyNGE4ZTgzZTlkYWMx
-    ZmU4M2M0ZjU5Mzg4NzhhYTkwYzZhNTIwOGEyMjUzZTk4NjE4MjA=
+    ZjFmOTRjYWM1NDExNDgzMDEwMTFiNTQ1ZTI3NjYyNzA4MzUyNWIwNjYzNjk1
+    MDU5ODQ4ZDY5M2Y2MWVjYjJmNTE3OTIxMTliZjNlNzRjNzgxOWRiYWQ5NWFk
+    ZGQyM2U4YmMzYjBjZGI3OGVmOWJiYmVjYTYwNTA1Yzk2ODM4YWM=

data/lib/circuits/component/and.rb

@@ -4,16 +4,20 @@ module Circuits
   module Component
     # Logical AND Operator
     class And < Base
-      def initialize(opts = {})
-        @input_count = 2
-        @output_count = 1
-        super opts
-      end
-
       # Sets the output to be the result of a logical AND of the inputs
       def tick
         self[:out].set(inputs.map(&:get).inject(:&))
       end
+
+      private
+
+      def default_input_count
+        2
+      end
+
+      def default_output_count
+        1
+      end
     end
   end
 end

data/lib/circuits/component/base.rb

@@ -10,17 +10,22 @@ module Circuits
     class Base
       # Creates the Component with inputs and outputs
       # @param opts [Hash] options to create the Component with
-      # @option opts [Array<Input>, FixNum] :inputs The array of inputs to use,
-      # or the number of inputs to create
+      # @option opts [FixNum] :input_count The number of inputs
+      # @option opts [FixNum] :ouput_count The number of outputs
+      # @option opts [Hash] :port_mappings The port_mappings to use
       def initialize(opts = {})
-        create_inputs opts
-        create_outputs opts
+        input_count = opts[:input_count] || default_input_count
+        output_count = opts[:output_count] || default_output_count
+        @inputs = input_count.times.collect { Circuits::Terminal::Input.new }
+        @outputs = output_count.times.collect { Circuits::Terminal::Output.new }
+        @port_mappings = opts[:port_mappings] || default_port_mappings
       end
 
-      # Does the internal computation and sets the outputs
-      def tick
-        fail NotImplementedError
-      end
+      # the inputs of this component
+      attr_reader :inputs
+
+      # the outputs of this component
+      attr_reader :outputs
 
       # Sets all the outputs expose what was set in #tick
       def tock
@@ -31,83 +36,46 @@ module Circuits
       # @param port [Symbol] The symbol that represents the terminal
       # @return [Input, Output] The terminal
       def [](port)
-        p = port_mappings[port]
-        case p[:type]
-        when :input
-          inputs[p[:number]]
-        when :output
-          outputs[p[:number]]
-        end
-      end
-
-      # Assigns to an input or output
-      # @param port [Symbol] The symbol that represents the terminal
-      # @param terminal [Input, Output] The terminal to assign
-      # @return [Input, Output] The terminal that was passed in
-      def []=(port, terminal)
-        p = port_mappings[port]
-        case p[:type]
+        port_mapping = port_mappings[port]
+        port_number = port_mapping[:number]
+        case port_mapping[:type]
         when :input
-          inputs[p[:number]] = terminal
+          inputs[port_number]
         when :output
-          outputs[p[:number]] = terminal
+          outputs[port_number]
         end
       end
 
-      # the inputs of this component
-      attr_reader :inputs
-
-      # the outputs of this component
-      attr_reader :outputs
-
       private
 
-      def create_inputs(opts)
-        if opts[:inputs].class == Array
-          @inputs = opts[:inputs]
-          @input_count = @inputs.length
-        elsif opts[:inputs].class == Fixnum
-          @input_count = opts[:inputs]
-        end
-        @inputs ||= @input_count.times.collect { Circuits::Terminal::Input.new }
-      end
+      attr_reader :port_mappings
 
-      def create_outputs(opts)
-        if opts[:outputs].class == Array
-          @outputs = opts[:outputs]
-          @output_count = @outputs.length
-        elsif opts[:outputs].class == Fixnum
-          @output_count = opts[:outputs]
-        end
-        @outputs ||= @output_count.times.collect do
-          Circuits::Terminal::Output.new
+      def default_port_mappings
+        res = {}
+        (input_mappings + output_mappings).each do |mapping|
+          res.merge!(mapping)
         end
-      end
-
-      def port_mappings
-        return @port_mappings unless @port_mappings.nil?
-        @port_mappings = {}
-        input_mappings.each { |x| @port_mappings.merge!(x) }
-        output_mappings.each { |x| @port_mappings.merge!(x) }
-        @port_mappings
+        res
       end
 
       def input_mappings
-        return [{ in: { type: :input, number: 0 } }] if @input_count == 1
-        @input_count.times.collect do |i|
-          { num_to_port(i) => { type: :input, number: i } }
+        input_count = inputs.length
+        return [{ in: { type: :input, number: 0 } }] if input_count == 1
+        input_count.times.collect do |num|
+          { num_to_port(num) => { type: :input, number: num } }
         end
       end
 
       def output_mappings
-        return[{ out: { type: :output, number: 0 } }] if @output_count == 1
-        @output_count.times.collect do |i|
-          { num_to_port(i + @input_count) => { type: :output, number: i } }
+        output_count = outputs.length
+        return[{ out: { type: :output, number: 0 } }] if output_count == 1
+        output_count.times.collect do |num|
+          { num_to_port(num + inputs.length) => { type: :output, number: num } }
         end
       end
 
-      def num_to_port(i)
-        (i + 'a'.ord).chr.to_sym
+      def num_to_port(num)
+        (num + 'a'.ord).chr.to_sym
       end
     end
   end

data/lib/circuits/component/nand.rb

@@ -4,16 +4,20 @@ module Circuits
   module Component
     # Logical NAND Operator
     class Nand < Base
-      def initialize(opts = {})
-        @input_count = 2
-        @output_count = 1
-        super opts
-      end
-
       # Sets the output to be the result of a logical NAND of the inputs
       def tick
         self[:out].set(!inputs.map(&:get).inject(:&))
       end
+
+      private
+
+      def default_input_count
+        2
+      end
+
+      def default_output_count
+        1
+      end
     end
   end
 end

data/lib/circuits/component/nor.rb

@@ -4,16 +4,20 @@ module Circuits
   module Component
     # Logical NOR Operator
     class Nor < Base
-      def initialize(opts = {})
-        @input_count = 2
-        @output_count = 1
-        super opts
-      end
-
       # Sets the output to be the result of a logical OR of the inputs
       def tick
         self[:out].set(!inputs.map(&:get).inject(:|))
       end
+
+      private
+
+      def default_input_count
+        2
+      end
+
+      def default_output_count
+        1
+      end
     end
   end
 end

data/lib/circuits/component/not.rb

@@ -4,16 +4,20 @@ module Circuits
   module Component
     # Logical NOT Operator
     class Not < Base
-      def initialize(opts = {})
-        @input_count = 1
-        @output_count = 1
-        super opts
-      end
-
       # Sets the output to be the result of a logical NOT of the inputs
       def tick
         self[:out].set(!self[:in].get)
       end
+
+      private
+
+      def default_input_count
+        1
+      end
+
+      def default_output_count
+        1
+      end
     end
   end
 end

data/lib/circuits/component/or.rb

@@ -4,16 +4,20 @@ module Circuits
   module Component
     # Logical OR Operator
     class Or < Base
-      def initialize(opts = {})
-        @input_count = 2
-        @output_count = 1
-        super opts
-      end
-
       # Sets the output to be the result of a logical OR of the inputs
       def tick
         self[:out].set(inputs.map(&:get).inject(:|))
       end
+
+      private
+
+      def default_input_count
+        2
+      end
+
+      def default_output_count
+        1
+      end
     end
   end
 end

data/lib/circuits/component/sr_nand.rb

@@ -5,9 +5,11 @@ module Circuits
   module Component
     # SR NAND Latch
     class SrNand < Base
-      def initialize(opts = {})
-        set_defaults
-        super opts
+      def initialize
+        super(port_mappings: { not_s: { type: :input, number: 0 },
+                               not_r: { type: :input, number: 1 },
+                               q: { type: :output, number: 0 },
+                               not_q: { type: :output, number: 1 } })
         create_sub_components
         link_inputs
         link_outputs
@@ -24,38 +26,35 @@ module Circuits
 
       private
 
-      attr_reader :nand_1, :nand_2, :sub_components
+      attr_reader :nand_s, :nand_r, :sub_components
 
       def create_sub_components
-        @nand_1 = Nand.new
-        @nand_2 = Nand.new
-        @sub_components = [@nand_1, @nand_2]
+        @nand_s = Nand.new
+        @nand_r = Nand.new
+        @sub_components = [@nand_s, @nand_r]
+      end
+
+      def default_input_count
+        2
+      end
+
+      def default_output_count
+        2
       end
 
       def link_inputs
-        nand_1[:a].set self[:not_s]
-        nand_2[:a].set self[:not_r]
+        nand_s[:a].set self[:not_s]
+        nand_r[:a].set self[:not_r]
       end
 
       def link_outputs
-        self[:q].set nand_1[:out]
-        self[:not_q].set nand_2[:out]
+        self[:q].set nand_s[:out]
+        self[:not_q].set nand_r[:out]
       end
 
       def link_sub_components
-        nand_1[:b].set nand_2[:out]
-        nand_2[:b].set nand_1[:out]
-      end
-
-      def set_defaults
-        @input_count = 2
-        @output_count = 2
-        @port_mappings = {
-          not_s: { type: :input, number: 0 },
-          not_r: { type: :input, number: 1 },
-          q: { type: :output, number: 0 },
-          not_q: { type: :output, number: 1 }
-        }
+        nand_s[:b].set nand_r[:out]
+        nand_r[:b].set nand_s[:out]
       end
     end
   end

data/lib/circuits/component/sr_nor.rb

@@ -5,9 +5,11 @@ module Circuits
   module Component
     # SR NOR Latch
     class SrNor < Base
-      def initialize(opts = {})
-        set_defaults
-        super opts
+      def initialize
+        super(port_mappings: { r: { type: :input, number: 0 },
+                               s: { type: :input, number: 1 },
+                               q: { type: :output, number: 0 },
+                               not_q: { type: :output, number: 1 } })
         create_sub_components
         link_inputs
         link_outputs
@@ -24,38 +26,35 @@ module Circuits
 
       private
 
-      attr_reader :nor_1, :nor_2, :sub_components
+      attr_reader :nor_r, :nor_s, :sub_components
 
       def create_sub_components
-        @nor_1 = Nor.new
-        @nor_2 = Nor.new
-        @sub_components = [@nor_1, @nor_2]
+        @nor_r = Nor.new
+        @nor_s = Nor.new
+        @sub_components = [@nor_r, @nor_s]
+      end
+
+      def default_input_count
+        2
+      end
+
+      def default_output_count
+        2
       end
 
       def link_inputs
-        nor_1[:a].set self[:r]
-        nor_2[:a].set self[:s]
+        nor_r[:a].set self[:r]
+        nor_s[:a].set self[:s]
       end
 
       def link_outputs
-        self[:q].set nor_1[:out]
-        self[:not_q].set nor_2[:out]
+        self[:q].set nor_r[:out]
+        self[:not_q].set nor_s[:out]
       end
 
       def link_sub_components
-        nor_1[:b].set nor_2[:out]
-        nor_2[:b].set nor_1[:out]
-      end
-
-      def set_defaults
-        @input_count = 2
-        @output_count = 2
-        @port_mappings = {
-          r: { type: :input, number: 0 },
-          s: { type: :input, number: 1 },
-          q: { type: :output, number: 0 },
-          not_q: { type: :output, number: 1 }
-        }
+        nor_r[:b].set nor_s[:out]
+        nor_s[:b].set nor_r[:out]
       end
     end
   end

data/lib/circuits/component/xnor.rb

@@ -4,16 +4,20 @@ module Circuits
   module Component
     # Logical XNOR Operator
     class Xnor < Base
-      def initialize(opts = {})
-        @input_count = 2
-        @output_count = 1
-        super opts
-      end
-
       # Sets the output to be the result of a logical XNOR of the inputs
       def tick
         self[:out].set(!inputs.map(&:get).inject(:^))
       end
+
+      private
+
+      def default_input_count
+        2
+      end
+
+      def default_output_count
+        1
+      end
     end
   end
 end

data/lib/circuits/component/xor.rb

@@ -4,16 +4,20 @@ module Circuits
   module Component
     # Logical XOR Operator
     class Xor < Base
-      def initialize(opts = {})
-        @input_count = 2
-        @output_count = 1
-        super opts
-      end
-
       # Sets the output to be the result of a logical XOR of the inputs
       def tick
         self[:out].set(inputs.map(&:get).inject(:^))
       end
+
+      private
+
+      def default_input_count
+        2
+      end
+
+      def default_output_count
+        1
+      end
     end
   end
 end

data/lib/circuits/terminal/output.rb

@@ -6,6 +6,7 @@ module Circuits
       # Creates the output
       # @param opts [Hash] Options to create the Output with
       # @option opts [Boolean] :state The initial state of the Output
+      # @option opts [Input, Output] :terminal The terminal to read from
       def initialize(opts = {})
         @next_state = opts[:terminal] || opts[:state] || false
         tock
@@ -18,7 +19,7 @@ module Circuits
       end
 
       # The next state
-      # @param [Boolean, Terminal] terminal The terminal or state to output
+      # @param [Boolean, Terminal] state The terminal or state to output
       def set(state)
         @next_state = state
       end

data/lib/circuits/version.rb

@@ -1,5 +1,5 @@
 # Circuits allows you to express logical circuits in code
 module Circuits
   # The version of the Circuits gem
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 end

data/spec/spec_helper.rb

@@ -1,2 +1,4 @@
 require 'coveralls'
-Coveralls.wear!
+require 'simplecov'
+
+SimpleCov.start

data/spec/unit/circuits/component/and_spec.rb

@@ -58,7 +58,7 @@ describe Circuits::Component::And do
 
     [3, 4, 8].each do |n|
       context "with #{n} inputs" do
-        subject { Circuits::Component::And.new inputs: n }
+        subject { Circuits::Component::And.new input_count: n }
 
         before do
           n.times { |x| subject.inputs[x].set inputs[x] }

data/spec/unit/circuits/component/base_spec.rb

@@ -2,100 +2,52 @@ require 'spec_helper'
 require 'circuits/component/base'
 
 # Mock component to include Circuits::Component::Base
-class MockComponent < Circuits::Component::Base
-  def initialize(opts = {})
-    @input_count = 1
-    @output_count = 1
-    super opts
+class MockComponent1 < Circuits::Component::Base
+  def default_input_count
+    1
   end
-end
-
-describe Circuits::Component::Base do
-  context 'when using defaults' do
-    subject { MockComponent.new }
-
-    it 'has one input' do
-      expect(subject.inputs.count).to eq(1)
-    end
-
-    it 'has one output' do
-      expect(subject.outputs.count).to eq(1)
-    end
 
-    describe '#[]=' do
-      let(:new_input) { double('new_input') }
-      let(:new_output) { double('new_output') }
-
-      before do
-        subject[:in] = new_input
-        subject[:out] = new_output
-      end
-
-      it 'has the new input available as :in' do
-        expect(subject[:in]).to eq(new_input)
-      end
-
-      it 'has the new output available as :out' do
-        expect(subject[:out]).to eq(new_output)
-      end
-    end
+  def default_output_count
+    1
   end
+end
 
-  context 'when specifying input and output count' do
-    subject { MockComponent.new(inputs: 2, outputs: 2) }
-
-    it 'has one input' do
-      expect(subject.inputs.count).to eq(2)
-    end
-
-    it 'has one output' do
-      expect(subject.outputs.count).to eq(2)
-    end
+# Mock component to include Circuits::Component::Base
+class MockComponent2 < Circuits::Component::Base
+  def default_input_count
+    2
   end
 
-  context 'when supplying inputs and outputs' do
-    let(:inputs) { [double('input')] }
-    let(:outputs) { [double('output')] }
+  def default_output_count
+    2
+  end
+end
 
-    subject { MockComponent.new(inputs: inputs, outputs: outputs) }
+describe Circuits::Component::Base do
+  describe '#[]' do
+    context 'one input and one output' do
+      subject { MockComponent1.new }
 
-    describe '#tick' do
-      it 'raises NotImplementedError' do
-        expect { subject.tick }.to raise_error(NotImplementedError)
+      it 'has the input available as :in' do
+        expect(subject[:in]).to eq(subject.inputs[0])
       end
-    end
 
-    describe '#tock' do
-      it 'tocks the outputs' do
-        expect(outputs[0]).to receive(:tock)
-        subject.tock
+      it 'has the output available as :out' do
+        expect(subject[:out]).to eq(subject.outputs[0])
       end
     end
 
-    describe '#[]' do
-      context 'one input and one output' do
-        it 'has the input available as :in' do
-          expect(subject[:in]).to eq(inputs[0])
-        end
+    context 'two inputs and two outputs' do
+      subject { MockComponent2.new }
 
-        it 'has the output available as :out' do
-          expect(subject[:out]).to eq(outputs[0])
-        end
+      it 'has the inputs available as :a and :b' do
+        expect(subject[:a]).to eq(subject.inputs[0])
+        expect(subject[:b]).to eq(subject.inputs[1])
       end
 
-      context 'two inputs and two outputs' do
-        let(:inputs) { [double('input_1'), double('input_2')] }
-        let(:outputs) { [double('output_1'), double('output_2')] }
-
-        it 'has the inputs available as :a and :b' do
-          expect(subject[:a]).to eq(inputs[0])
-          expect(subject[:b]).to eq(inputs[1])
-        end
-
-        it 'has the outputs available as :c and :d' do
-          expect(subject[:c]).to eq(outputs[0])
-          expect(subject[:d]).to eq(outputs[1])
-        end
+      it 'has the outputs available as :c and :d' do
+        expect(subject[:c]).to eq(subject.outputs[0])
+        expect(subject[:d]).to eq(subject.outputs[1])
       end
     end
   end

data/spec/unit/circuits/component/nand_spec.rb

@@ -57,7 +57,7 @@ describe Circuits::Component::Nand do
     end
     [3, 4, 8].each do |n|
       context "with #{n} inputs" do
-        subject { Circuits::Component::Nand.new inputs: n }
+        subject { Circuits::Component::Nand.new input_count: n }
 
         before do
           n.times { |x| subject.inputs[x].set inputs[x] }

data/spec/unit/circuits/component/nor_spec.rb

@@ -57,7 +57,7 @@ describe Circuits::Component::Nor do
     end
     [3, 4, 8].each do |n|
       context "with #{n} inputs" do
-        subject { Circuits::Component::Nor.new inputs: n }
+        subject { Circuits::Component::Nor.new input_count: n }
 
         before do
           n.times { |x| subject.inputs[x].set inputs[x] }

data/spec/unit/circuits/component/or_spec.rb

@@ -57,7 +57,7 @@ describe Circuits::Component::Or do
     end
     [3, 4, 8].each do |n|
       context "with #{n} inputs" do
-        subject { Circuits::Component::Or.new inputs: n }
+        subject { Circuits::Component::Or.new input_count: n }
 
         before do
           n.times { |x| subject.inputs[x].set inputs[x] }

data/spec/unit/circuits/component/xnor_spec.rb

@@ -58,7 +58,7 @@ describe Circuits::Component::Xnor do
     context 'when the number of inputs is even' do
       [2, 4, 8].each do |n|
         context "with #{n} inputs" do
-          subject { Circuits::Component::Xnor.new inputs: n }
+          subject { Circuits::Component::Xnor.new input_count: n }
 
           before do
             n.times { |x| subject.inputs[x].set inputs[x] }
@@ -107,7 +107,7 @@ describe Circuits::Component::Xnor do
     context 'when the number of inputs is odd' do
       [3, 5, 7].each do |n|
         context "with #{n} inputs" do
-          subject { Circuits::Component::Xnor.new inputs: n }
+          subject { Circuits::Component::Xnor.new input_count: n }
 
           before do
             n.times { |x| subject.inputs[x].set inputs[x] }

data/spec/unit/circuits/component/xor_spec.rb

@@ -58,7 +58,7 @@ describe Circuits::Component::Xor do
     context 'when the number of inputs is even' do
       [2, 4, 8].each do |n|
         context "with #{n} inputs" do
-          subject { Circuits::Component::Xor.new inputs: n }
+          subject { Circuits::Component::Xor.new input_count: n }
 
           before do
             n.times { |x| subject.inputs[x].set inputs[x] }
@@ -107,7 +107,7 @@ describe Circuits::Component::Xor do
     context 'when the number of inputs is odd' do
       [3, 5, 7].each do |n|
         context "with #{n} inputs" do
-          subject { Circuits::Component::Xor.new inputs: n }
+          subject { Circuits::Component::Xor.new input_count: n }
 
           before do
             n.times { |x| subject.inputs[x].set inputs[x] }

data/spec/unit/circuits/terminal/input_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'circuits/terminal/input'
+
+describe Circuits::Terminal::Input do
+  describe '#get' do
+    context 'when given no state' do
+      subject { Circuits::Terminal::Input.new }
+
+      it 'is false' do
+        expect(subject.get).to eq(false)
+      end
+    end
+  end
+
+  describe '#set' do
+    let(:state) { double('state') }
+
+    context 'when given a state' do
+      subject { Circuits::Terminal::Input.new(state: state) }
+
+      it 'has that state' do
+        subject.set state
+        expect(subject.get).to eq(state)
+      end
+    end
+
+    context 'when given an input' do
+      let(:input) { Circuits::Terminal::Input.new(state: state) }
+
+      subject { Circuits::Terminal::Input.new }
+
+      it 'has the input state' do
+        subject.set input
+        expect(subject.get).to eq(state)
+      end
+    end
+
+    context 'when given an output' do
+      let(:output) { Circuits::Terminal::Output.new(state: state) }
+
+      subject { Circuits::Terminal::Input.new }
+
+      it 'has the output state' do
+        subject.set output
+        expect(subject.get).to eq(state)
+      end
+    end
+  end
+end

data/spec/unit/circuits/terminal/output_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+require 'circuits/terminal/output'
+
+describe Circuits::Terminal::Output do
+  describe '#get' do
+    let(:state) { double('state') }
+
+    context 'when given no state' do
+      subject { Circuits::Terminal::Output.new }
+
+      it 'is false' do
+        expect(subject.get).to eq(false)
+      end
+    end
+
+    context 'when given a state' do
+      subject { Circuits::Terminal::Output.new(state: state) }
+
+      it 'has that state' do
+        expect(subject.get).to eq(state)
+      end
+    end
+
+    context 'when given an input' do
+      let(:input) { Circuits::Terminal::Input.new(state: state) }
+
+      subject { Circuits::Terminal::Output.new(terminal: input) }
+
+      it 'has the input state' do
+        expect(subject.get).to eq(state)
+      end
+    end
+
+    context 'when given an output' do
+      let(:output) { Circuits::Terminal::Output.new(state: state) }
+
+      subject { Circuits::Terminal::Output.new(terminal: output) }
+
+      it 'has the output state' do
+        expect(subject.get).to eq(state)
+      end
+    end
+  end
+
+  describe '#set' do
+    let(:state_1) { double('state_1') }
+    let(:state_2) { double('state_2') }
+
+    subject { Circuits::Terminal::Output.new(state: state_1) }
+
+    context 'when given a state' do
+      it 'gets does not get set immediately' do
+        subject.set state_2
+        expect(subject.get).to eq(state_1)
+      end
+    end
+
+    context 'when given an input' do
+      let(:input) { Circuits::Terminal::Input.new(state: state_2) }
+
+      it 'gets does not get set immediately' do
+        subject.set input
+        expect(subject.get).to eq(state_1)
+      end
+    end
+
+    context 'when given an output' do
+      let(:output) { Circuits::Terminal::Output.new(state: state_2) }
+
+      it 'gets does not get set immediately' do
+        subject.set output
+        expect(subject.get).to eq(state_1)
+      end
+    end
+  end
+
+  describe '#tock' do
+    let(:state_1) { double('state_1') }
+    let(:state_2) { double('state_2') }
+
+    subject { Circuits::Terminal::Output.new(state: state_1) }
+
+    context 'when given a state' do
+      it 'updates the state' do
+        subject.set state_2
+        subject.tock
+        expect(subject.get).to eq(state_2)
+      end
+    end
+
+    context 'when given an input' do
+      let(:input) { Circuits::Terminal::Input.new(state: state_2) }
+
+      it 'updates the state' do
+        subject.set input
+        subject.tock
+        expect(subject.get).to eq(state_2)
+      end
+    end
+
+    context 'when given an output' do
+      let(:output) { Circuits::Terminal::Output.new(state: state_2) }
+
+      it 'updates the state' do
+        subject.set output
+        subject.tock
+        expect(subject.get).to eq(state_2)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: circuits
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Henry Muru Paenga
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-27 00:00:00.000000000 Z
+date: 2015-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -148,6 +148,8 @@ files:
 - spec/unit/circuits/component/sr_nor_spec.rb
 - spec/unit/circuits/component/xnor_spec.rb
 - spec/unit/circuits/component/xor_spec.rb
+- spec/unit/circuits/terminal/input_spec.rb
+- spec/unit/circuits/terminal/output_spec.rb
 homepage: https://github.com/meringu/circuits
 licenses:
 - MIT
@@ -184,3 +186,5 @@ test_files:
 - spec/unit/circuits/component/sr_nor_spec.rb
 - spec/unit/circuits/component/xnor_spec.rb
 - spec/unit/circuits/component/xor_spec.rb
+- spec/unit/circuits/terminal/input_spec.rb
+- spec/unit/circuits/terminal/output_spec.rb