modbus-cli 0.0.4 → 0.0.5

data/lib/modbus-cli/commands_common.rb

@@ -37,6 +37,10 @@ module Modbus
           end
         end
 
+        def host_option
+          option ["-p", "--port"], 'PORT', "use TCP port", :default => 502
+        end
+
         def output_option
         end
       end

data/lib/modbus-cli/dump_command.rb

@@ -12,6 +12,7 @@ module Modbus
           YAML.load_file(filename).dup.tap do |ff|
             #parameter takes presedence
             ff[:host] = host || ff[:host]
+            ff[:port] = port || ff[:port]
             ff[:slave] = slave || ff[:slave]
             ff[:offset] = offset || ff[:offset]
           end
@@ -19,6 +20,7 @@ module Modbus
       end
 
       option ["-h", "--host"], 'ADDR', "use the address/hostname ADDR instead of the stored one"
+      host_option
 
       option ["-s", "--slave"], 'ID', "use slave ID instead of the stored one" do |s|
         Integer(s).tap {|slave| raise ArgumentError 'Slave address should be in the range 0..255' unless (0..255).member? slave }
@@ -36,7 +38,7 @@ module Modbus
 
       def execute_host(host_id)
         slave_ids =   files.select {|d| d[:host] == host_id }.map {|d| d[:slave] }.sort.uniq
-        ModBus::TCPClient.connect(host_id) do |client|
+        ModBus::TCPClient.connect(host_id, port) do |client|
           slave_ids.each {|slave_id| execute_slave host_id, slave_id, client }
         end
       end

data/lib/modbus-cli/read_command.rb

@@ -14,6 +14,7 @@ module Modbus
       format_options
       slave_option
       host_parameter
+      host_option
       address_parameter
       option ["-o", "--output"], 'FILE', "write results to file FILE"
       
@@ -58,7 +59,7 @@ module Modbus
 
       def write_data_to_file(data)
         File.open(output, 'w') do |file|
-          file.puts({ :host => host, :slave => slave, :offset => address_to_s(addr_offset, :modicon), :data => data }.to_yaml)
+          file.puts({ :host => host, :port => port, :slave => slave, :offset => address_to_s(addr_offset, :modicon), :data => data }.to_yaml)
         end
       end
 
@@ -70,7 +71,7 @@ module Modbus
       end
 
       def execute
-        ModBus::TCPClient.connect(host) do |cl|
+        ModBus::TCPClient.connect(host, port) do |cl|
           cl.with_slave(slave) do |sl|
             if output then
               case addr_type

data/lib/modbus-cli/version.rb

@@ -1,5 +1,5 @@
 module Modbus
   module Cli
-    VERSION = "0.0.4"
+    VERSION = "0.0.5"
   end
 end

data/lib/modbus-cli/write_command.rb

@@ -11,6 +11,7 @@ module Modbus
       format_options
       slave_option
       host_parameter
+      host_option
       address_parameter
 
       parameter 'VALUES ...', 'values to write, nonzero counts as true for discrete values', :attribute_name => :values do |vv|
@@ -32,7 +33,7 @@ module Modbus
 
 
       def execute
-        ModBus::TCPClient.connect(host) do |cl|
+        ModBus::TCPClient.connect(host, port) do |cl|
           cl.with_slave(slave) do |sl|
             case addr_type
             when :bit

data/spec/dump_command_spec.rb

@@ -10,8 +10,8 @@ describe Modbus::Cli::DumpCommand do
   it 'reads the file and write the contents to the original device' do
     client = mock 'client'
     slave = mock 'slave'
-    YAML.should_receive(:load_file).with('dump.yml').and_return(:host => '1.2.3.4', :slave => 5, :offset => 400123, :data => [4, 5, 6])
-    ModBus::TCPClient.should_receive(:connect).with('1.2.3.4').and_yield(client)
+    YAML.should_receive(:load_file).with('dump.yml').and_return(:host => '1.2.3.4', :port => 502, :slave => 5, :offset => 400123, :data => [4, 5, 6])
+    ModBus::TCPClient.should_receive(:connect).with('1.2.3.4', 502).and_yield(client)
     client.should_receive(:with_slave).with(5).and_yield(slave)
     slave.should_receive(:write_holding_registers).with(122, [4, 5, 6])
     cmd.run %w(dump dump.yml)
