ios_parser 0.3.0

data/spec/lib/ios_parser/lexer_spec.rb

@@ -0,0 +1,231 @@
+require_relative '../../spec_helper'
+require 'ios_parser'
+require 'ios_parser/lexer'
+
+module IOSParser
+  describe Lexer do
+    describe '#call' do
+      subject { klass.new.call(input) }
+
+      let(:subject_pure) do
+        IOSParser::PureLexer.new.call(input)
+      end
+
+      context 'indented region' do
+        let(:input) { <<-END }
+policy-map mypolicy_in
+ class myservice_service
+  police 300000000 1000000 exceed-action policed-dscp-transmit
+   set dscp cs1
+ class other_service
+  police 600000000 1000000 exceed-action policed-dscp-transmit
+   set dscp cs2
+END
+
+        let(:output) do
+          ['policy-map', 'mypolicy_in', :EOL,
+           :INDENT,
+           'class', 'myservice_service', :EOL,
+           :INDENT,
+           'police', 300_000_000, 1_000_000, 'exceed-action',
+           'policed-dscp-transmit', :EOL,
+           :INDENT,
+           'set', 'dscp', 'cs1', :EOL,
+           :DEDENT, :DEDENT,
+           'class', 'other_service', :EOL,
+           :INDENT,
+           'police', 600_000_000, 1_000_000, 'exceed-action',
+           'policed-dscp-transmit', :EOL,
+           :INDENT,
+           'set', 'dscp', 'cs2', :EOL, :DEDENT, :DEDENT, :DEDENT
+          ]
+        end
+
+        subject { klass.new.call(input).map(&:last) }
+        it('enclosed in symbols') { should == output }
+
+        it('enclosed in symbols (using the pure ruby lexer)') do
+          expect(subject_pure.map(&:last)).to eq output
+        end
+      end
+
+      context 'ASR indented regions' do
+        context 'indented region' do
+          let(:input) { <<-END }
+router static
+ vrf MGMT
+  address-family ipv4 unicast
+   0.0.0.0/0 1.2.3.4
+  !
+ !
+!
+router ospf 12345
+ nsr
+END
+
+          let(:expectation) do
+            ['router', 'static', :EOL,
+             :INDENT, 'vrf', 'MGMT', :EOL,
+             :INDENT, 'address-family', 'ipv4', 'unicast', :EOL,
+             :INDENT, '0.0.0.0/0', '1.2.3.4', :EOL,
+             :DEDENT, :DEDENT, :DEDENT,
+             'router', 'ospf', 12_345, :EOL,
+             :INDENT, 'nsr', :EOL,
+             :DEDENT
+            ]
+          end
+
+          it 'pure' do
+            tokens = IOSParser::PureLexer.new.call(input)
+            expect(tokens.map(&:last)).to eq expectation
+          end # it 'pure' do
+
+          it 'c' do
+            tokens = IOSParser::CLexer.new.call(input)
+            expect(tokens.map(&:last)).to eq expectation
+          end # it 'c' do
+        end # context 'indented region' do
+      end # context 'ASR indented regions' do
+
+      context 'banners' do
+        let(:input) do
+          <<-END
+banner foobar ^
+asdf 1234 9786 asdf
+line 2
+line 3
+  ^
+END
+        end
+
+        let(:output) do
+          [[0, 'banner'], [7, 'foobar'], [14, :BANNER_BEGIN],
+           [16, "asdf 1234 9786 asdf\nline 2\nline 3\n  "],
+           [52, :BANNER_END], [53, :EOL]]
+        end
+
+        it('tokenized and enclosed in symbols') { should == output }
+
+        it('tokenized and enclodes in symbols (using the pure ruby lexer)') do
+          expect(subject_pure).to eq output
+        end
+      end
+
+      context 'decimal number' do
+        let(:input) { 'boson levels at 93.2' }
+        let(:output) { ['boson', 'levels', 'at', 93.2] }
+        subject { klass.new.call(input).map(&:last) }
+        it('converts to Float') { should == output }
+      end
+
+      context 'cryptographic certificate' do
+        let(:input) do
+          <<END
+crypto pki certificate chain TP-self-signed-0123456789
+ certificate self-signed 01
+  FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF
+  EEEEEEEE EEEEEEEE EEEEEEEE EEEEEEEE EEEEEEEE EEEEEEEE EEEEEEEE EEEEEEEE
+  DDDDDDDD DDDDDDDD DDDDDDDD DDDDDDDD DDDDDDDD DDDDDDDD DDDDDDDD DDDDDDDD AAAA
+        quit
+!
+END
+        end
+
+        let(:output) do
+          [[0, 'crypto'],
+           [7, 'pki'],
+           [11, 'certificate'],
+           [23, 'chain'],
+           [29, 'TP-self-signed-0123456789'],
+           [54, :EOL],
+           [56, :INDENT],
+           [56, 'certificate'],
+           [68, 'self-signed'],
+           [80, '01'],
+           [85, :CERTIFICATE_BEGIN],
+           [85,
+            'FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF '\
+            'FFFFFFFF EEEEEEEE EEEEEEEE EEEEEEEE EEEEEEEE EEEEEEEE EEEEEEEE '\
+            'EEEEEEEE EEEEEEEE DDDDDDDD DDDDDDDD DDDDDDDD DDDDDDDD DDDDDDDD '\
+            'DDDDDDDD DDDDDDDD DDDDDDDD AAAA'],
+           [323, :CERTIFICATE_END],
+           [323, :EOL],
+           [323, :DEDENT]
+          ]
+        end
+
+        subject { klass.new.call(input) }
+        it('tokenized') { expect(subject).to eq output }
+
+        it('tokenized (using the pure ruby lexer)') do
+          expect(subject_pure).to eq output
+        end
+      end
+
+      context 'comments' do
+        let(:input) { 'ip addr 127.0.0.0.1 ! asdfsdf' }
+        let(:output) { ['ip', 'addr', '127.0.0.0.1'] }
+        subject { klass.new.call(input).map(&:last) }
+        it('dropped') { should == output }
+      end
+
+      context 'quoted octothorpe' do
+        let(:input) { <<-EOS }
+vlan 1
+ name "a #"
+vlan 2
+ name d
+      EOS
+
+        let(:output) do
+          [
+            'vlan', 1, :EOL,
+            :INDENT, 'name', '"a #"', :EOL,
+            :DEDENT,
+            'vlan', 2, :EOL,
+            :INDENT, 'name', 'd', :EOL,
+            :DEDENT
+          ]
+        end
+
+        it { expect(subject_pure.map(&:last)).to eq output }
+        it { expect(subject.map(&:last)).to eq output }
+      end # context 'quoted octothorpe' do
+
+      context 'vlan range' do
+        let(:input) { 'switchport trunk allowed vlan 50-90' }
+        let(:output) do
+          [
+            [0, 'switchport'],
+            [11, 'trunk'],
+            [17, 'allowed'],
+            [25, 'vlan'],
+            [30, '50-90']
+          ]
+        end
+        it { should == output }
+      end # context 'vlan range' do
+
+      context 'partial dedent' do
+        let(:input) do
+          <<END
+class-map match-any foobar
+  description blahblahblah
+ match access-group fred
+END
+        end
+
+        let(:output) do
+          [
+            'class-map', 'match-any', 'foobar', :EOL,
+            :INDENT, 'description', 'blahblahblah', :EOL,
+            'match', 'access-group', 'fred', :EOL,
+            :DEDENT
+          ]
+        end
+
+        it { expect(subject_pure.map(&:last)).to eq output }
+      end
+    end
+  end
+end

data/spec/lib/ios_parser_spec.rb

@@ -0,0 +1,101 @@
+require_relative '../spec_helper'
+require 'ios_parser'
+
+describe IOSParser do
+  describe '.parse' do
+    context 'indented region' do
+      let(:input) { <<-END }
+policy-map mypolicy_in
+ class myservice_service
+  police 300000000 1000000 exceed-action policed-dscp-transmit
+   set dscp cs1
+ class other_service
+  police 600000000 1000000 exceed-action policed-dscp-transmit
+   set dscp cs2
+   command_with_no_args
+END
+
+      let(:output) do
+        {
+          commands:
+            [{ args: ['policy-map', 'mypolicy_in'],
+               commands:
+                 [{ args: %w(class myservice_service),
+                    commands: [{ args: ['police', 300_000_000, 1_000_000,
+                                        'exceed-action',
+                                        'policed-dscp-transmit'],
+                                 commands: [{ args: %w(set dscp cs1),
+                                              commands: [], pos: 114 }],
+                                 pos: 50
+                               }],
+                    pos: 24
+                  },
+
+                  { args: %w(class other_service),
+                    commands: [{ args: ['police', 600_000_000, 1_000_000,
+                                        'exceed-action',
+                                        'policed-dscp-transmit'],
+                                 commands: [{ args: %w(set dscp cs2),
+                                              commands: [], pos: 214 },
+                                            { args: ['command_with_no_args'],
+                                              commands: [], pos: 230 }],
+                                 pos: 150
+                               }],
+                    pos: 128
+                  }],
+               pos: 0
+             }]
+        }
+      end
+
+      subject { described_class.parse(input) }
+
+      it('constructs the right AST') do
+        should be_a IOSParser::IOS::Document
+        expect(subject.to_hash).to eq output
+      end
+    end # context 'indented region'
+
+    context 'partial outdent' do
+      let(:input) do
+        <<END
+class-map match-any foobar
+  description blah blah blah
+ match access-group fred
+END
+      end
+
+      let(:output) do
+        {
+          commands:
+            [
+              {
+                args: ['class-map', 'match-any', 'foobar'],
+                commands: [
+                  {
+                    args: %w(description blah blah blah),
+                    commands: [],
+                    pos: 29
+                  },
+                  {
+                    args: ['match', 'access-group', 'fred'],
+                    commands: [],
+                    pos: 57
+                  }
+                ],
+                pos: 0
+              }
+            ]
+        }
+      end
+
+      subject { described_class.parse(input) }
+
+      it 'constructs the right AST' do
+        should be_a IOSParser::IOS::Document
+        actual = subject.to_hash
+        expect(actual).to eq(output)
+      end
+    end # context "partial outdent" do
+  end # describe '.parse'
+end # describe IOSParser

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+$LOAD_PATH << File.dirname(__FILE__) + '/../lib'
+
+def klass
+  described_class
+end

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: ios_parser
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Ben Miller
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.37'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.37'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.5'
+- !ruby/object:Gem::Dependency
+  name: guard-rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: 
+email: bjmllr@gmail.com
+executables: []
+extensions:
+- ext/ios_parser/c_lexer/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- doc/state_machine.graphviz
+- doc/state_machine.png
+- ext/ios_parser/c_lexer/extconf.rb
+- ext/ios_parser/c_lexer/lexer.c
+- ios_parser.gemspec
+- lib/ios_parser.rb
+- lib/ios_parser/ios.rb
+- lib/ios_parser/ios/command.rb
+- lib/ios_parser/ios/document.rb
+- lib/ios_parser/ios/queryable.rb
+- lib/ios_parser/lexer.rb
+- lib/ios_parser/pure.rb
+- lib/ios_parser/version.rb
+- spec/lib/ios_parser/ios/queryable_spec.rb
+- spec/lib/ios_parser/ios_spec.rb
+- spec/lib/ios_parser/lexer_spec.rb
+- spec/lib/ios_parser_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/bjmllr/ios_parser
+licenses:
+- GPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: convert network switch and router config files to structured data
+test_files:
+- spec/lib/ios_parser/ios/queryable_spec.rb
+- spec/lib/ios_parser/ios_spec.rb
+- spec/lib/ios_parser/lexer_spec.rb
+- spec/lib/ios_parser_spec.rb
+- spec/spec_helper.rb
+has_rdoc: