ios_parser 0.5.1 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2de99dbf9bae8e78c136f2ae91976e4989dcf1b38ee329184c379a8e23346183
-  data.tar.gz: a5a644079df051eb363682d43773b056fe9b0101493494bd6ae4571cf1196920
+  metadata.gz: 7ca27e440ca7f9a38c976bff002dc996725d77e1ec3fcd12749e119b910ed08d
+  data.tar.gz: 5c59a60ccdf9c10e5d6fd8841dfb2eac7fae046b3447aa401cc61982210d9b08
 SHA512:
-  metadata.gz: 58f820e3c067173aa657c137a0da9c2d3da94eb9b6ebe489281ea29a5185ee36c3a3f6bbba7bd1c4e5317845c629dfd6ce05b4a29c704e5bd457de589835be6d
-  data.tar.gz: 7df6f8eed3246238da8db8a8d5aa7d19ebd7a45c32c01951615de5314c729b713640192496e04f3fcb8fddcca0c2701d72c51970da4eb9d9a2c55333559c58ac
+  metadata.gz: 68394ff82c8d23b91accdd947529e352d09459d1fd6a5747ab4bb3ec7a53863b01cf8079fffb0e3f9b941c443451664e2acd2c4201ba7c06cea5b6bfe4ab584a
+  data.tar.gz: 33106cf36832dc6d082f278bf5d2a324d03274b37eb496828b29180587e812577b94387bcb9ec6428ed961710da9662c9b24b6b2923fe4f35003e196dcbd95f2

data/.travis.yml

@@ -3,14 +3,15 @@ rvm:
   - 2.0.0
   - 2.1.10
   - 2.2.10
-  - 2.3.7
-  - 2.4.4
-  - 2.5.1
+  - 2.3.8
+  - 2.4.5
+  - 2.5.3
   - jruby-9.1.16.0
+  - jruby-9.2.0.0
 matrix:
   include:
     - rvm: jruby
       env: JRUBY_OPTS='-Xcompat.version=2.0'
 bundler_args: --without guard
 before_install:
-  - if [ "jruby" != "$TRAVIS_RUBY_VERSION"  ]; then gem install bundler --without guard; fi
+  - if [ "jruby" != "$TRAVIS_RUBY_VERSION"  ]; then gem i rubygems-update -v '<3' && update_rubygems; gem install bundler -v 1.17.3 --without guard; fi

data/ext/ios_parser/c_lexer/lexer.c

@@ -2,6 +2,7 @@
 
 static VALUE rb_mIOSParser;
 static VALUE rb_cCLexer;