@@ -25,8 +25,8 @@ describe Modbus::Cli::DumpCommand do
     yml = {:host => 'X', :slave => 5, :offset => 400010, :data => [99]}
     YAML.should_receive(:load_file).with('a.yml').and_return(yml)
     YAML.should_receive(:load_file).with('b.yml').and_return(yml.dup.tap {|y| y[:host] = 'Y' })
-    ModBus::TCPClient.should_receive(:connect).with('X').and_yield(client1)
-    ModBus::TCPClient.should_receive(:connect).with('Y').and_yield(client2)
+    ModBus::TCPClient.should_receive(:connect).with('X', 502).and_yield(client1)
+    ModBus::TCPClient.should_receive(:connect).with('Y', 502).and_yield(client2)
     client1.should_receive(:with_slave).with(5).and_yield(slave1)
     client2.should_receive(:with_slave).with(5).and_yield(slave2)
     slave1.should_receive(:write_holding_registers).with(9, [99])
@@ -41,7 +41,7 @@ describe Modbus::Cli::DumpCommand do
     yml = {:host => 'X', :slave => 5, :offset => 400010, :data => [99]}
     YAML.should_receive(:load_file).with('a.yml').and_return(yml)
     YAML.should_receive(:load_file).with('b.yml').and_return(yml.dup.tap {|y| y[:slave] = 99 })
-    ModBus::TCPClient.should_receive(:connect).with('X').and_yield(client1)
+    ModBus::TCPClient.should_receive(:connect).with('X', 502).and_yield(client1)
     client1.should_receive(:with_slave).with(5).and_yield(slave1)
     client1.should_receive(:with_slave).with(99).and_yield(slave2)
     slave1.should_receive(:write_holding_registers).with(9, [99])
@@ -55,7 +55,7 @@ describe Modbus::Cli::DumpCommand do
     yml = {:host => 'X', :slave => 5, :offset => 400010, :data => [99]}
     YAML.should_receive(:load_file).with('a.yml').and_return(yml)
     YAML.should_receive(:load_file).with('b.yml').and_return(yml.dup)
-    ModBus::TCPClient.should_receive(:connect).with('X').and_yield(client1)
+    ModBus::TCPClient.should_receive(:connect).with('X', 502).and_yield(client1)
     client1.should_receive(:with_slave).with(5).and_yield(slave1)
     slave1.should_receive(:write_holding_registers).with(9, [99])
     slave1.should_receive(:write_holding_registers).with(9, [99])
@@ -63,15 +63,15 @@ describe Modbus::Cli::DumpCommand do
   end
 
   it 'accepts the --host <hostname> parameter' do
-    YAML.should_receive(:load_file).with('dump.yml').and_return(:host => '1.2.3.4', :slave => 5, :offset => 123, :data => [4, 5, 6])
-    ModBus::TCPClient.should_receive(:connect).with('Y')
+    YAML.should_receive(:load_file).with('dump.yml').and_return(:host => '1.2.3.4', :port => 502, :slave => 5, :offset => 123, :data => [4, 5, 6])
+    ModBus::TCPClient.should_receive(:connect).with('Y', 502)
     cmd.run %w(dump --host Y dump.yml)
   end
 
   it 'accepts the --slave <id> parameter' do
     client = mock 'client'
-    YAML.should_receive(:load_file).with('dump.yml').and_return(:host => '1.2.3.4', :slave => 5, :offset => 123, :data => [4, 5, 6])
-    ModBus::TCPClient.should_receive(:connect).with('1.2.3.4').and_yield(client)
+    YAML.should_receive(:load_file).with('dump.yml').and_return(:host => '1.2.3.4', :port => 502, :slave => 5, :offset => 123, :data => [4, 5, 6])
+    ModBus::TCPClient.should_receive(:connect).with('1.2.3.4', 502).and_yield(client)
     client.should_receive(:with_slave).with(99)
     cmd.run %w(dump --slave 99 dump.yml)
   end
@@ -79,8 +79,8 @@ describe Modbus::Cli::DumpCommand do
   it 'accepts the --offset <n> parameter with modicon addressing' do
     client = mock 'client'
     slave = mock 'slave'
-    YAML.should_receive(:load_file).with('dump.yml').and_return(:host => '1.2.3.4', :slave => 5, :offset => 123, :data => [4, 5, 6])
-    ModBus::TCPClient.should_receive(:connect).with('1.2.3.4').and_yield(client)
+    YAML.should_receive(:load_file).with('dump.yml').and_return(:host => '1.2.3.4', :port => 502, :slave => 5, :offset => 123, :data => [4, 5, 6])
+    ModBus::TCPClient.should_receive(:connect).with('1.2.3.4', 502).and_yield(client)
     client.should_receive(:with_slave).with(5).and_yield(slave)
     slave.should_receive(:write_holding_registers).with(100, [4, 5, 6])
     cmd.run %w(dump --offset 400101 dump.yml)
@@ -89,8 +89,8 @@ describe Modbus::Cli::DumpCommand do
   it 'accepts the --offset <n> parameter with schneider addressing' do
     client = mock 'client'
     slave = mock 'slave'
-    YAML.should_receive(:load_file).with('dump.yml').and_return(:host => '1.2.3.4', :slave => 5, :offset => 123, :data => [4, 5, 6])
-    ModBus::TCPClient.should_receive(:connect).with('1.2.3.4').and_yield(client)
+    YAML.should_receive(:load_file).with('dump.yml').and_return(:host => '1.2.3.4', :port => 502, :slave => 5, :offset => 123, :data => [4, 5, 6])
+    ModBus::TCPClient.should_receive(:connect).with('1.2.3.4', 502).and_yield(client)
     client.should_receive(:with_slave).with(5).and_yield(slave)
     slave.should_receive(:write_holding_registers).with(100, [4, 5, 6])
     cmd.run %w(dump --offset %MW100 dump.yml)

data/spec/read_command_spec.rb

@@ -11,7 +11,7 @@ describe Modbus::Cli::ReadCommand do
   end
 
   it 'can read registers' do
-    client, slave = standard_connect_helper '1.2.3.4'
+    client, slave = standard_connect_helper '1.2.3.4', 502
     slave.should_receive(:read_holding_registers).with(100, 10).and_return((0..9).to_a)
     cmd.run %w(read 1.2.3.4 %MW100 10)
     stdout.should match(/^\s*%MW105\s*5$/)
@@ -20,28 +20,28 @@ describe Modbus::Cli::ReadCommand do
 
 
   it 'can read floating point numbers' do
-    client, slave = standard_connect_helper '1.2.3.4'
+    client, slave = standard_connect_helper '1.2.3.4', 502
     slave.should_receive(:read_holding_registers).with(100, 4).and_return([52429, 17095, 52429, 17095])
     cmd.run %w(read 1.2.3.4 %MF100 2)
     stdout.should match(/^\s*%MF102\s*99[.]9(00[0-9]*)?$/)
   end
 
   it 'should display numbers with good precision' do
-    client, slave = standard_connect_helper '1.2.3.4'
+    client, slave = standard_connect_helper '1.2.3.4', 502
     slave.should_receive(:read_holding_registers).and_return([1049, 16286])
     cmd.run %w(read 1.2.3.4 %MF100 1)
     stdout.should match(/^\s*%MF100\s*1[.]2345\d*$/)
   end
 
   it 'can read double word numbers' do
-    client, slave = standard_connect_helper '1.2.3.4'
+    client, slave = standard_connect_helper '1.2.3.4', 502
     slave.should_receive(:read_holding_registers).with(100, 4).and_return([16959, 15, 16959, 15])
     cmd.run %w(read 1.2.3.4 %MD100 2)
     stdout.should match(/^\s*%MD102\s*999999$/)
   end
 
   it 'can read coils' do
-    client, slave = standard_connect_helper '1.2.3.4'
+    client, slave = standard_connect_helper '1.2.3.4', 502
     slave.should_receive(:read_coils).with(100, 10).and_return([1, 0] * 5)
     cmd.run %w(read 1.2.3.4 %M100 10)
     stdout.should match(/^\s*%M105\s*0$/)
@@ -61,53 +61,53 @@ describe Modbus::Cli::ReadCommand do
   end
 
   it 'should split large reads into smaller chunks for words' do
-    client, slave = standard_connect_helper '1.2.3.4'
+    client, slave = standard_connect_helper '1.2.3.4', 502
     slave.should_receive(:read_holding_registers).with(100, 125).and_return([1, 0] * 1000)
     slave.should_receive(:read_holding_registers).with(225, 25).and_return([1, 0] * 1000)
     cmd.run %w(read 1.2.3.4 %MW100 150)
   end
 
   it 'should split large reads into smaller chunks for coils' do
-    client, slave = standard_connect_helper '1.2.3.4'
+    client, slave = standard_connect_helper '1.2.3.4', 502
     slave.should_receive(:read_coils).with(100, 2000).and_return([1, 0] * 1000)
     slave.should_receive(:read_coils).with(2100, 1000).and_return([1, 0] * 500)
     cmd.run %w(read 1.2.3.4 %M100 3000)
   end
 
   it 'can read registers as ints' do
-    client, slave = standard_connect_helper '1.2.3.4'
+    client, slave = standard_connect_helper '1.2.3.4', 502
     slave.should_receive(:read_holding_registers).with(100, 1).and_return([0xffff])
     cmd.run %w(read --int 1.2.3.4 %MW100 1)
     stdout.should match(/^\s*%MW100\s*-1$/)
   end
 
   it 'can read registers as floats' do
-    client, slave = standard_connect_helper '1.2.3.4'
+    client, slave = standard_connect_helper '1.2.3.4', 502
     slave.should_receive(:read_holding_registers).with(100, 2).and_return([0,0])
     cmd.run %w(read --float 1.2.3.4 %MW100 1)
   end
 
   it 'can read registers as dwords' do
-    client, slave = standard_connect_helper '1.2.3.4'
+    client, slave = standard_connect_helper '1.2.3.4', 502
     slave.should_receive(:read_holding_registers).with(100, 2).and_return([0,0])
     cmd.run %w(read --dword 1.2.3.4 %MW100 1)
   end
 
   it 'can read registers as words' do
-    client, slave = standard_connect_helper '1.2.3.4'
+    client, slave = standard_connect_helper '1.2.3.4', 502
     slave.should_receive(:read_holding_registers).with(100, 1).and_return([0])
     cmd.run %w(read --word 1.2.3.4 %MD100 1)
   end
 
   it 'accepts Modicon addresses for coils' do
-    client, slave = standard_connect_helper '1.2.3.4'
+    client, slave = standard_connect_helper '1.2.3.4', 502
     slave.should_receive(:read_coils).with(100, 10).and_return([1, 0] * 5)
     cmd.run %w(read 1.2.3.4 101 10)
     stdout.should match(/^\s*106\s*0$/)
   end
 
   it 'accepts Modicon addresses for registers' do
-    client, slave = standard_connect_helper '1.2.3.4'
+    client, slave = standard_connect_helper '1.2.3.4', 502
     slave.should_receive(:read_holding_registers).with(100, 10).and_return((0..9).to_a)
     cmd.run %w(read 1.2.3.4 400101 10)
     stdout.should match(/^\s*400106\s*5$/)
@@ -115,14 +115,14 @@ describe Modbus::Cli::ReadCommand do
 
 
   it 'should accept the --modicon option to force modicon output' do
-    client, slave = standard_connect_helper '1.2.3.4'
+    client, slave = standard_connect_helper '1.2.3.4', 502
     slave.should_receive(:read_holding_registers).with(100, 10).and_return((0..9).to_a)
     cmd.run %w(read --modicon 1.2.3.4 %MW100 10)
     stdout.should match(/^\s*400106\s*5$/)
   end
 
   it 'should accept the --schneider option to force schneider output' do 
-    client, slave = standard_connect_helper '1.2.3.4'
+    client, slave = standard_connect_helper '1.2.3.4', 502
     slave.should_receive(:read_holding_registers).with(100, 10).and_return((0..9).to_a)
     cmd.run %w(read --schneider 1.2.3.4 400101 10)
     stdout.should match(/^\s*%MW105\s*5$/)
@@ -130,27 +130,27 @@ describe Modbus::Cli::ReadCommand do
 
   it 'has a --slave parameter' do
     client = mock 'client'
-    ModBus::TCPClient.should_receive(:connect).with('X').and_yield(client)
+    ModBus::TCPClient.should_receive(:connect).with('X', 502).and_yield(client)
     client.should_receive(:with_slave).with(99)
     cmd.run %w(read --slave 99 X 101 1)
   end
 
   it 'can write the output from reading registers to a yaml file using the -o <filename> parameter' do
-    client, slave = standard_connect_helper '1.2.3.4'
+    client, slave = standard_connect_helper '1.2.3.4', 502
     slave.should_receive(:read_holding_registers).with(100, 1).and_return([1])
     file_mock = mock('file')
     File.should_receive(:open).and_yield(file_mock)
-    file_mock.should_receive(:puts).with({:host => '1.2.3.4', :slave => 1, :offset => '400101', :data => [1]}.to_yaml)
+    file_mock.should_receive(:puts).with({:host => '1.2.3.4', :port => 502, :slave => 1, :offset => '400101', :data => [1]}.to_yaml)
     cmd.run %w(read --output filename.yml 1.2.3.4 %MW100 1)
     stdout.should_not match(/./)
   end
 
   it 'can write the output from reading coils to a yaml file using the -o <filename> parameter' do
-    client, slave = standard_connect_helper '1.2.3.4'
+    client, slave = standard_connect_helper '1.2.3.4', 502
     slave.should_receive(:read_coils).with(100, 1).and_return([1])
     file_mock = mock('file')
     File.should_receive(:open).and_yield(file_mock)
-    file_mock.should_receive(:puts).with({:host => '1.2.3.4', :slave => 1, :offset => '101', :data => [1]}.to_yaml)
+    file_mock.should_receive(:puts).with({:host => '1.2.3.4', :port => 502, :slave => 1, :offset => '101', :data => [1]}.to_yaml)
     cmd.run %w(read --output filename.yml 1.2.3.4 %M100 1)
     stdout.should_not match(/./)
   end

data/spec/spec_helper.rb

@@ -34,10 +34,10 @@ def stub_tcpip
 end
 
 
-def standard_connect_helper(address)
+def standard_connect_helper(address, port)
   client = mock 'client'
   slave = mock 'slave'
-  ModBus::TCPClient.should_receive(:connect).with(address).and_yield(client)
+  ModBus::TCPClient.should_receive(:connect).with(address, port).and_yield(client)
   client.should_receive(:with_slave).with(1).and_yield(slave)
   return client, slave
 end

data/spec/write_command_spec.rb

@@ -10,26 +10,26 @@ describe Modbus::Cli::WriteCommand do
   end
 
   it 'can write to registers' do
-    client, slave = standard_connect_helper 'HOST'
+    client, slave = standard_connect_helper 'HOST', 502
     slave.should_receive(:write_holding_registers).with(100, [1, 2, 3, 4])
     cmd.run %w(write HOST %MW100 1 2 3 4)
   end
 
 
   it 'can write floating point numbers' do
-    client, slave = standard_connect_helper 'HOST'
+    client, slave = standard_connect_helper 'HOST', 502
     slave.should_receive(:write_holding_registers).with(100, [52429, 17095, 52429, 17095])
     cmd.run %w(write HOST %MF100 99.9 99.9)
   end
 
   it 'can write double word numbers' do
-    client, slave = standard_connect_helper 'HOST'
+    client, slave = standard_connect_helper 'HOST', 502
     slave.should_receive(:write_holding_registers).with(100, [16959, 15, 16959, 15])
     cmd.run %w(write HOST %MD100 999999 999999)
   end
 
   it 'can write to coils' do
-    client, slave = standard_connect_helper 'HOST'
+    client, slave = standard_connect_helper 'HOST', 502
     slave.should_receive(:write_multiple_coils).with(100, [1, 0, 1, 0, 1, 0, 0, 1, 1])
     cmd.run %w(write HOST %M100 1 0 1 0 1 0 0 1 1)
   end
@@ -45,58 +45,58 @@ describe Modbus::Cli::WriteCommand do
 
 
   it 'should split large writes in chunks for words' do
-    client, slave = standard_connect_helper 'HOST'
+    client, slave = standard_connect_helper 'HOST', 502
     slave.should_receive(:write_holding_registers).with(100, (1..123).to_a)
     slave.should_receive(:write_holding_registers).with(223, (124..150).to_a)
     cmd.run %w(write HOST %MW100) + (1..150).to_a
   end
 
   it 'should split large writes in chunks for coils' do
-    client, slave = standard_connect_helper 'HOST'
+    client, slave = standard_connect_helper 'HOST', 502
     slave.should_receive(:write_multiple_coils).with(100, [0, 1] * 984)
     slave.should_receive(:write_multiple_coils).with(2068, [0, 1] * 16)
     cmd.run %w(write HOST %M100) + [0, 1] * 1000
   end
 
   it 'can write to registers as ints' do
-    client, slave = standard_connect_helper 'HOST'
+    client, slave = standard_connect_helper 'HOST', 502
     slave.should_receive(:write_holding_registers).with(100, [0xffff])
     cmd.run %w(write --int HOST %MW100 -1)
   end
 
   it 'can write to registers as floats' do
-    client, slave = standard_connect_helper 'HOST'
+    client, slave = standard_connect_helper 'HOST', 502
     slave.should_receive(:write_holding_registers).with(100, [52429, 17095])
     cmd.run %w(write --float HOST %MW100 99.9)
   end
 
   it 'can write to registers as double words' do
-    client, slave = standard_connect_helper 'HOST'
+    client, slave = standard_connect_helper 'HOST', 502
     slave.should_receive(:write_holding_registers).with(100, [16959, 15])
     cmd.run %w(write --dword HOST %MW100 999999)
   end
 
   it 'can write to registers as words' do
-    client, slave = standard_connect_helper 'HOST'
+    client, slave = standard_connect_helper 'HOST', 502
     slave.should_receive(:write_holding_registers).with(100, [99])
     cmd.run %w(write --word HOST %MF100 99)
   end
 
   it 'can write to registers using Modicon addressing' do
-    client, slave = standard_connect_helper 'HOST'
+    client, slave = standard_connect_helper 'HOST', 502
     slave.should_receive(:write_holding_registers).with(100, [1, 2, 3, 4])
     cmd.run %w(write HOST 400101 1 2 3 4)
   end
 
   it 'can write to coils using Modicon addressing' do
-    client, slave = standard_connect_helper 'HOST'
+    client, slave = standard_connect_helper 'HOST', 502
     slave.should_receive(:write_multiple_coils).with(100, [1, 0, 1, 0, 1, 0, 0, 1, 1])
     cmd.run %w(write HOST 101 1 0 1 0 1 0 0 1 1)
   end
 
   it 'has a --slave parameter' do
     client = mock 'client'
-    ModBus::TCPClient.should_receive(:connect).with('X').and_yield(client)
+    ModBus::TCPClient.should_receive(:connect).with('X', 502).and_yield(client)
     client.should_receive(:with_slave).with(99)
     cmd.run %w(write --slave 99 X 101 1)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: modbus-cli
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-02 00:00:00.000000000Z
+date: 2011-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rmodbus
-  requirement: &77908650 !ruby/object:Gem::Requirement
+  requirement: &75774940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '1.1'
   type: :runtime
   prerelease: false
-  version_requirements: *77908650
+  version_requirements: *75774940
 - !ruby/object:Gem::Dependency
   name: clamp
-  requirement: &77908400 !ruby/object:Gem::Requirement
+  requirement: &75774550 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '0.3'
   type: :runtime
   prerelease: false
-  version_requirements: *77908400
+  version_requirements: *75774550
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &77908170 !ruby/object:Gem::Requirement
+  requirement: &75774310 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: '2.7'
   type: :development
   prerelease: false
-  version_requirements: *77908170
+  version_requirements: *75774310
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &77907940 !ruby/object:Gem::Requirement
+  requirement: &75774000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,7 +54,7 @@ dependencies:
         version: '0.9'
   type: :development
   prerelease: false
-  version_requirements: *77907940
+  version_requirements: *75774000
 description: Command line interface to communicate over Modbus TCP
 email:
 - tallak@tveide.net
@@ -106,4 +106,3 @@ signing_key:
 specification_version: 3
 summary: Modbus command line
 test_files: []
-has_rdoc: