ios_parser 0.5.1-java

data/lib/ios_parser/lexer.rb

@@ -0,0 +1,327 @@
+module IOSParser
+  class PureLexer
+    LexError = IOSParser::LexError
+
+    attr_accessor :tokens, :token, :indents, :indent, :state, :char,
+                  :string_terminator
+
+    def initialize
+      @text    = ''
+      @token   = ''
+      @tokens  = []
+      @indent  = 0
+      @indents = [0]
+      @state   = :root
+      @token_char = 0
+      @this_char  = -1
+    end
+
+    def call(input_text)
+      @text = input_text
+
+      input_text.each_char.with_index do |c, i|
+        @this_char = i
+        self.char = c
+        send(state)
+      end
+
+      finalize
+    end
+
+    ROOT_TRANSITIONS = [
+      :space,
+      :banner_begin,
+      :certificate_begin,
+      :newline,
+      :comment,
+      :integer,
+      :quoted_string,
+      :word
+    ].freeze
+
+    def root
+      @token_start ||= @this_char
+
+      ROOT_TRANSITIONS.each do |meth|
+        return send(meth) if send(:"#{meth}?")
+      end
+
+      raise LexError, "Unknown character #{char.inspect}"
+    end
+
+    def root_line_start
+      if lead_comment?
+        comment
+      else
+        root
+      end
+    end
+
+    def make_token(value, pos: nil)
+      pos ||= @token_start || @this_char
+      @token_start = nil
+      [pos, value]
+    end
+
+    def comment
+      self.state = :comment
+      update_indentation
+      self.state = :root if newline?
+    end
+
+    def comment?
+      char == '!'
+    end
+
+    def lead_comment?
+      char == '#' || char == '!'
+    end
+
+    def banner_begin
+      self.state = :banner
+      tokens << make_token(:BANNER_BEGIN)
+      @token_start = @this_char + 2
+      @banner_delimiter = char == "\n" ? 'EOF' : char
+    end
+
+    def banner_begin?
+      tokens[-2] && tokens[-2].last == 'banner'
+    end
+
+    def banner
+      if banner_end_char?
+        banner_end_char
+      elsif banner_end_string?
+        banner_end_string
+      else
+        token << char
+      end
+    end
+
+    def banner_end_string
+      self.state = :root
+      token.chomp!(@banner_delimiter[0..-2])
+      tokens << make_token(token) << make_token(:BANNER_END)
+      self.token = ''
+    end
+
+    def banner_end_string?
+      @banner_delimiter.size > 1 && (token + char).end_with?(@banner_delimiter)
+    end
+
+    def banner_end_char
+      self.state = :root
+      banner_end_clean_token
+      tokens << make_token(token) << make_token(:BANNER_END)
+      self.token = ''
+    end
+
+    def banner_end_char?
+      char == @banner_delimiter && (@text[@this_char - 1] == "\n" ||
+                                    @text[@this_char + 1] == "\n")
+    end
+
+    def banner_end_clean_token
+      token.slice!(0) if token[0] == 'C'
+      token.slice!(0) if ["\n", ' '].include?(token[0])
+    end
+
+    def scrub_banner_garbage
+      tokens.each_index do |i|
+        next unless tokens[i + 1]
+        tokens.slice!(i + 1) if banner_garbage?(i)
+      end
+    end
+
+    def banner_garbage?(pos)
+      tokens[pos].last == :BANNER_END && tokens[pos + 1].last == 'C'
+    end
+
+    def certificate_begin?
+      tokens[-6] && tokens[-6].last == :INDENT &&
+        tokens[-5] && tokens[-5].last == 'certificate'
+    end
+
+    def certificate_begin
+      self.state = :certificate
+      indents.pop
+      tokens[-2..-1] = [make_token(:CERTIFICATE_BEGIN, pos: tokens[-1][0])]
+      certificate
+    end
+
+    def certificate
+      token[-5..-1] == "quit\n" ? certificate_end : token << char
+    end
+
+    def certificate_end
+      tokens.concat certificate_end_tokens
+      update_indentation
+      @token_start = @this_char
+
+      @token = ''
+      self.state = :line_start
+      self.indent = 0
+      root
+    end
+
+    def certificate_end_tokens
+      [
+        make_token(token[0..-6].gsub!(/\s+/, ' ').strip, pos: tokens[-1][0]),
+        make_token(:CERTIFICATE_END, pos: @this_char),
+        make_token(:EOL, pos: @this_char)
+      ]
+    end
+
+    def integer
+      self.state = :integer
+      if dot?   then decimal
+      elsif digit? then token << char
+      elsif word?  then word
+      else root
+      end
+    end
+
+    def integer_token
+      token[0] == '0' ? word_token : make_token(Integer(token))
+    end
+
+    def digit?
+      ('0'..'9').cover? char
+    end
+    alias integer? digit?
+
+    def dot?
+      char == '.'
+    end
+
+    def decimal
+      self.state = :decimal
+      if digit? then token << char
+      elsif dot?   then token << char
+      elsif word?  then word
+      else root
+      end
+    end
+
+    def decimal_token
+      if token.count('.') > 1 || token[-1] == '.'
+        word_token
+      else
+        make_token(Float(token))
+      end
+    end
+
+    def decimal?
+      dot? || digit?
+    end
+
+    def word
+      self.state = :word
+      word? ? token << char : root
+    end
+
+    def word_token
+      make_token(token)
+    end
+
+    def word?
+      digit? || dot? ||
+        ('a'..'z').cover?(char) ||
+        ('A'..'Z').cover?(char) ||
+        ['-', '+', '$', ':', '/', ',', '(', ')', '|', '*', '#', '=', '<', '>',
+         '!', '"', '&', '@', ';', '%', '~', '{', '}', "'", '?', '[', ']', '_',
+         '^', '\\', '`'].include?(char)
+    end
+
+    def space
+      delimit
+      self.indent += 1 if tokens.last && tokens.last.last == :EOL
+    end
+
+    def space?
+      char == ' ' || char == "\t" || char == "\r"
+    end
+
+    def quoted_string
+      self.state = :quoted_string
+      token << char
+      if string_terminator.nil?
+        self.string_terminator = char
+      elsif char == string_terminator
+        delimit
+      end
+    end
+
+    def quoted_string_token
+      make_token(token)
+    end
+
+    def quoted_string?
+      char == '"' || char == "'"
+    end
+
+    def newline
+      delimit
+      return banner_begin if banner_begin?
+      self.state = :line_start
+      self.indent = 0
+      tokens << make_token(:EOL)
+    end
+
+    def newline?
+      char == "\n"
+    end
+
+    def line_start
+      if space?
+        self.indent += 1
+      else
+        update_indentation
+        root_line_start
+      end
+    end
+
+    def delimit
+      return if token.empty?
+
+      unless respond_to?(:"#{state}_token")
+        pos = @token_start || @this_char
+        raise LexError, "Unterminated #{state} starting at #{pos}: "\
+                        "#{@text[pos..pos + 20].inspect}"
+      end
+
+      tokens << send(:"#{state}_token")
+      self.state = :root
+      self.token = ''
+    end
+
+    def update_indentation
+      pop_dedent while 1 < indents.size && indent <= indents[-2]
+      push_indent if indent > indents.last
+      self.indent = 0
+    end
+
+    def pop_dedent
+      tokens << make_token(:DEDENT)
+      indents.pop
+    end
+
+    def push_indent
+      tokens << make_token(:INDENT)
+      indents.push(indent)
+    end
+
+    def finalize
+      if state == :quoted_string
+        pos = @text.rindex(string_terminator)
+        raise LexError, "Unterminated quoted string starting at #{pos}: "\
+                        "#{@text[pos..pos + 20]}"
+      end
+
+      delimit
+      update_indentation
+      scrub_banner_garbage
+      tokens
+    end
+  end # class PureLexer
+end # module IOSParser

