ios_parser 0.5.1-java

data/fixtures/complex_banner.txt

@@ -0,0 +1,24 @@
+banner exec ^C
+
+             / / 
+          (\/_//`)
+           /   '/
+          0  0   \ 
+         /        \
+        /    __/   \
+       /,  _/ \     \_               
+       `-./ )  |     ~^~^~^~^~^~^~^~\~.
+           (   /                     \_}
+              |               /      |
+              ;     |         \      /
+               \/ ,/           \    |
+               / /~~|~|~~~~~~|~|\   |
+              / /   | |      | | `\ \
+             / /    | |      | |   \ \
+            / (     | |      | |    \ \
+     jgs   /,_)    /__)     /__)   /,_/
+    '''''"""""'''""""""'''""""""''"""""'''''
+
+Welcome to the Goat Rodeo!! 
+
+^C

data/ios_parser.gemspec

@@ -0,0 +1,25 @@
+$LOAD_PATH.unshift File.expand_path('lib', __dir__)
+require 'ios_parser/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'ios_parser'
+  s.version     = IOSParser.version
+  s.summary     = 'convert network switch and router config files to '\
+                  'structured data'
+  s.authors     = ['Ben Miller']
+  s.email       = 'bjmllr@gmail.com'
+  s.homepage    = 'https://github.com/bjmllr/ios_parser'
+  s.license     = 'GPL-3.0'
+  s.files       = `git ls-files`.split("\n")
+  s.test_files  = `git ls-files -- {spec,features}/*`.split("\n")
+
+  if RUBY_PLATFORM == 'java'
+    s.platform = 'java'
+  else
+    s.extensions << 'ext/ios_parser/c_lexer/extconf.rb'
+  end
+
+  s.add_development_dependency 'rake-compiler', '~>0.9'
+  s.add_development_dependency 'rspec', '~>3.2'
+  s.add_development_dependency 'rubocop', '~> 0.54' if RUBY_VERSION > '2.1'
+end

data/lib/ios_parser/ios/command.rb

@@ -0,0 +1,91 @@
+require 'json'
+require_relative 'queryable'
+
+module IOSParser
+  class IOS
+    class Command
+      include Enumerable
+      include Queryable
+      attr_accessor :args, :commands, :parent, :pos, :document
+
+      def initialize(args: [], commands: [],
+                     parent: nil, pos: nil, document: nil)
+        @args = args
+        @commands = commands
+        @parent = parent
+        @pos = pos
+        @document = document
+      end
+
+      def name
+        args[0]
+      end
+
+      def ==(other)
+        args == other.args && commands == other.commands
+      end
+
+      def eql?(other)
+        self == other && self.class == other.class
+      end
+
+      def line
+        args.join(' ')
+      end
+
+      def path
+        parent ? parent.path + [parent.line] : []
+      end
+
+      def indentation(base: 0)
+        ' ' * (path.length - base)
+      end
+
+      def each
+        yield self
+        commands.each { |command| command.each { |cmd| yield cmd } }
+      end
+
+      def inspect
+        "<IOSParser::IOS::Command:0x#{object_id.to_s(16)} "\
+        "@args=#{args.inspect}, "\
+        "@commands=#{commands.inspect}, "\
+        "@pos=#{pos.inspect}, "\
+        "@document=<IOSParser::IOS::Document:0x#{document.object_id.to_s(16)}>>"
+      end
+
+      def to_s(dedent: false)
+        indent_opts = { base: dedent ? path.length : 0 }
+        map { |cmd| "#{cmd.indentation(indent_opts)}#{cmd.line}\n" }.join
+      end
+
+      def to_hash
+        {
+          args: args,
+          commands: commands.map(&:to_hash),
+          pos: pos
+        }
+      end
+
+      def to_json
+        JSON.dump(to_hash)
+      end
+
+      class << self
+        def from_hash(hash, parent = nil)
+          hash[:parent] = parent
+          [:args, :commands, :pos].each do |key|
+            val = hash.delete(key.to_s)
+            hash[key] ||= val
+          end
+
+          hash[:commands] ||= []
+          hash[:commands].each_index do |i|
+            hash[:commands][i] = from_hash(hash[:commands][i])
+          end
+          new(hash)
+        end
+      end
+    end # class Command
+  end # class IOS
+end # module IOSParser

data/lib/ios_parser/ios/document.rb

