ios_parser 0.3.0

data/lib/ios_parser/ios/command.rb

@@ -0,0 +1,90 @@
+require 'json'
+require_relative 'queryable'
+
+module IOSParser
+  class IOS
+    class Command
+      include Queryable, Enumerable
+      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,53 @@
+require 'json'
+require_relative 'queryable'
+require_relative 'command'
+
+module IOSParser
+  class IOS
+    class Document
+      include Queryable, Enumerable
+      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,218 @@
+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(raw)
+            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, b)
+            case a
+            when String
+              a == b.to_s
+            else
+              a === b
+            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.any? { |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,70 @@
+require_relative 'ios/document'
+
+module IOSParser
+  class IOS
+    attr_accessor :lexer, :tokens, :source, :document
+
+    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

data/lib/ios_parser/lexer.rb

@@ -0,0 +1,278 @@
+module IOSParser
+  class PureLexer
+    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)
+      initialize
+
+      input_text.each_char.with_index do |c, i|
+        @this_char = i
+        self.char = c
+        send(state)
+      end
+
+      delimit
+      update_indentation
+      scrub_banner_garbage
+      tokens
+    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 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 == '#' || char == '!'
+    end
+
+    def banner_begin
+      self.state = :banner
+      tokens << make_token(:BANNER_BEGIN)
+      @token_start = @this_char + 2
+      @banner_delimiter = char
+    end
+
+    def banner_begin?
+      tokens[-2] && tokens[-2].last == 'banner'
+    end
+
+    def banner
+      char == @banner_delimiter ? banner_end : token << char
+    end
+
+    def banner_end
+      self.state = :root
+      banner_end_clean_token
+      tokens << make_token(token) << make_token(:BANNER_END)
+      self.token = ''
+    end
+
+    def banner_end_clean_token
+      token.slice!(0) if token[0] == 'C'
+      token.slice!(0) if ["\n", ' '].include?(token[0])
+      token.chomp!("\n")
+    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?(i)
+      tokens[i].last == :BANNER_END && tokens[i + 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
+      case
+      when dot?   then decimal
+      when digit? then token << char
+      when 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
+      case
+      when digit? then token << char
+      when dot?   then token << char
+      when 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
+      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
+      end
+    end
+
+    def delimit
+      return if token.empty?
+      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
+
+    class LexError < StandardError; 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.3.0'
+    end
+  end
+end