circuits 0.10.0 → 0.11.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NWRmNzIwNmQ5NTkxNmIyYmQ4MWM1ZTg4NWE4YzY1ZDBiYzRkMjhhNA==
+    YTQ4YTRjMjcwYmU5OGRiY2MzMzhkNzkxZDNlNDI5MGQ5NWU5YzYwNg==
   data.tar.gz: !binary |-
-    OWZjOGE4YzQ1MWYyOTgzMmRiMzk2MGRmMmU3Njg3ZDFlYTcxN2Q0MA==
+    YjgxYmQ4M2E2MzQ1OTI3ZGI2NDBjZjBlZTc3ZDU0MmViNTU3ZjQxYQ==
 SHA512:
   metadata.gz: !binary |-
-    ODcyZjIwYWIyMjZhZDhlOGM2YTBjYjdkMjljNzFhYmQwYjBlZDE4ZGU5MjZj
-    MzNmMzg3NTFjZTBiNmM3MjUxZTgxNTdkYmEzNjIzNzliZmI4ZTE3YWRmMTBm
-    YTI1NmVmMWMxZDg0ODBlMmNkN2QwN2RmN2ZmMDc3NTcxMjVjNmI=
+    NTY0MzBjODYzMzJjNTRkZmJlMjgxYmY1ZGUyNTdlMzM3NGQ1YWQ5ZjU1YjZk
+    ODQ4MGQwZmE3NjI4MjY5MGZkY2RhYTQxOWUyYzJiOWU5NzJjOWZhMDg4YmU3
+    MjhjOWQ1NzdjNzFlOGM1ZmJjNzhkODg2M2MwMzQ1NTA4MGViZmI=
   data.tar.gz: !binary |-
-    MmQwZjU2NGJjZWE3MzYyYTU3ODFhN2Y2OWY5YmJmN2JhZTNkOGMwNmZhZmI4
-    MzMxYzZiYjQyZTI0NWVlZmUxMjZjZTgxNmQyYzBlYmY4YzEzZDE5ZjcyODMx
-    ZDY5ZTE0YjAzNzRiMDJjNDcxMWY1MWFlZjU3Y2ExYTgxZWNmM2Y=
+    MWVkNTg2Y2E5NDQ1ZDViMjMyMDBlZTQzYmNjZGMzNjRiZTc1YzVjZjc5NDkw
+    MWYwZmE5ZTlkMmYwYzZkNGEwNTQ2YTcxMmY1ZDRmM2MyZWEwYzYxM2QyNTBk
+    ZjNkNmRkZDc4OTQ3ZDQwMDM2NDYzOGIzZjk2NmIxMDc0NTQ5MjQ=

data/lib/circuits/component/and.rb

@@ -4,20 +4,15 @@ module Circuits
   module Component
     # Logical AND Operator
     class And < Base
+      def initialize(opts = {})
+        inputs = opts[:inputs] || 2
+        super(inputs: inputs, outputs: 1)
+      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,15 +10,17 @@ module Circuits
     class Base
       # Creates the Component with inputs and outputs
       # @param opts [Hash] options to create the Component with