@@ -0,0 +1,54 @@
+require 'json'
+require_relative 'queryable'
+require_relative 'command'
+
+module IOSParser
+  class IOS
+    class Document
+      include Enumerable
+      include Queryable
+      attr_accessor :commands, :parent, :source
+
+      def initialize(source)
+        @commands = []
+        @parent = nil
+        @source = source
+      end
+
+      [:[], :push].each do |method|
+        define_method(method) { |*args| commands.send(method, *args) }
+      end
+
+      def each
+        commands.each { |command| command.each { |cmd| yield cmd } }
+      end
+
+      def to_s(dedent: false)
+        base = dedent ? indentation : 0
+        map { |cmd| "#{cmd.indentation(base: base)}#{cmd.line}\n" }.join
+      end
+
+      def to_hash
+        { commands: commands.map(&:to_hash) }
+      end
+
+      def to_json
+        JSON.dump(to_hash)
+      end
+
+      class << self
+        def from_hash(hash)
+          hash[:parent] = parent
+          [:commands, :source].each do |key|
+            val = hash.delete(key.to_s)
+            hash[key] = val unless hash.key?(key)
+          end
+
+          new(source).tap do |doc|
+            doc.push(*(hash[:commands].map { |c| Command.from_hash(c) }))
+          end
+        end
+      end # class << self
+    end # class Document
+  end # class IOS
+end # class IOSParser

data/lib/ios_parser/ios/queryable.rb

@@ -0,0 +1,219 @@
+module IOSParser
+  class IOS
+    module Queryable
+      def find_all(expr, &blk)
+        _find_all(MatcherReader.query_expression(expr), &blk)
+      end
+
+      def find(expr, &blk)
+        _find(MatcherReader.query_expression(expr), &blk)
+      end
+
+      def _find_all(expr, &blk)
+        [].tap do |ret|
+          commands.each do |command|
+            if match_expr(expr, command)
+              ret << command
+              yield(command) if blk
+            end
+
+            ret.push(*command._find_all(expr, &blk))
+          end
+        end
+      end
+
+      def match_expr(expr, command)
+        expr.each_pair.all? { |pred, arg| Matcher.send(pred, arg, command) }
+      end
+
+      def _find(expr, &blk)
+        _find_all(expr) do |command|
+          yield(command) if blk
+          return command
+        end
+        nil
+      end
+
+      module MatcherReader
+        class << self
+          def query_expression(raw)
+            case raw
+            when Hash          then query_expression_hash(raw)
+            when Proc          then { procedure: procedure(raw) }
+            when Regexp        then { line: line(raw) }
+            when String, Array then { starts_with: starts_with(raw) }
+            else raise("Invalid query: #{raw.inspect}")
+            end
+          end
+          alias parent query_expression
+          alias any_child query_expression
+          alias no_child query_expression
+
+          def query_expression_hash(original)
+            raw = original.dup
+            raw.each_pair { |pred, arg| raw[pred] &&= send(pred, arg) }
+            raw
+          end
+
+          def name(expr)
+            expr
+          end
+
+          def starts_with(expr)
+            case expr
+            when String then expr.split
+            when Array  then expr
+            else raise("Invalid #{__method__} condition in query: #{expr}")
+            end
+          end
+          alias contains starts_with
+          alias ends_with starts_with
+
+          def procedure(expr)
+            unless expr.respond_to?(:call)
+              raise("Invalid procedure in query: #{expr}")
+            end
+            expr
+          end
+
+          def line(expr)
+            case expr
+            when String, Regexp then expr
+            when Array          then expr.join(' ')
+            else raise("Invalid line condition in query: #{expr}")
+            end
+          end
+
+          def array_wrap_and_map(expr)
+            (expr.respond_to?(:map) && !expr.is_a?(Hash) ? expr : [expr])
+              .map { |e| query_expression(e) }
+          end
+          alias any array_wrap_and_map
+          alias all array_wrap_and_map
+          alias none array_wrap_and_map
+          alias not array_wrap_and_map
+          alias not_all array_wrap_and_map
+
+          def depth(expr)
+            unless expr.is_a?(Integer) || (expr.is_a?(Range) &&
+                                           expr.first.is_a?(Integer) &&
+                                           expr.last.is_a?(Integer))
+              raise("Invalid depth constraint in query: #{expr}")
+            end
+            expr
+          end
+        end # class << self
+      end # module MatcherReader
+
+      module Matcher
+        class << self
+          def name(expr, command)
+            expr === command.name
+          end
+
+          def starts_with(req_ary, command)
+            (0..req_ary.length - 1).all? do |i|
+              compare_string_or_case(req_ary[i], command.args[i])
+            end
+          end
+
+          def contains(req_ary, command)
+            (0..command.args.length - req_ary.length).any? do |j|
+              (0..req_ary.length - 1).all? do |i|
+                compare_string_or_case(req_ary[i], command.args[i + j])
+              end
+            end
+          end
+
+          def ends_with(req_ary, command)
+            (1..req_ary.length).all? do |i|
+              compare_string_or_case(req_ary[-i], command.args[-1])
+            end
+          end
+
+          def compare_string_or_case(a_object, b_object)
+            case a_object
+            when String
+              a_object == b_object.to_s
+            else
+              a_object === b_object
+            end
+          end
+
+          def procedure(expr, command)
+            expr.call(command)
+          end
+
+          def line(expr, command)
+            expr === command.line
+          end
+
+          def parent(expr, command)
+            expr.each_pair.all? do |pred, arg|
+              command.parent && send(pred, arg, command.parent)
+            end
+          end
+
+          def any_child(expr, command)
+            command.find(expr)
+          end
+
+          def no_child(expr, command)
+            !command.find(expr)
+          end
+
+          def any(expressions, command)
+            expressions.any? do |expr|
+              expr.each_pair.any? do |pred, arg|
+                send(pred, arg, command)
+              end
+            end
+          end
+
+          def all(expressions, command)
+            expressions.all? do |expr|
+              expr.each_pair.all? do |pred, arg|
+                send(pred, arg, command)
+              end
+            end
+          end
+
+          def not_all(expressions, command)
+            !expressions.all? { |expr| all([expr], command) }
+          end
+          alias not not_all
+
+          def none(expressions, command)
+            expressions.none? { |expr| all([expr], command) }
+          end
+
+          def depth(expr, command)
+            case expr
+            when Integer then depth_exact(expr, command)
+            when Range   then depth_range(expr, command)
+            end
+          end
+
+          def depth_exact(expr, command)
+            _depth(expr, command) == expr
+          end
+
+          def depth_range(expr, command)
+            _depth(expr.last, command) > expr.first
+          end
+
+          def _depth(max, command)
+            level = 0
+            ptr = command
+            while ptr.parent
+              ptr = ptr.parent
+              level += 1
+              return Float::MIN if level > max
+            end
+            level
+          end
+        end # class << self
+      end # module Matcher
+    end # module Queryable
+  end # class IOS
+end # module IOSParser

data/lib/ios_parser/ios.rb

@@ -0,0 +1,73 @@
+require_relative 'ios/document'
+
+module IOSParser
+  class IOS
+    attr_accessor :document
+    attr_accessor :lexer
+    attr_accessor :source
+    attr_writer :tokens
+
+    def initialize(parent: nil, lexer: IOSParser::Lexer.new)
+      @document = Document.new(nil)
+      @parent = parent
+      @lexer  = lexer
+    end
+
+    def tokens
+      @tokens ||= lexer.call(@source)
+    end
+
+    def call(source)
+      unless source.respond_to? :each_char
+        raise ArgumentError, 'Provided configuration source is invalid.'
+      end
+      @source = source
+      @document.source = source
+      @document.push(*section) until tokens.empty?
+      @document
+    end
+
+    def section(parent = nil)
+      [].tap do |commands|
+        until tokens.empty? || tokens.first.last == :DEDENT
+          commands.push(command(parent, @document))
+        end
+        tokens.shift # discard :DEDENT
+      end
+    end
+
+    def command(parent = nil, document = nil)
+      pos = tokens.first.first
+      opts = { args: arguments, parent: parent, document: document, pos: pos }
+
+      Command.new(opts).tap do |cmd|
+        cmd.commands = subsections(cmd)
+      end
+    end
+
+    def arguments_to_discard
+      [:INDENT, :DEDENT,
+       :CERTIFICATE_BEGIN, :CERTIFICATE_END,
+       :BANNER_BEGIN, :BANNER_END]
+    end
+
+    def arguments
+      [].tap do |args|
+        until tokens.empty? || tokens.first.last == :EOL
+          _, arg = tokens.shift
+          args << arg unless arguments_to_discard.include?(arg)
+        end
+        tokens.shift # discard :EOL
+      end
+    end
+
+    def subsections(parent = nil)
+      if !tokens.empty? && tokens.first.last == :INDENT
+        tokens.shift # discard :INDENT
+        section(parent)
+      else
+        []
+      end
+    end
+  end
+end