data/lib/ios_parser/pure.rb

@@ -0,0 +1,2 @@
+require_relative 'lexer'
+require_relative '../ios_parser'

data/lib/ios_parser/version.rb

@@ -0,0 +1,7 @@
+module IOSParser
+  class << self
+    def version
+      '0.5.1'
+    end
+  end
+end

data/lib/ios_parser.rb

@@ -0,0 +1,37 @@
+require 'json'
+
+module IOSParser
+  class LexError < StandardError; end
+
+  def self.lexer
+    if const_defined?(:PureLexer)
+      PureLexer
+    else
+      require_relative 'ios_parser/c_lexer'
+      CLexer
+    end
+  rescue LoadError
+    require 'ios_parser/lexer'
+    PureLexer
+  end
+
+  Lexer = lexer
+end
+
+require_relative 'ios_parser/ios'
+
+module IOSParser
+  class << self
+    def parse(input)
+      IOSParser::IOS.new.call(input)
+    end
+
+    def hash_to_ios(hash)
+      IOSParser::IOS::Document.from_hash(hash)
+    end
+
+    def json_to_ios(text)
+      hash_to_ios JSON.parse(text)
+    end
+  end
+end

data/spec/lib/ios_parser/ios/queryable_spec.rb

@@ -0,0 +1,157 @@
+require_relative '../../../spec_helper'
+require 'ios_parser'
+
+module IOSParser
+  class IOS
+    describe Queryable do
+      let(:input) { <<-END.unindent }
+        policy-map mypolicy_in
+         class some_service
+          police 300000000 1000000 exceed-action policed-dscp-transmit
+           set dscp cs1
+         class my_service
+          police 600000000 1000000 exceed-action policed-dscp-transmit
+           set dscp cs2
+           command_with_no_args
+      END
+
+      let(:expectation) { 'set dscp cs1' }
+      let(:parsed) { IOSParser.parse(input) }
+      subject { parsed.find(matcher.freeze).line }
+
+      describe '#find' do
+        context 'shortcut matcher' do
+          describe String do
+            let(:matcher) { 'set dscp cs1'.freeze }
+            it { should == expectation }
+          end
+
+          describe Regexp do
+            let(:matcher) { /set .* cs1/ }
+            it { should == expectation }
+          end
+
+          describe Proc do
+            let(:expectation) { 'command_with_no_args' }
+            let(:matcher) { ->(c) { c.args.count == 1 } }
+            it { should == expectation }
+          end
+        end # context 'shortcut matcher' do
+
+        context 'explicit matcher form of shortcut matcher' do
+          describe String do
+            let(:matcher) { { starts_with: 'set dscp cs1'.freeze }.freeze }
+            it { should == expectation }
+          end
+
+          describe Regexp do
+            let(:matcher) { { line: /set .* cs1/ }.freeze }
+            it { should == expectation }
+          end
+
+          describe Proc do
+            let(:expectation) { 'command_with_no_args' }
+            let(:matcher) { { procedure: ->(c) { c.args.count == 1 } }.freeze }
+            it { should == expectation }
+          end
+        end # context 'explicit matcher form of shortcut matcher' do
+
+        context 'matcher: contains' do
+          describe String do
+            let(:matcher) { { contains: 'dscp cs1'.freeze }.freeze }
+            it { should == expectation }
+          end
+
+          describe Array do
+            let(:matcher) do
+              { contains: ['dscp'.freeze, 'cs1'.freeze].freeze }.freeze
+            end
+            it { should == expectation }
+          end
+        end # context 'matcher: contains' do
+
+        context 'matcher: ends_with' do
+          let(:expectation) { 'class my_service' }
+
+          describe String do
+            let(:matcher) { { ends_with: 'my_service'.freeze }.freeze }
+            it { should == expectation }
+          end
+
+          describe Array do
+            let(:matcher) { { ends_with: ['my_service'.freeze].freeze }.freeze }
+            it { should == expectation }
+          end
+        end # context 'matcher: ends_with' do
+
+        context 'matcher: all' do
+          let(:matcher) { { all: ['set'.freeze, /cs1/].freeze }.freeze }
+          it { should == expectation }
+        end
+
+        context 'matcher: parent' do
+          let(:matcher) { { parent: /police 3/ }.freeze }
+          it { should == expectation }
+        end
+
+        context 'matcher: any' do
+          let(:matcher) { { any: [/asdf/, /cs1/, /qwerwqe/].freeze }.freeze }
+          it { should == expectation }
+        end
+
+        context 'matcher: any (with a hash)' do
+          let(:matcher) do
+            {
+              any: { depth: 0, procedure: ->(c) { c.args.count == 1 } }.freeze
+            }.freeze
+          end
+
+          it do
+            expect(parsed.find_all(matcher).map(&:line))
+              .to eq ['policy-map mypolicy_in', 'command_with_no_args']
+          end
+        end
+
+        context 'matcher: depth' do
+          let(:matcher) { { depth: 3 }.freeze }
+          it { should == expectation }
+        end
+
+        context 'matcher: none' do
+          let(:matcher) do
+            { none: [/policy/, /class/, /police/].freeze }.freeze
+          end
+          it { should == expectation }
+        end
+
+        context 'matcher: not_all' do
+          let(:matcher)  do
+            {
+              all: {
+                none: /policy/,
+                not: /class/,
+                not_all: /police/
+              }.freeze
+            }.freeze
+          end
+
+          it do
+            expect(parsed.find(not_all: [/policy/, /class/]).line)
+              .to eq 'policy-map mypolicy_in'
+          end
+          it { should == expectation }
+        end
+
+        context 'matcher: any_child' do
+          let(:matcher) { { not: { any_child: /dscp/ }.freeze }.freeze }
+          it { should == expectation }
+        end
+
+        context 'matcher: no_child' do
+          let(:matcher) { { no_child: /dscp/ }.freeze }
+          it { should == expectation }
+        end
+      end # describe '#find' do
+    end # describe Queryable
+  end # class IOS
+end # module IOSParser