-      # @option opts [FixNum] :input_count The number of inputs
-      # @option opts [FixNum] :ouput_count The number of outputs
+      # @option opts [FixNum, Array<Symbol>] :inputs The number of inputs or an
+      # array of their names
+      # @option opts [FixNum, Array<Symbol>] :ouputs The number of outputs or an
+      # array of their names
       # @option opts [Hash] :port_mappings The port_mappings to use
       def initialize(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
+        @inputs = create_inputs opts[:inputs]
+        @outputs = create_outputs opts[:outputs]
+        @port_mappings = create_port_mappings opts
+        @sub_components = opts[:sub_components] || []
+        @ticks = opts[:ticks] || 0
       end
 
       # the inputs of this component
@@ -36,6 +38,14 @@ module Circuits
         res
       end
 
+      # Computes the outputs based on the inputs and previous state
+      def tick
+        @ticks.times.each do
+          @sub_components.each(&:tick)
+          @sub_components.each(&:tock)
+        end
+      end
+
       # Sets all the outputs expose what was set in #tick
       def tock
         outputs.each(&:tock)
@@ -52,7 +62,7 @@ module Circuits
       # @param port [Symbol] The symbol that represents the terminal
       # @return [Input, Output] The terminal
       def [](port)
-        port_mapping = port_mappings[port]
+        port_mapping = @port_mappings[port]
         return nil if port_mapping.nil?
         port_number = port_mapping[:number]
         case port_mapping[:type]
@@ -65,17 +75,33 @@ module Circuits
 
       private
 
-      attr_reader :port_mappings
+      def create_inputs(inputs)
+        input_count = inputs.class == Fixnum ? inputs : inputs.length
+        input_count.times.map { Circuits::Terminal::Input.new }
+      end
+
+      def create_outputs(outputs)
+        output_count = outputs.class == Fixnum ? outputs : outputs.length
+        output_count.times.map { Circuits::Terminal::Output.new }
+      end
 
-      def default_port_mappings
+      def create_port_mappings(opts = {})
         res = {}
-        (input_mappings + output_mappings).each do |mapping|
+        (input_mappings(opts[:inputs]) +
+         output_mappings(opts[:outputs])).each do |mapping|
           res.merge!(mapping)
         end
         res
       end
 
-      def input_mappings
+      def input_mappings(input_names)
+        return default_input_mappings unless input_names.class == Array
+        input_names.map.each_with_index do |input_name, num|
+          { input_name => { type: :input, number: num } }
+        end
+      end
+
+      def default_input_mappings
         input_count = inputs.length
         return [{ in: { type: :input, number: 0 } }] if input_count == 1
         input_count.times.collect do |num|
@@ -83,7 +109,14 @@ module Circuits
         end
       end
 
-      def output_mappings
+      def output_mappings(output_names)
+        return default_output_mappings unless output_names.class == Array
+        output_names.map.each_with_index do |output_name, num|
+          { output_name => { type: :output, number: num } }
+        end
+      end
+
+      def default_output_mappings
         output_count = outputs.length
         return[{ out: { type: :output, number: 0 } }] if output_count == 1
         output_count.times.collect do |num|

data/lib/circuits/component/d.rb

@@ -1,80 +1,58 @@
 require 'circuits/component/base'
-require 'circuits/component/nand'
+require 'circuits/component/and'
+require 'circuits/component/sr_nand'
 
 module Circuits
   module Component
     # Positive edge triggered D-type flip flop
     class D < Base
       def initialize
-        super(port_mappings: { d: { type: :input, number: 0 },
-                               clk: { type: :input, number: 1 },
-                               q: { type: :output, number: 0 },
-                               not_q: { type: :output, number: 1 } })
-        create_sub_components
-        link_sub_components
+        sub_components = create_sub_components
+        super(inputs: [:d, :clk], outputs: [:q, :not_q],
+              sub_components: sub_components.map { |_, v| v },
+              ticks: 4)
+        link sub_components
         reset
       end
 
-      # Computes the outputs based on the inputs and previous state
-      def tick
-        3.times.each do
-          sub_components.each(&:tick)
-          sub_components.each(&:tock)
-        end
-      end
-
       private
 
-      attr_reader :and_gate, :sr_nand_clk, :sr_nand_d, :sr_nand_out,
-                  :sub_components
-
       def create_sub_components
-        @and_gate = Circuits::Component::And.new
-        @sr_nand_clk = Circuits::Component::SrNand.new
-        @sr_nand_d = Circuits::Component::SrNand.new
-        @sr_nand_out = Circuits::Component::SrNand.new
-        @sub_components = [@and_gate, @sr_nand_clk, @sr_nand_d, @sr_nand_out]
-      end
-
-      def default_input_count
-        2
-      end
-
-      def default_output_count
-        2
-      end
-
-      def link_and_gate
-        and_gate[:a].set sr_nand_clk[:not_q]
-        and_gate[:b].set self[:clk]
+        {
+          and_gate: Circuits::Component::And.new,
+          sr_nand_clk: Circuits::Component::SrNand.new,
+          sr_nand_d: Circuits::Component::SrNand.new,
+          sr_nand_out: Circuits::Component::SrNand.new
+        }
       end
 
-      def link_outputs
-        self[:q].set sr_nand_out[:q]
-        self[:not_q].set sr_nand_out[:not_q]
+      def link(sub_components)
+        link_and_gate sub_components
+        link_sr_nand_clk sub_components
+        link_sr_nand_d sub_components
+        link_sr_nand_out sub_components
+        q.set sub_components[:sr_nand_out].q
+        not_q.set sub_components[:sr_nand_out].not_q
       end
 
-      def link_sr_nand_d
-        sr_nand_d[:not_s].set and_gate[:out]
-        sr_nand_d[:not_r].set self[:d]
+      def link_and_gate(sc)
+        sc[:and_gate].a.set sc[:sr_nand_clk].not_q
+        sc[:and_gate].b.set clk
       end
 
-      def link_sr_nand_clk
-        sr_nand_clk[:not_s].set sr_nand_d[:not_q]
-        sr_nand_clk[:not_r].set self[:clk]
+      def link_sr_nand_clk(sc)
+        sc[:sr_nand_clk].not_s.set sc[:sr_nand_d].not_q
+        sc[:sr_nand_clk].not_r.set clk
       end
 
-      def link_sr_nand_out
-        sr_nand_out[:not_s].set sr_nand_clk[:not_q]
-        sr_nand_out[:not_r].set sr_nand_d[:q]
+      def link_sr_nand_d(sc)
+        sc[:sr_nand_d].not_s.set sc[:and_gate].out
+        sc[:sr_nand_d].not_r.set d
       end
 
-      def link_sub_components
-        link_outputs
-        link_and_gate
-        link_sr_nand_d
-        link_sr_nand_clk
-        link_sr_nand_out
+      def link_sr_nand_out(sc)
+        sc[:sr_nand_out].not_s.set sc[:sr_nand_clk].not_q
+        sc[:sr_nand_out].not_r.set sc[:sr_nand_d].q
       end
 
       def reset

data/lib/circuits/component/nand.rb

@@ -4,20 +4,15 @@ module Circuits
   module Component
     # Logical NAND Operator
     class Nand < Base
+      def initialize(opts = {})
+        inputs = opts[:inputs] || 2
+        super(inputs: inputs, outputs: 1)
+      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,20 +4,15 @@ module Circuits
   module Component
     # Logical NOR Operator
     class Nor < Base
+      def initialize(opts = {})
+        inputs = opts[:inputs] || 2
+        super(inputs: inputs, outputs: 1)
+      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,19 +4,13 @@ module Circuits
   module Component
     # Logical NOT Operator
     class Not < Base
-      # Sets the output to be the result of a logical NOT of the inputs
-      def tick
-        self[:out].set(!self[:in].get)
+      def initialize
+        super(inputs: 1, outputs: 1)
       end
 
-      private
-
-      def default_input_count
-        1
-      end
-
-      def default_output_count
-        1
+      # Sets the output to be the result of a logical NOT of the inputs
+      def tick
+        out.set(!self[:in].get)
       end
     end
   end

data/lib/circuits/component/or.rb

@@ -4,20 +4,15 @@ module Circuits
   module Component
     # Logical OR Operator
     class Or < Base
+      def initialize(opts = {})
+        inputs = opts[:inputs] || 2
+        super(inputs: inputs, outputs: 1)
+      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

@@ -6,67 +6,40 @@ module Circuits
     # SR NAND Latch
     class SrNand < Base
       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_sub_components
+        nand_s = Nand.new
+        nand_r = Nand.new
+        super(inputs: [:not_s, :not_r],
+              outputs: [:q, :not_q],
+              sub_components: [nand_s, nand_r],
+              ticks: 2)
+        link nand_s, nand_r
         reset
       end
 
-      # Computes the outputs based on the inputs and previous state
-      def tick
-        2.times.each do
-          sub_components.each(&:tick)
-          sub_components.each(&:tock)
-        end
-      end
-
       private
 
-      attr_reader :nand_s, :nand_r, :sub_components
-
-      def create_sub_components
-        @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_nand_r
-        nand_r[:a].set self[:not_r]
-        nand_r[:b].set nand_s[:out]
-      end
-
-      def link_nand_s
-        nand_s[:a].set self[:not_s]
-        nand_s[:b].set nand_r[:out]
+      def link(nand_s, nand_r)
+        link_nand_s nand_s, nand_r
+        link_nand_r nand_s, nand_r
+        q.set nand_s.out
+        not_q.set nand_r.out
       end
 
-      def link_outputs
-        self[:q].set nand_s[:out]
-        self[:not_q].set nand_r[:out]
+      def link_nand_s(nand_s, nand_r)
+        nand_s.a.set not_s
+        nand_s.b.set nand_r.out
       end
 
-      def link_sub_components
-        link_nand_s
-        link_nand_r
-        link_outputs
+      def link_nand_r(nand_s, nand_r)
+        nand_r.a.set not_r
+        nand_r.b.set nand_s.out
       end
 
       def reset
-        self[:not_s].set true
+        not_s.set true
         tick
         tock
-        self[:not_r].set true
+        not_r.set true
       end
     end
   end

data/lib/circuits/component/sr_nor.rb

@@ -6,67 +6,40 @@ module Circuits
     # SR NOR Latch
     class SrNor < Base
       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_sub_components
+        nor_s = Nor.new
+        nor_r = Nor.new
+        super(inputs: [:r, :s],
+              outputs: [:q, :not_q],
+              sub_components: [nor_s, nor_r],
+              ticks: 2)
+        link nor_s, nor_r
         reset
       end
 
-      # Computes the outputs based on the inputs and previous state
-      def tick
-        2.times.each do
-          sub_components.each(&:tick)
-          sub_components.each(&:tock)
-        end
-      end
-
       private
 
-      attr_reader :nor_r, :nor_s, :sub_components
-
-      def create_sub_components
-        @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_nor_r
-        nor_r[:a].set self[:r]
-        nor_r[:b].set nor_s[:out]
-      end
-
-      def link_nor_s
-        nor_s[:a].set self[:s]
-        nor_s[:b].set nor_r[:out]
+      def link(nor_s, nor_r)
+        link_nor_s nor_s, nor_r
+        link_nor_r nor_s, nor_r
+        q.set nor_r.out
+        not_q.set nor_s.out
       end
 
-      def link_outputs
-        self[:q].set nor_r[:out]
-        self[:not_q].set nor_s[:out]
+      def link_nor_s(nor_s, nor_r)
+        nor_s.a.set s
+        nor_s.b.set nor_r.out
       end
 
-      def link_sub_components
-        link_nor_s
-        link_nor_r
-        link_outputs
+      def link_nor_r(nor_s, nor_r)
+        nor_r.a.set r
+        nor_r.b.set nor_s.out
       end
 
       def reset
-        self[:r].set true
+        r.set true
         tick
         tock
-        self[:r].set false
+        r.set false
       end
     end
   end

data/lib/circuits/component/xnor.rb

@@ -4,20 +4,15 @@ module Circuits
   module Component
     # Logical XNOR Operator
     class Xnor < Base
+      def initialize(opts = {})
+        inputs = opts[:inputs] || 2
+        super(inputs: inputs, outputs: 1)
+      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,20 +4,15 @@ module Circuits
   module Component
     # Logical XOR Operator
     class Xor < Base
+      def initialize(opts = {})
+        inputs = opts[:inputs] || 2
+        super(inputs: inputs, outputs: 1)
+      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/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.10.0'
+  VERSION = '0.11.0'
 end

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

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

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

@@ -1,32 +1,10 @@
 require 'spec_helper'
 require 'circuits/component/base'
 
-# Mock component to include Circuits::Component::Base
-class MockComponent1 < Circuits::Component::Base
-  def default_input_count
-    1
-  end
-
-  def default_output_count
-    1
-  end
-end
-
-# Mock component to include Circuits::Component::Base
-class MockComponent2 < Circuits::Component::Base
-  def default_input_count
-    2
-  end
-
-  def default_output_count
-    2
-  end
-end
-
 describe Circuits::Component::Base do
   describe '#[]' do
     context 'one input and one output' do
-      subject { MockComponent1.new }
+      subject { Circuits::Component::Base.new(inputs: 1, outputs: 1) }
 
       it 'has the input available as #in' do
         expect(subject[:in]).to eq(subject.inputs[0])
@@ -62,7 +40,7 @@ describe Circuits::Component::Base do
     end
 
     context 'two inputs and two outputs' do
-      subject { MockComponent2.new }
+      subject { Circuits::Component::Base.new(inputs: 2, outputs: 2) }
 
       it 'has the inputs available as #a and #b' do
         expect(subject.a).to eq(subject.inputs[0])

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

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

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

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

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

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

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

@@ -50,7 +50,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 input_count: n }
+          subject { Circuits::Component::Xnor.new inputs: n }
 
           before do
             n.times { |x| subject.inputs[x].set inputs[x] }
@@ -99,7 +99,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 input_count: n }
+          subject { Circuits::Component::Xnor.new inputs: n }
 
           before do
             n.times { |x| subject.inputs[x].set inputs[x] }

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

@@ -50,7 +50,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 input_count: n }
+          subject { Circuits::Component::Xor.new inputs: n }
 
           before do
             n.times { |x| subject.inputs[x].set inputs[x] }
@@ -99,7 +99,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 input_count: n }
+          subject { Circuits::Component::Xor.new inputs: n }
 
           before do
             n.times { |x| subject.inputs[x].set inputs[x] }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: circuits
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Henry Muru Paenga
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-29 00:00:00.000000000 Z
+date: 2015-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler