Merge pull request #48 from opus-codium/rubocop

Author: smortex

.rubocop.yml

@@ -7,6 +7,10 @@ AllCops:
     - tmp/**/*.rb
     - vendor/bundle/**/*
 
+plugins:
+  - rubocop-rake
+  - rubocop-rspec
+
 Layout/HashAlignment:
   EnforcedColonStyle: table
   EnforcedHashRocketStyle: table
@@ -26,6 +30,16 @@ Metrics/ModuleLength:
   Exclude:
     - spec/**/*.rb
 
+RSpec/ExampleLength:
+  Max: 50
+
+RSpec/MultipleExpectations:
+  Max: 10
+
+RSpec/SpecFilePathFormat:
+  Exclude:
+    - spec/core_ext_spec.rb
+
 Style/Documentation:
   Exclude:
     - features/support/env.rb

Rakefile

@@ -22,9 +22,11 @@ task test: %i[spec features]
 
 task default: :test
 
+# rubocop:disable Rake/Desc
 task feature: :gen_parser
 task build: :gen_parser
 task spec: :gen_parser
+# rubocop:enable Rake/Desc
 
 desc 'Generate the puffy language parser'
 task gen_parser: 'lib/puffy/parser.tab.rb'

spec/core_ext_spec.rb

@@ -6,48 +6,53 @@
   describe '#expand' do
     describe 'No expansion' do
       subject { { a: :b }.expand }
+
       it { is_expected.to eq([{ a: :b }]) }
     end
 
     describe 'Single expansion' do
-      subject { { a: %i[b c] }.expand }
+      subject(:expanded_hash) { { a: %i[b c] }.expand }
+
       it do
-        is_expected.to eq([
-                            { a: :b },
-                            { a: :c },
-                          ])
+        expect(expanded_hash).to eq([
+                                      { a: :b },
+                                      { a: :c },
+                                    ])
       end
     end
 
     describe 'Multiple expansions' do
-      subject { { a: %i[b c], d: %i[e f] }.expand }
+      subject(:expanded_hash) { { a: %i[b c], d: %i[e f] }.expand }
+
       it do
-        is_expected.to eq([
-                            { a: :b, d: :e },
-                            { a: :c, d: :e },
-                            { a: :b, d: :f },
-                            { a: :c, d: :f },
-                          ])
+        expect(expanded_hash).to eq([
+                                      { a: :b, d: :e },
+                                      { a: :c, d: :e },
+                                      { a: :b, d: :f },
+                                      { a: :c, d: :f },
+                                    ])
       end
     end
 
     describe 'Nested Array expansions' do
-      subject { { a: [{ b: { c: %i[d e] } }] }.expand }
+      subject(:expanded_hash) { { a: [{ b: { c: %i[d e] } }] }.expand }
+
       it do
-        is_expected.to eq([
-                            { a: { b: { c: :d } } },
-                            { a: { b: { c: :e } } },
-                          ])
+        expect(expanded_hash).to eq([
+                                      { a: { b: { c: :d } } },
+                                      { a: { b: { c: :e } } },
+                                    ])
       end
     end
 
     describe 'Nested Hash expansions' do
-      subject { { a: [{ b: [{ c: :d }, { e: :f }] }] }.expand }
+      subject(:expanded_hash) { { a: [{ b: [{ c: :d }, { e: :f }] }] }.expand }
+
       it do
-        is_expected.to eq([
-                            { a: { b: { c: :d } } },
-                            { a: { b: { e: :f } } },
-                          ])
+        expect(expanded_hash).to eq([
+                                      { a: { b: { c: :d } } },
+                                      { a: { b: { e: :f } } },
+                                    ])
       end
     end
   end

spec/puffy/formatters/iptables_spec.rb

@@ -7,61 +7,65 @@
 module Puffy
   module Formatters
     RSpec.describe Iptables::Rule do
+      subject(:formatter) { described_class.new }
+
       it 'formats simple rules' do
         rule = Rule.new(action: :pass, dir: :in, proto: :tcp, to: { host: nil, port: 80 })
-        expect(subject.emit_rule(rule)).to eq('-A INPUT -m conntrack --ctstate NEW -p tcp --dport 80 -j ACCEPT')
+        expect(formatter.emit_rule(rule)).to eq('-A INPUT -m conntrack --ctstate NEW -p tcp --dport 80 -j ACCEPT')
 
         rule = Rule.new(action: :pass, dir: :in, on: 'lo')
-        expect(subject.emit_rule(rule)).to eq('-A INPUT -i lo -j ACCEPT')
+        expect(formatter.emit_rule(rule)).to eq('-A INPUT -i lo -j ACCEPT')
 
         rule = Rule.new(action: :block, dir: :in, on: '!lo', to: { host: IPAddr.new('127.0.0.0/8') })
-        expect(subject.emit_rule(rule)).to eq('-A INPUT ! -i lo -d 127.0.0.0/8 -j DROP')
+        expect(formatter.emit_rule(rule)).to eq('-A INPUT ! -i lo -d 127.0.0.0/8 -j DROP')
 
         rule = Rule.new(action: :pass, dir: :out)
-        expect(subject.emit_rule(rule)).to eq('-A OUTPUT -j ACCEPT')
+        expect(formatter.emit_rule(rule)).to eq('-A OUTPUT -j ACCEPT')
 
         rule = Rule.new(action: :pass, dir: :in, proto: :tcp, from: { port: 67..68 }, to: { port: 67..68 })
-        expect(subject.emit_rule(rule)).to eq('-A INPUT -m conntrack --ctstate NEW -p tcp --sport 67:68 --dport 67:68 -j ACCEPT')
+        expect(formatter.emit_rule(rule)).to eq('-A INPUT -m conntrack --ctstate NEW -p tcp --sport 67:68 --dport 67:68 -j ACCEPT')
       end
 
       it 'returns packets when instructed so' do
         rule = Rule.new(action: :block, return: true, dir: :in, proto: :icmp)
-        expect(subject.emit_rule(rule)).to eq('-A INPUT -p icmp -j RETURN')
+        expect(formatter.emit_rule(rule)).to eq('-A INPUT -p icmp -j RETURN')
       end
 
       it 'formats forward rules' do
         rule = Rule.new(action: :pass, dir: :fwd, in: 'eth1', out: 'ppp0', from: { host: IPAddr.new('192.168.0.0/24') })
-        expect(subject.emit_rule(rule)).to eq('-A FORWARD -i eth1 -o ppp0 -s 192.168.0.0/24 -j ACCEPT')
+        expect(formatter.emit_rule(rule)).to eq('-A FORWARD -i eth1 -o ppp0 -s 192.168.0.0/24 -j ACCEPT')
       end
 
       it 'formats dnat rules' do
         rule = Rule.new(action: :pass, dir: :in, on: 'ppp0', proto: :tcp, to: { port: 80 }, rdr_to: { host: IPAddr.new('192.168.0.42') })
-        expect(subject.emit_rule(rule)).to eq('-A PREROUTING -i ppp0 -p tcp --dport 80 -j DNAT --to-destination 192.168.0.42')
+        expect(formatter.emit_rule(rule)).to eq('-A PREROUTING -i ppp0 -p tcp --dport 80 -j DNAT --to-destination 192.168.0.42')
       end
 
       it 'formats dnat rules ignoring same port' do
         rule = Rule.new(action: :pass, dir: :in, on: 'ppp0', proto: :tcp, to: { port: 80 }, rdr_to: { host: IPAddr.new('192.168.0.42'), port: 80 })
-        expect(subject.emit_rule(rule)).to eq('-A PREROUTING -i ppp0 -p tcp --dport 80 -j DNAT --to-destination 192.168.0.42')
+        expect(formatter.emit_rule(rule)).to eq('-A PREROUTING -i ppp0 -p tcp --dport 80 -j DNAT --to-destination 192.168.0.42')
       end
 
       it 'formats dnat rules with port' do
         rule = Rule.new(action: :pass, dir: :in, on: 'ppp0', proto: :tcp, to: { port: 80 }, rdr_to: { host: IPAddr.new('192.168.0.42'), port: 8080 })
-        expect(subject.emit_rule(rule)).to eq('-A PREROUTING -i ppp0 -p tcp --dport 80 -j DNAT --to-destination 192.168.0.42:8080')
+        expect(formatter.emit_rule(rule)).to eq('-A PREROUTING -i ppp0 -p tcp --dport 80 -j DNAT --to-destination 192.168.0.42:8080')
       end
 
       it 'formats redirect rules' do
         rule = Rule.new(action: :pass, dir: :in, on: 'eth0', proto: :tcp, to: { port: 80 }, rdr_to: { host: IPAddr.new('127.0.0.1/32'), port: 3128 })
-        expect(subject.emit_rule(rule)).to eq('-A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 3128')
+        expect(formatter.emit_rule(rule)).to eq('-A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 3128')
       end
 
       it 'formats nat rules' do
         rule = Rule.new(action: :pass, dir: :out, on: 'ppp0', nat_to: IPAddr.new('198.51.100.72'))
-        expect(subject.emit_rule(rule)).to eq('-A POSTROUTING -o ppp0 -j MASQUERADE')
+        expect(formatter.emit_rule(rule)).to eq('-A POSTROUTING -o ppp0 -j MASQUERADE')
       end
     end
 
     RSpec.describe Iptables::Ruleset do
-      context 'ruleset' do
+      subject(:formatter) { described_class.new }
+
+      context 'with a ruleset' do
         before do
           Timecop.freeze('2000-01-01 00:00:00')
         end
@@ -74,7 +78,7 @@ module Formatters
           parser = Puffy::Parser.new
           parser.parse(File.read(File.join('spec', 'fixtures', 'simple_lan_network.puffy')))
           rules = parser.ruleset_for('gw')
-          expect(subject.emit_ruleset(rules, :block)).to eq <<~NETFILTER
+          expect(formatter.emit_ruleset(rules, :block)).to eq <<~NETFILTER
             # Generated by puffy v#{Puffy::VERSION} on Sat Jan  1 00:00:00 2000
             *nat
             :PREROUTING ACCEPT [0:0]
@@ -99,7 +103,7 @@ module Formatters
             COMMIT
           NETFILTER
           rules = parser.ruleset_for('www')
-          expect(subject.emit_ruleset(rules, :block)).to eq <<~NETFILTER
+          expect(formatter.emit_ruleset(rules, :block)).to eq <<~NETFILTER
             # Generated by puffy v#{Puffy::VERSION} on Sat Jan  1 00:00:00 2000
             *filter
             :INPUT DROP [0:0]

spec/puffy/formatters/pf_spec.rb

@@ -5,71 +5,75 @@
 module Puffy
   module Formatters
     RSpec.describe Pf::Rule do
+      subject(:formatter) { described_class.new }
+
       it 'formats simple rules' do
         rule = Rule.new(action: :pass, dir: :out, proto: :tcp)
-        expect(subject.emit_rule(rule)).to eq('pass out quick proto tcp')
+        expect(formatter.emit_rule(rule)).to eq('pass out quick proto tcp')
 
         rule = Rule.new(action: :pass, dir: :in, proto: :tcp, to: { host: nil, port: 80 })
-        expect(subject.emit_rule(rule)).to eq('pass in quick proto tcp to any port 80')
+        expect(formatter.emit_rule(rule)).to eq('pass in quick proto tcp to any port 80')
 
         rule = Rule.new(action: :block, dir: :in, proto: :icmp)
-        expect(subject.emit_rule(rule)).to eq('block in quick proto icmp')
+        expect(formatter.emit_rule(rule)).to eq('block in quick proto icmp')
 
         rule = Rule.new(action: :pass, dir: :in, proto: :udp, from: { port: 123 }, to: { port: 123 })
-        expect(subject.emit_rule(rule)).to eq('pass in quick proto udp from any port 123 to any port 123')
+        expect(formatter.emit_rule(rule)).to eq('pass in quick proto udp from any port 123 to any port 123')
 
         rule = Rule.new(action: :pass, dir: :in, proto: :tcp, from: { port: 67..68 }, to: { port: 67..68 })
-        expect(subject.emit_rule(rule)).to eq('pass in quick proto tcp from any port 67:68 to any port 67:68')
+        expect(formatter.emit_rule(rule)).to eq('pass in quick proto tcp from any port 67:68 to any port 67:68')
       end
 
       it 'generates non-quick rules' do
         rule = Rule.new(action: :block, dir: :in, no_quick: true)
-        expect(subject.emit_rule(rule)).to eq('block in all')
+        expect(formatter.emit_rule(rule)).to eq('block in all')
       end
 
       it 'returns packets when instructed so' do
         rule = Rule.new(action: :block, return: true, dir: :in, proto: :icmp)
-        expect(subject.emit_rule(rule)).to eq('block return in quick proto icmp')
+        expect(formatter.emit_rule(rule)).to eq('block return in quick proto icmp')
       end
 
-      context 'redirect rules' do
+      context 'when formatting redirect rules' do
         it 'formats redirect rules' do
           rule = Rule.new(action: :pass, dir: :in, on: 'eth0', proto: :tcp, to: { port: 80 }, rdr_to: { host: IPAddr.new('127.0.0.1/32'), port: 3128 })
-          expect(subject.emit_rule(rule)).to eq('pass in quick on eth0 proto tcp to any port 80 divert-to 127.0.0.1 port 3128')
+          expect(formatter.emit_rule(rule)).to eq('pass in quick on eth0 proto tcp to any port 80 divert-to 127.0.0.1 port 3128')
         end
 
         it 'fails on ambiguous redirect rule' do
           rule = Rule.new(action: :pass, dir: :in, on: 'eth0', proto: :tcp, to: { port: 80 }, rdr_to: { port: 3128 })
-          expect { subject.emit_rule(rule) }.to raise_exception('Unspecified address family')
+          expect { formatter.emit_rule(rule) }.to raise_exception('Unspecified address family')
         end
 
         it 'formats implicit IPv4 destination' do
           rule = Rule.new(action: :pass, dir: :in, on: 'eth0', af: :inet, proto: :tcp, to: { port: 80 }, rdr_to: { port: 3128 })
-          expect(subject.emit_rule(rule)).to eq('pass in quick on eth0 proto tcp to any port 80 divert-to 127.0.0.1 port 3128')
+          expect(formatter.emit_rule(rule)).to eq('pass in quick on eth0 proto tcp to any port 80 divert-to 127.0.0.1 port 3128')
         end
 
         it 'formats implicit IPv6 destination' do
           rule = Rule.new(action: :pass, dir: :in, on: 'eth0', af: :inet6, proto: :tcp, to: { port: 80 }, rdr_to: { port: 3128 })
-          expect(subject.emit_rule(rule)).to eq('pass in quick on eth0 proto tcp to any port 80 divert-to ::1 port 3128')
+          expect(formatter.emit_rule(rule)).to eq('pass in quick on eth0 proto tcp to any port 80 divert-to ::1 port 3128')
         end
       end
 
-      context 'implicit address family' do
+      context 'when using an implicit address family' do
         it 'skips redundant address family' do
           rule = Rule.new(action: :pass, dir: :in, af: :inet, proto: :tcp, to: { host: IPAddr.new('127.0.0.1') })
-          expect(subject.emit_rule(rule)).to eq('pass in quick proto tcp to 127.0.0.1')
+          expect(formatter.emit_rule(rule)).to eq('pass in quick proto tcp to 127.0.0.1')
           rule = Rule.new(action: :pass, dir: :in, af: :inet6, proto: :tcp, to: { host: IPAddr.new('::1') })
-          expect(subject.emit_rule(rule)).to eq('pass in quick proto tcp to ::1')
+          expect(formatter.emit_rule(rule)).to eq('pass in quick proto tcp to ::1')
           rule = Rule.new(action: :pass, dir: :in, af: :inet, proto: :tcp, to: { port: 80 })
-          expect(subject.emit_rule(rule)).to eq('pass in quick inet proto tcp to any port 80')
+          expect(formatter.emit_rule(rule)).to eq('pass in quick inet proto tcp to any port 80')
           rule = Rule.new(action: :pass, dir: :in, af: :inet6, proto: :tcp, to: { port: 80 })
-          expect(subject.emit_rule(rule)).to eq('pass in quick inet6 proto tcp to any port 80')
+          expect(formatter.emit_rule(rule)).to eq('pass in quick inet6 proto tcp to any port 80')
         end
       end
     end
 
     RSpec.describe Pf::Ruleset do
-      context 'ruleset' do
+      subject(:formatter) { described_class.new }
+
+      context 'with a ruleset' do
         let(:parser) do
           parser = Puffy::Parser.new
           parser.parse(File.read(File.join('spec', 'fixtures', 'simple_lan_network.puffy')))
@@ -84,9 +88,9 @@ module Formatters
           Timecop.return
         end
 
-        it 'formats a simple lan network rules' do
+        it 'generates the correct gw rules' do
           rules = parser.ruleset_for('gw')
-          expect(subject.emit_ruleset(rules, :block)).to eq <<~PF
+          expect(formatter.emit_ruleset(rules, :block)).to eq <<~PF
             # Generated by puffy v#{Puffy::VERSION} on Sat Jan  1 00:00:00 2000
             match in all scrub (no-df)
             set skip on lo
@@ -99,9 +103,9 @@ module Formatters
           PF
         end
 
-        it 'formats a simple lan network rules' do
+        it 'generates tE correct www rules' do
           rules = parser.ruleset_for('www')
-          expect(subject.emit_ruleset(rules, :block)).to eq <<~PF
+          expect(formatter.emit_ruleset(rules, :block)).to eq <<~PF
             # Generated by puffy v#{Puffy::VERSION} on Sat Jan  1 00:00:00 2000
             match in all scrub (no-df)
             set skip on lo

spec/puffy/parser_spec.rb

@@ -3,13 +3,15 @@
 require 'puffy'
 
 RSpec.describe Puffy::Parser do
+  subject(:parser) { described_class.new }
+
   let(:config) do
     <<~CONFIG
       localhost = {127.0.0.1 ::1}
     CONFIG
   end
 
   it 'parses successfuly' do
-    expect { subject.parse(config) }.not_to raise_error
+    expect { parser.parse(config) }.not_to raise_error
   end
 end

spec/puffy/melt_error_spec.rb spec/puffy/puffy_error_spec.rbspec/puffy/melt_error_spec.rb renamed to spec/puffy/puffy_error_spec.rb

@@ -3,6 +3,10 @@
 require 'puffy'
 
 RSpec.describe Puffy::PuffyError do
+  subject(:error) do
+    described_class.new('Message', token)
+  end
+
   let(:token) do
     {
       filename: 'filename.ext',
@@ -13,14 +17,11 @@
     }
   end
 
-  subject do
-    Puffy::PuffyError.new('Message', token)
-  end
-
   it 'reports the correct location in file' do
-    expect(subject.to_s).to match(/^filename.ext:12:5: Message/)
+    expect(error.to_s).to match(/^filename.ext:12:5: Message/)
   end
+
   it 'highlights the correct location in the line' do
-    expect(subject.to_s).to match(/^    \^~~$/)
+    expect(error.to_s).to match(/^    \^~~$/)
   end
 end