+static VALUE rb_cToken;
 VALUE rb_eLexError;
 
 typedef enum lex_token_state {
@@ -21,6 +22,9 @@ struct LexInfo {
     size_t pos;
     size_t token_start;
     size_t token_length;
+    size_t line;
+    size_t start_of_line;
+    size_t token_line;
     lex_token_state token_state;
     VALUE tokens;
     int indent;
@@ -46,13 +50,16 @@ typedef struct LexInfo LexInfo;
 
 #define CURRENT_CHAR(LEX) LEX->text[LEX->pos]
 #define TOKEN_EMPTY(LEX) LEX->token_length <= 0
+#define TOKEN_VALUE(TOK) RSTRUCT_GET(TOK, 0)
 
-#define MAKE_TOKEN(LEX, TOK) rb_ary_new3(2, rb_int_new(LEX->token_start), TOK)
-#define ADD_TOKEN(LEX, TOK) rb_ary_push(LEX->tokens, MAKE_TOKEN(LEX, TOK))
+#define ADD_TOKEN(LEX, TOK) rb_ary_push(LEX->tokens, make_token(LEX, TOK))
 
 #define CMD_LEN(CMD) (sizeof(CMD) - 1)
+
+static VALUE make_token(LexInfo *lex, VALUE tok);
+
 int is_certificate(LexInfo *lex) {
-    VALUE indent_ary, indent, command_ary, command;
+    VALUE indent_token, indent, command_token, command;
     int token_count, indent_pos, command_pos;
 
     token_count = RARRAY_LEN(lex->tokens);
@@ -62,16 +69,15 @@ int is_certificate(LexInfo *lex) {
     command_pos = token_count - 5;
     if (command_pos < 0) { return 0; }
 
-    indent_ary = rb_ary_entry(lex->tokens, indent_pos);
-    indent = rb_ary_entry(indent_ary, 1);
+    indent_token = rb_ary_entry(lex->tokens, indent_pos);
+    indent = TOKEN_VALUE(indent_token);
     if (TYPE(indent) != T_SYMBOL) { return 0; }
     if (rb_intern("INDENT") != SYM2ID(indent)) { return 0; }
 
-    command_ary = rb_ary_entry(lex->tokens, command_pos);
-    if (TYPE(command_ary) != T_ARRAY) { return 0; }
-    if (RARRAY_LEN(command_ary) < 2) { return 0; }
+    command_token = rb_ary_entry(lex->tokens, command_pos);
+    if (TYPE(command_token) != T_STRUCT) { return 0; }
 
-    command = rb_ary_entry(command_ary, 1);
+    command = TOKEN_VALUE(command_token);
     if (TYPE(command) != T_STRING) { return 0; }
 
     StringValue(command);
@@ -81,6 +87,33 @@ int is_certificate(LexInfo *lex) {
     return 1;
 }
 
+int is_authentication_banner_begin(LexInfo *lex) {
+    VALUE authentication_ary, authentication, banner_ary, banner;
+    int token_count = RARRAY_LEN(lex->tokens);
+    int authentication_pos = token_count -2;
+    int banner_pos = token_count - 1;
+
+    if (banner_pos < 0) { return 0; }
+
+    banner_ary = rb_ary_entry(lex->tokens, banner_pos);
+    banner = TOKEN_VALUE(banner_ary);
+    if (TYPE(banner) != T_STRING) { return 0; }
+
+    StringValue(banner);
+    if (RSTRING_LEN(banner) != CMD_LEN("banner")) { return 0; }
+    if (0 != strncmp(RSTRING_PTR(banner), "banner", 6)) { return 0; }
+
+    authentication_ary = rb_ary_entry(lex->tokens, authentication_pos);
+    authentication = TOKEN_VALUE(authentication_ary);
+    if (TYPE(authentication) != T_STRING) { return 0; }
+
+    StringValue(authentication);
+    if (RSTRING_LEN(authentication) != CMD_LEN("authentication")) { return 0; }
+    if (0 != strncmp(RSTRING_PTR(authentication), "authentication", 14)) { return 0; }
+
+    return 1;
+}
+
 int is_banner_begin(LexInfo *lex) {
     VALUE banner_ary, banner;
     int token_count = RARRAY_LEN(lex->tokens);
@@ -88,8 +121,10 @@ int is_banner_begin(LexInfo *lex) {
 
     if (banner_pos < 0) { return 0; }
 
+    if (is_authentication_banner_begin(lex)) { return 1; }
+
     banner_ary = rb_ary_entry(lex->tokens, banner_pos);
-    banner = rb_ary_entry(banner_ary, 1);
+    banner = TOKEN_VALUE(banner_ary);
     if (TYPE(banner) != T_STRING) { return 0; }
 
     StringValue(banner);
@@ -119,7 +154,7 @@ static void delimit(LexInfo *lex) {
     case (LEX_STATE_INTEGER):
         strncpy(string, &lex->text[lex->token_start], lex->token_length);
         string[lex->token_length] = '\0';
-        token = rb_int_new(atoi(string));
+        token = rb_int_new(atoll(string));
         break;
 
     case (LEX_STATE_DECIMAL):
@@ -148,6 +183,14 @@ static void deallocate(void * lex) {
     xfree(lex);
 }
 
+static VALUE make_token(LexInfo *lex, VALUE tok) {
+    return rb_struct_new(rb_cToken,
+                         tok,
+                         rb_int_new(lex->token_start),
+                         rb_int_new(lex->line),
+                         rb_int_new(lex->token_start - lex->start_of_line + 1));
+}
+
 static void mark(void *ptr) {
     LexInfo *lex = (LexInfo *)ptr;
     rb_gc_mark(lex->tokens);
@@ -164,6 +207,9 @@ static VALUE initialize(VALUE self, VALUE input_text) {
 
     lex->text = NULL;
     lex->pos = 0;
+    lex->line = 1;
+    lex->start_of_line = 0;
+    lex->token_line = 0;
     lex->token_start = 0;
     lex->token_length = 0;
     lex->token_state = LEX_STATE_ROOT;
@@ -180,6 +226,22 @@ static void process_root(LexInfo * lex);
 static void process_start_of_line(LexInfo * lex);
 static void start_banner(LexInfo * lex);
 
+static void find_start_of_line(LexInfo *lex, size_t from) {
+    size_t pos = from;
+
+    for (;;) {
+        if (IS_NEWLINE(lex->text[pos])) {
+            lex->start_of_line = pos + 1;
+            return;
+        } else if (pos <= 0) {
+            lex->start_of_line = 0;
+            return;
+        } else {
+            pos--;
+        }
+    }
+}
+
 static void process_newline(LexInfo *lex) {
     delimit(lex);
 
@@ -189,6 +251,8 @@ static void process_newline(LexInfo *lex) {
       lex->pos = lex->pos + 1;
       lex->token_start = lex->pos;
       lex->token_length = 0;
+      lex->token_line = 0;
+      lex->line = lex->line + 1;
       return;
     }
 
@@ -196,6 +260,7 @@ static void process_newline(LexInfo *lex) {
     ADD_TOKEN(lex, ID2SYM(rb_intern("EOL")));
     lex->token_state = LEX_STATE_INDENT;
     lex->indent = 0;
+    lex->line = lex->line + 1;
 }
 
 static void process_space(LexInfo *lex) {
@@ -204,11 +269,23 @@ static void process_space(LexInfo *lex) {
 
 static void process_comment(LexInfo *lex) {
     char c = CURRENT_CHAR(lex);
+    int token_count = RARRAY_LEN(lex->tokens);
+    VALUE last_token, last_value;
+
+    if (0 < token_count) {
+      last_token = rb_ary_entry(lex->tokens, token_count - 1);
+      last_value = TOKEN_VALUE(last_token);
+
+      if (TYPE(last_value) != T_SYMBOL) {
+        ADD_TOKEN(lex, ID2SYM(rb_intern("EOL")));
+      }
+    }
 
     if (IS_NEWLINE(c)) {
         delimit(lex);
         lex->token_state = LEX_STATE_INDENT;
         lex->indent = 0;
+        lex->line = lex->line + 1;
     }
 }
 
@@ -269,7 +346,7 @@ static void process_integer(LexInfo *lex) {
 }
 
 static void process_certificate(LexInfo *lex) {
-    char quit[5];
+    char quit[6] = "quit\n";
 
     strncpy(quit, &CURRENT_CHAR(lex) - 5, 5);
 
@@ -295,17 +372,31 @@ static void process_certificate(LexInfo *lex) {
         lex->token_length = 0;
 
         lex->token_start = lex->pos;
+        lex->line = lex->line + lex->token_line - 1;
+        find_start_of_line(lex, lex->pos);
         ADD_TOKEN(lex, ID2SYM(rb_intern("CERTIFICATE_END")));
 
-        process_newline(lex);
+        find_start_of_line(lex, lex->pos - 2);
+        lex->start_of_line++;
+        lex->token_start = lex->pos;
+        ADD_TOKEN(lex, ID2SYM(rb_intern("EOL")));
+
+        lex->token_state = LEX_STATE_INDENT;
+        lex->indent = 0;
+        lex->line = lex->line + 1;
+
         process_start_of_line(lex);
     } else {
+        if (IS_NEWLINE(CURRENT_CHAR(lex))) {
+            lex->token_line++;
+        }
         lex->token_length++;
     }
 }
 
 static void start_certificate(LexInfo *lex) {
     lex->indent_pos--;
+    lex->token_line = 0;
     rb_ary_pop(lex->tokens);
     rb_ary_pop(lex->tokens);
     ADD_TOKEN(lex, ID2SYM(rb_intern("CERTIFICATE_BEGIN")));
@@ -331,15 +422,22 @@ static void process_banner(LexInfo *lex) {
         lex->token_length++;
         delimit(lex);
         lex->token_start = lex->pos;
+        lex->line = lex->line + lex->token_line;
+        find_start_of_line(lex, lex->pos);
         ADD_TOKEN(lex, ID2SYM(rb_intern("BANNER_END")));
         if (lex->text[lex->pos + 1] == 'C') { lex->pos++; }
     } else if (!lex->banner_delimiter && is_banner_end_string(lex)) {
         lex->token_length -= 1;
         delimit(lex);
         lex->token_start = lex->pos;
+        lex->line = lex->line + lex->token_line;
+        find_start_of_line(lex, lex->pos);
         ADD_TOKEN(lex, ID2SYM(rb_intern("BANNER_END")));
     } else {
-        lex->token_length++;
+      if (IS_NEWLINE(lex->text[lex->pos + lex->token_length])) {
+        lex->token_line++;
+      }
+      lex->token_length++;
     }
 }
 
@@ -347,12 +445,17 @@ static void start_banner(LexInfo *lex) {
     char c = CURRENT_CHAR(lex);
     lex->banner_delimiter = (c == '\n') ? 0 : c;
     ADD_TOKEN(lex, ID2SYM(rb_intern("BANNER_BEGIN")));
+    if ('\n' == lex->text[lex->pos + 1]) lex->line++;
     if ('\n' == lex->text[lex->pos + 2]) lex->pos++;
 }
 
 static void process_start_of_line(LexInfo *lex) {
     char c = CURRENT_CHAR(lex);
 
+    if (lex->indent == 0) {
+        lex->start_of_line = lex->pos;
+    }
+
     if (IS_SPACE(c)) {
         lex->indent++;
         return;
@@ -487,7 +590,8 @@ static VALUE call(VALUE self, VALUE input_text) {
     }
 
     delimit(lex);
-    lex->token_start = lex->pos;
+    lex->token_start = lex->pos - 1;
+    lex->line = lex->line - 1;
 
     for (; lex->indent_pos > 0; lex->indent_pos--) {
         ADD_TOKEN(lex, ID2SYM(rb_intern("DEDENT")));
@@ -501,6 +605,7 @@ void Init_c_lexer() {
     rb_cCLexer = rb_define_class_under(rb_mIOSParser, "CLexer", rb_cObject);
     rb_eLexError = rb_define_class_under(rb_mIOSParser, "LexError",
                                          rb_eStandardError);
+    rb_cToken = rb_path2class("IOSParser::Token");
     rb_define_alloc_func(rb_cCLexer, allocate);
     rb_define_method(rb_cCLexer, "initialize", initialize, 0);
     rb_define_method(rb_cCLexer, "call", call, 1);

data/lib/ios_parser/ios/command.rb

@@ -6,19 +6,22 @@ module IOSParser
     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
+      attr_accessor :commands, :parent, :document, :indent, :tokens
+      def initialize(tokens: [], commands: [],
+                     parent: nil, document: nil, indent: nil)
+        @tokens = tokens
         @commands = commands
         @parent = parent
-        @pos = pos
         @document = document
+        @indent = indent || 0
+      end
+
+      def args
+        tokens.map(&:value)
       end
 
       def name
-        args[0]
+        tokens.first.value
       end
 
       def ==(other)
@@ -37,6 +40,10 @@ module IOSParser
         parent ? parent.path + [parent.line] : []
       end
 
+      def pos
+        tokens.first && tokens.first.pos
+      end
+
       def indentation(base: 0)
         ' ' * (path.length - base)
       end
@@ -48,9 +55,10 @@ module IOSParser
 
       def inspect
         "<IOSParser::IOS::Command:0x#{object_id.to_s(16)} "\
-        "@args=#{args.inspect}, "\
+        "@tokens=#{tokens.inspect}, "\
         "@commands=#{commands.inspect}, "\
         "@pos=#{pos.inspect}, "\
+        "@indent=#{indent}, "\
         "@document=<IOSParser::IOS::Document:0x#{document.object_id.to_s(16)}>>"
       end
 
@@ -63,7 +71,8 @@ module IOSParser
         {
           args: args,
           commands: commands.map(&:to_hash),
-          pos: pos
+          pos: pos,
+          indent: indent
         }
       end
 

data/lib/ios_parser/ios.rb

@@ -11,6 +11,7 @@ module IOSParser
       @document = Document.new(nil)
       @parent = parent
       @lexer  = lexer
+      @indent = 0
     end
 
     def tokens
@@ -29,40 +30,50 @@ module IOSParser
 
     def section(parent = nil)
       [].tap do |commands|
-        until tokens.empty? || tokens.first.last == :DEDENT
+        until tokens.empty? || tokens.first.value == :DEDENT
           commands.push(command(parent, @document))
         end
-        tokens.shift # discard :DEDENT
+        token = tokens.shift # discard :DEDENT
+        @indent -= 1 if token && token.value == :DEDENT
       end
     end
 
     def command(parent = nil, document = nil)
-      pos = tokens.first.first
-      opts = { args: arguments, parent: parent, document: document, pos: pos }
+      opts = {
+        tokens: command_tokens,
+        parent: parent,
+        document: document,
+        indent: @indent
+      }
 
       Command.new(opts).tap do |cmd|
         cmd.commands = subsections(cmd)
       end
     end
 
+    def command_tokens
+      toks = []
+      until tokens.empty? || tokens.first.value == :EOL
+        tok = tokens.shift
+        toks << tok unless argument_to_discard?(tok.value)
+      end
+      tokens.shift # discard :EOL
+      toks
+    end
+
+    def argument_to_discard?(arg)
+      arguments_to_discard.include?(arg)
+    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
+      if !tokens.empty? && tokens.first.value == :INDENT
+        @indent += 1
         tokens.shift # discard :INDENT
         section(parent)
       else

data/lib/ios_parser/lexer.rb

@@ -3,6 +3,7 @@ module IOSParser
     LexError = IOSParser::LexError
 
     attr_accessor :tokens, :token, :indents, :indent, :state, :char,
+                  :line, :start_of_line, :token_line,
                   :string_terminator
 
     def initialize
@@ -12,8 +13,10 @@ module IOSParser
       @indent  = 0
       @indents = [0]
       @state   = :root
-      @token_char = 0
-      @this_char  = -1
+      @this_char = -1
+      @line = 1
+      @start_of_line = 0
+      @token_line = 0
     end
 
     def call(input_text)
@@ -57,16 +60,37 @@ module IOSParser
       end
     end
 
-    def make_token(value, pos: nil)
+    def make_token(value, pos: nil, col: nil)
       pos ||= @token_start || @this_char
+      col ||= pos - start_of_line + 1
       @token_start = nil
-      [pos, value]
+      Token.new(value, pos, line, col)
+    end
+
+    def find_start_of_line(from: @this_char)
+      from.downto(0) do |pos|
+        if @text[pos] == "\n"
+          self.start_of_line = pos + 1
+          return start_of_line
+        end
+      end
+
+      self.line_start = 0
     end
 
     def comment
       self.state = :comment
-      update_indentation
-      self.state = :root if newline?
+      tokens << make_token(:EOL) if tokens.last &&
+                                    !tokens.last.value.is_a?(Symbol)
+      comment_newline if newline?
+    end
+
+    def comment_newline
+      delimit
+      self.start_of_line = @this_char + 1
+      self.state = :line_start
+      self.indent = 0
+      self.line += 1
     end
 
     def comment?
@@ -79,16 +103,25 @@ module IOSParser
 
     def banner_begin
       self.state = :banner
+      self.token_line = 0
       tokens << make_token(:BANNER_BEGIN)
       @token_start = @this_char + 2
       @banner_delimiter = char == "\n" ? 'EOF' : char
+      return unless @text[@this_char + 1] == "\n"
+      self.token_line -= 1
+      self.line += 1
     end
 
     def banner_begin?
-      tokens[-2] && tokens[-2].last == 'banner'
+      tokens[-2] && (
+        tokens[-2].value == 'banner' ||
+        tokens[-2..-1].map(&:value) == %w[authentication banner]
+      )
     end
 
     def banner
+      self.token_line += 1 if newline?
+
       if banner_end_char?
         banner_end_char
       elsif banner_end_string?
@@ -101,7 +134,10 @@ module IOSParser
     def banner_end_string
       self.state = :root
       token.chomp!(@banner_delimiter[0..-2])
-      tokens << make_token(token) << make_token(:BANNER_END)
+      tokens << make_token(token)
+      self.line += token_line
+      find_start_of_line
+      tokens << make_token(:BANNER_END)
       self.token = ''
     end
 
@@ -112,7 +148,10 @@ module IOSParser
     def banner_end_char
       self.state = :root
       banner_end_clean_token
-      tokens << make_token(token) << make_token(:BANNER_END)
+      tokens << make_token(token)
+      self.line += token_line
+      find_start_of_line
+      tokens << make_token(:BANNER_END)
       self.token = ''
     end
 
@@ -134,42 +173,60 @@ module IOSParser
     end
 
     def banner_garbage?(pos)
-      tokens[pos].last == :BANNER_END && tokens[pos + 1].last == 'C'
+      tokens[pos].value == :BANNER_END && tokens[pos + 1].value == 'C'
     end
 
     def certificate_begin?
-      tokens[-6] && tokens[-6].last == :INDENT &&
-        tokens[-5] && tokens[-5].last == 'certificate'
+      tokens[-6] && tokens[-6].value == :INDENT &&
+        tokens[-5] && tokens[-5].value == 'certificate'
     end
 
     def certificate_begin
       self.state = :certificate
       indents.pop
-      tokens[-2..-1] = [make_token(:CERTIFICATE_BEGIN, pos: tokens[-1][0])]
+      tokens[-2..-1] = [make_token(:CERTIFICATE_BEGIN, pos: tokens[-1].pos)]
+      self.token_line = 0
       certificate
     end
 
     def certificate
-      token[-5..-1] == "quit\n" ? certificate_end : token << char
+      if token.end_with?("quit\n")
+        certificate_end
+      else
+        self.token_line += 1 if char == "\n"
+        token << char
+      end
     end
 
     def certificate_end
       tokens.concat certificate_end_tokens
+      self.line += 1
       update_indentation
       @token_start = @this_char
 
       @token = ''
       self.state = :line_start
       self.indent = 0
+      self.line += 1
       root
     end
 
+    # rubocop: disable AbcSize
     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)
-      ]
+      cluster = []
+      cluster << make_token(certificate_token_value, pos: tokens[-1].pos)
+      self.line += self.token_line - 1
+      cluster << make_token(:CERTIFICATE_END, pos: @this_char, col: 1)
+      find_start_of_line(from: @this_char - 2)
+      cluster << make_token(:EOL,
+                            pos: @this_char,
+                            col: @this_char - start_of_line)
+      cluster
+    end
+    # rubocop: enable AbcSize
+
+    def certificate_token_value
+      token[0..-6].gsub!(/\s+/, ' ').strip
     end
 
     def integer
@@ -235,7 +292,7 @@ module IOSParser
 
     def space
       delimit
-      self.indent += 1 if tokens.last && tokens.last.last == :EOL
+      self.indent += 1 if tokens.last && tokens.last.value == :EOL
     end
 
     def space?
@@ -266,6 +323,8 @@ module IOSParser
       self.state = :line_start
       self.indent = 0
       tokens << make_token(:EOL)
+      self.start_of_line = @this_char + 1
+      self.line += 1
     end
 
     def newline?
@@ -302,7 +361,14 @@ module IOSParser
     end
 
     def pop_dedent
-      tokens << make_token(:DEDENT)
+      col =
+        if tokens.last.line == line
+          tokens.last.col
+        else
+          1
+        end
+
+      tokens << make_token(:DEDENT, col: col)
       indents.pop
     end
 
@@ -319,6 +385,7 @@ module IOSParser
       end
 
       delimit
+      self.line -= 1
       update_indentation
       scrub_banner_garbage
       tokens

data/lib/ios_parser/token.rb

@@ -0,0 +1,8 @@
+module IOSParser
+  Token = Struct.new(
+    :value,
+    :pos,
+    :line,
+    :col
+  )
+end

data/lib/ios_parser/version.rb

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

data/lib/ios_parser.rb

@@ -1,4 +1,5 @@
 require 'json'
+require 'ios_parser/token'
 
 module IOSParser
   class LexError < StandardError; end
@@ -6,11 +7,27 @@ module IOSParser
   def self.lexer
     if const_defined?(:PureLexer)
       PureLexer
+    else
+      c_lexer
+    end
+  rescue LoadError
+    pure_lexer
+  end
+
+  def self.c_lexer
+    if RUBY_VERSION < '2.1'
+      warn 'The C Lexer requires Ruby 2.1 or later. The pure Ruby lexer will '\
+           'be used instead. You can eliminate this warning by upgrading ruby '\
+           'or explicitly using the pure-Ruby lexer '\
+           "(require 'ios_parser/pure')"
+      pure_lexer
     else
       require_relative 'ios_parser/c_lexer'
       CLexer
     end
-  rescue LoadError
+  end
+
+  def self.pure_lexer
     require 'ios_parser/lexer'
     PureLexer
   end

data/spec/lib/ios_parser/ios_spec.rb

@@ -25,22 +25,26 @@ module IOSParser
                     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 },
+                                 commands: [
+                                   { args: %w[set dscp cs1],
+                                     commands: [], pos: 114, indent: 3 }
+                                 ],
+                                 pos: 50, indent: 2 }],
+                    pos: 24, indent: 1 },
 
                   { 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 }]
+                                 commands: [
+                                   { args: %w[set dscp cs2],
+                                     commands: [], pos: 214, indent: 3 },
+                                   { args: ['command_with_no_args'],
+                                     commands: [], pos: 230, indent: 3 }
+                                 ],
+                                 pos: 150, indent: 2 }],
+                    pos: 128, indent: 1 }],
+               pos: 0, indent: 0 }]
         }
       end
 
@@ -59,9 +63,9 @@ module IOSParser
         it('can be searched by an exact command') do
           expect(subject.find_all(name: 'set').map(&:to_hash))
             .to eq [{ args: %w[set dscp cs1],
-                      commands: [], pos: 114 },
+                      commands: [], pos: 114, indent: 3 },
                     { args: %w[set dscp cs2],
-                      commands: [], pos: 214 }]
+                      commands: [], pos: 214, indent: 3 }]
         end
 
         context 'can be searched by name and the first argument' do
@@ -92,8 +96,8 @@ module IOSParser
               [{ args: ['police', 300_000_000, 1_000_000, 'exceed-action',
                         'policed-dscp-transmit'],
                  commands: [{ args: %w[set dscp cs1],
-                              commands: [], pos: 114 }],
-                 pos: 50 }]
+                              commands: [], pos: 114, indent: 3 }],
+                 pos: 50, indent: 2 }]
             end
 
             context 'integer query' do
@@ -115,7 +119,7 @@ module IOSParser
                     .find('set')
                     .to_hash)
               .to eq(args: %w[set dscp cs1],
-                     commands: [], pos: 114)
+                     commands: [], pos: 114, indent: 3)
           end
         end # context 'nested search'
 
@@ -252,15 +256,15 @@ module IOSParser
         cmd_ary = [
           { args: ['ip', 'route', '10.0.0.1', '255.255.255.255',
                    'Null0'],
-            commands: [], pos: 0 },
+            commands: [], pos: 0, indent: 0 },
           { args: ['ip', 'route', '9.9.9.199', '255.255.255.255',
                    '42.42.42.142', 'name', 'PONIES'],
-            commands: [], pos: 40 },
+            commands: [], pos: 40, indent: 0 },
           { args: ['ip', 'route', 'vrf', 'Mgmt-intf', '0.0.0.0',
                    '0.0.0.0', '9.9.9.199'],
-            commands: [], pos: 100 },
+            commands: [], pos: 100, indent: 0 },
           { args: ['ip', 'route', '0.0.0.0/0', '11.11.0.111', 120],
-            commands: [], pos: 149 }
+            commands: [], pos: 149, indent: 0 }
         ]
 
         expect(result.find_all('ip route').map(&:to_hash)).to eq(cmd_ary)
@@ -269,7 +273,7 @@ module IOSParser
 
         cmd_hash = { args: ['ip', 'route', '9.9.9.199', '255.255.255.255',
                             '42.42.42.142', 'name', 'PONIES'],
-                     commands: [], pos: 40 }
+                     commands: [], pos: 40, indent: 0 }
         expect(result.find('ip route 9.9.9.199').to_hash).to eq(cmd_hash)
       end # end context '#call'
 

data/spec/lib/ios_parser/lexer_spec.rb

@@ -40,11 +40,11 @@ END
            'set', 'dscp', 'cs2', :EOL, :DEDENT, :DEDENT, :DEDENT]
         end
 
-        subject { klass.new.call(input).map(&:last) }
+        subject { klass.new.call(input).map(&:value) }
         it('enclosed in symbols') { should == output }
 
         it('enclosed in symbols (using the pure ruby lexer)') do
-          expect(subject_pure.map(&:last)).to eq output
+          expect(subject_pure.map(&:value)).to eq output
         end
       end
 
@@ -75,12 +75,12 @@ END
 
           it 'pure' do
             tokens = IOSParser::PureLexer.new.call(input)
-            expect(tokens.map(&:last)).to eq expectation
+            expect(tokens.map(&:value)).to eq expectation
           end # it 'pure' do
 
           it 'default' do
             tokens = IOSParser.lexer.new.call(input)
-            expect(tokens.map(&:last)).to eq expectation
+            expect(tokens.map(&:value)).to eq expectation
           end # it 'c' do
         end # context 'indented region' do
       end # context 'ASR indented regions' do
@@ -97,9 +97,11 @@ 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]]
+          [[0, 1, 1, 'banner'], [7, 1, 8, 'foobar'],
+           [14, 1, 15, :BANNER_BEGIN],
+           [16, 2, 17, "asdf 1234 9786 asdf\nline 2\nline 3\n  "],
+           [52, 5, 3, :BANNER_END], [53, 5, 4, :EOL]]
+            .map { |pos, line, col, val| Token.new(val, pos, line, col) }
         end
 
         it('tokenized and enclosed in symbols') { should == output }
@@ -119,8 +121,8 @@ END
           ['banner', 'exec', :BANNER_BEGIN, content, :BANNER_END, :EOL]
         end
 
-        it { expect(subject.map(&:last)).to eq output }
-        it { expect(subject_pure.map(&:last)).to eq output }
+        it { expect(subject.map(&:value)).to eq output }
+        it { expect(subject_pure.map(&:value)).to eq output }
       end
 
       context 'complex eos banner' do
@@ -131,14 +133,37 @@ END
           ['banner', 'motd', :BANNER_BEGIN, content, :BANNER_END, :EOL]
         end
 
-        it { expect(subject.map(&:last)).to eq output }
-        it { expect(subject_pure.map(&:last)).to eq output }
+        it { expect(subject.map(&:value)).to eq output }
+        it { expect(subject_pure.map(&:value)).to eq output }
+      end
+
+      context 'aaa authentication banner' do
+        let(:input) { <<END.unindent }
+        aaa authentication banner ^C
+        xyz
+        ^C
+        aaa blah
+END
+
+        let(:output) do
+          ['aaa', 'authentication', 'banner',
+           :BANNER_BEGIN, "xyz\n", :BANNER_END, :EOL,
+           'aaa', 'blah', :EOL]
+        end
+
+        it 'lexes (c lexer)' do
+          expect(subject.map(&:value)).to eq output
+        end
+
+        it 'lexes (ruby lexer)' do
+          expect(subject_pure.map(&:value)).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) }
+        subject { klass.new.call(input).map(&:value) }
         it('converts to Float') { should == output }
       end
 
@@ -156,29 +181,33 @@ 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,
+          [[0, 1, 1, 'crypto'],
+           [7, 1, 8, 'pki'],
+           [11, 1, 12, 'certificate'],
+           [23, 1, 24, 'chain'],
+           [29, 1, 30, 'TP-self-signed-0123456789'],
+           [54, 1, 55, :EOL],
+           [56, 2, 2, :INDENT],
+           [56, 2, 2, 'certificate'],
+           [68, 2, 14, 'self-signed'],
+           [80, 2, 26, '01'],
+           [85, 3, 3, :CERTIFICATE_BEGIN],
+           [85, 3, 3,
             '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]]
+           [323, 6, 1, :CERTIFICATE_END],
+           [323, 6, 13, :EOL],
+           [323, 7, 1, :DEDENT]]
+            .map { |pos, line, col, val| Token.new(val, pos, line, col) }
         end
 
         subject { klass.new.call(input) }
-        it('tokenized') { expect(subject).to eq output }
+
+        it('tokenized') do
+          expect(subject).to eq output
+        end
 
         it('tokenized (using the pure ruby lexer)') do
           expect(subject_pure).to eq output
@@ -187,8 +216,8 @@ 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) }
+        let(:output) { ['ip', 'addr', '127.0.0.0.1', :EOL] }
+        subject { klass.new.call(input).map(&:value) }
         it('dropped') { should == output }
       end
 
@@ -211,20 +240,20 @@ END
           ]
         end
 
-        it { expect(subject_pure.map(&:last)).to eq output }
-        it { expect(subject.map(&:last)).to eq output }
+        it { expect(subject_pure.map(&:value)).to eq output }
+        it { expect(subject.map(&:value)).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']
-          ]
+            [0,  1, 1, 'switchport'],
+            [11, 1, 12, 'trunk'],
+            [17, 1, 18, 'allowed'],
+            [25, 1, 26, 'vlan'],
+            [30, 1, 31, '50-90']
+          ].map { |pos, line, col, val| Token.new(val, pos, line, col) }
         end
         it { should == output }
       end # context 'vlan range' do
@@ -247,31 +276,31 @@ END
           ]
         end
 
-        it { expect(subject_pure.map(&:last)).to eq output }
+        it { expect(subject_pure.map(&:value)).to eq output }
       end
 
       context '# in the middle of a line is not a comment' do
         let(:input) { "vlan 1\n name #31337" }
         let(:output) { ['vlan', 1, :EOL, :INDENT, 'name', '#31337', :DEDENT] }
 
-        it { expect(subject_pure.map(&:last)).to eq output }
-        it { expect(subject.map(&:last)).to eq output }
+        it { expect(subject_pure.map(&:value)).to eq output }
+        it { expect(subject.map(&:value)).to eq output }
       end
 
       context '# at the start of a line is a comment' do
         let(:input) { "vlan 1\n# comment\nvlan 2" }
         let(:output) { ['vlan', 1, :EOL, 'vlan', 2] }
 
-        it { expect(subject_pure.map(&:last)).to eq output }
-        it { expect(subject.map(&:last)).to eq output }
+        it { expect(subject_pure.map(&:value)).to eq output }
+        it { expect(subject.map(&:value)).to eq output }
       end
 
       context '# after indentation is a comment' do
         let(:input) { "vlan 1\n # comment\nvlan 2" }
         let(:output) { ['vlan', 1, :EOL, :INDENT, :DEDENT, 'vlan', 2] }
 
-        it { expect(subject_pure.map(&:last)).to eq output }
-        it { expect(subject.map(&:last)).to eq output }
+        it { expect(subject_pure.map(&:value)).to eq output }
+        it { expect(subject.map(&:value)).to eq output }
       end
 
       context 'unterminated quoted string' do
@@ -285,6 +314,84 @@ END
           expect { subject }.to raise_error(pattern)
         end
       end
+
+      context 'subcommands separated by comment line' do
+        let(:input) do
+          <<-END.unindent
+            router static
+             address-family ipv4 unicast
+             !
+             address-family ipv6 unicast
+          END
+        end
+
+        let(:expected) do
+          expected_full.map(&:value)
+        end
+
+        let(:expected_full) do
+          [
+            [0,  1, 1, 'router'],
+            [7,  1, 8, 'static'],
+            [13, 1, 14, :EOL],
+            [15, 2, 2, :INDENT],
+            [15, 2, 2, 'address-family'],
+            [30, 2, 17, 'ipv4'],
+            [35, 2, 22, 'unicast'],
+            [42, 2, 29, :EOL],
+            [47, 4, 2, 'address-family'],
+            [62, 4, 17, 'ipv6'],
+            [67, 4, 22, 'unicast'],
+            [74, 4, 29, :EOL],
+            [74, 4, 29, :DEDENT]
+          ].map { |pos, line, col, val| Token.new(val, pos, line, col) }
+        end
+
+        it 'lexes both subcommands' do
+          expect(subject.map(&:value)).to eq expected
+        end
+
+        it 'lexes both subcommands (with the pure ruby lexer)' do
+          expect(subject_pure.map(&:value)).to eq expected
+        end
+
+        it 'lexes position, line, and column' do
+          expect(subject).to eq expected_full
+        end
+
+        it 'lexes position, line, and column (with the pure ruby lexer)' do
+          expect(subject_pure).to eq expected_full
+        end
+      end
+
+      context 'comment at end of line' do
+        let(:input) do
+          <<-END.unindent
+            description !
+            switchport access vlan 2
+          END
+        end
+
+        let(:output) do
+          ['description', :EOL, 'switchport', 'access', 'vlan', 2, :EOL]
+        end
+
+        it { expect(subject_pure.map(&:value)).to eq output }
+        it { expect(subject.map(&:value)).to eq output }
+      end # context 'comment at end of line' do
+
+      context 'large integers up to 2^63-1' do
+        let(:input) do
+          "42 4200000000 9223372036854775807"
+        end
+
+        let(:output) do
+          [42, 4200000000, 9223372036854775807]
+        end
+
+        it { expect(subject_pure.map(&:value)).to eq output }
+        it { expect(subject.map(&:value)).to eq output }
+      end # context 'large integers up to 2^63-1' do
     end
   end
 end

data/spec/lib/ios_parser_spec.rb

@@ -24,22 +24,26 @@ describe IOSParser do
                     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 },
+                                 commands: [
+                                   { args: %w[set dscp cs1],
+                                     commands: [], pos: 114, indent: 3 }
+                                 ],
+                                 pos: 50, indent: 2 }],
+                    pos: 24, indent: 1 },
 
                   { 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 }]
+                                 commands: [
+                                   { args: %w[set dscp cs2],
+                                     commands: [], pos: 214, indent: 3 },
+                                   { args: ['command_with_no_args'],
+                                     commands: [], pos: 230, indent: 3 }
+                                 ],
+                                 pos: 150, indent: 2 }],
+                    pos: 128, indent: 1 }],
+               pos: 0, indent: 0 }]
         }
       end
 
@@ -70,15 +74,18 @@ describe IOSParser do
                   {
                     args: %w[description blah blah blah],
                     commands: [],
-                    pos: 29
+                    pos: 29,
+                    indent: 1
                   },
                   {
                     args: ['match', 'access-group', 'fred'],
                     commands: [],
-                    pos: 57
+                    pos: 57,
+                    indent: 1
                   }
                 ],
-                pos: 0
+                pos: 0,
+                indent: 0
               }
             ]
         }
@@ -92,5 +99,22 @@ describe IOSParser do
         expect(actual).to eq(output)
       end
     end # context "partial outdent" do
+
+    context 'comment at end of line' do
+      let(:input) do
+        <<END.unindent
+          description !
+          switchport access vlan 2
+END
+      end
+
+      subject { described_class.parse(input) }
+
+      it 'parses both commands' do
+        should be_a IOSParser::IOS::Document
+        expect(subject.find(starts_with: 'description')).not_to be_nil
+        expect(subject.find(starts_with: 'switchport')).not_to be_nil
+      end
+    end
   end # describe '.parse'
 end # describe IOSParser

data/spec/spec_helper.rb

@@ -1,5 +1,9 @@
 $LOAD_PATH << File.dirname(__FILE__) + '/../lib'
 
+RSpec.configure do |rspec|
+  rspec.filter_run_when_matching(focus: true)
+end
+
 def klass
   described_class
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ios_parser
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.7.1
 platform: ruby
 authors:
 - Ben Miller
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-11-10 00:00:00.000000000 Z
+date: 2022-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -52,7 +52,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.54'
-description: 
+description:
 email: bjmllr@gmail.com
 executables: []
 extensions:
@@ -84,6 +84,7 @@ files:
 - lib/ios_parser/ios/queryable.rb
 - lib/ios_parser/lexer.rb
 - lib/ios_parser/pure.rb
+- lib/ios_parser/token.rb
 - lib/ios_parser/version.rb
 - spec/lib/ios_parser/ios/queryable_spec.rb
 - spec/lib/ios_parser/ios_spec.rb
@@ -94,7 +95,7 @@ homepage: https://github.com/bjmllr/ios_parser
 licenses:
 - GPL-3.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -109,9 +110,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: convert network switch and router config files to structured data
 test_files: