threatinator 0.1.1

data/lib/threatinator/parsers/getline.rb

@@ -0,0 +1,8 @@
+module Threatinator
+  module Parsers
+    module Getline
+      require 'threatinator/parsers/getline/parser'
+    end
+  end
+end
+

data/lib/threatinator/parsers/getline/parser.rb

@@ -0,0 +1,45 @@
+require 'threatinator/record'
+require 'threatinator/parser'
+
+module Threatinator
+  module Parsers
+    module Getline
+      # Parses an IO, yielding each 'line' of data as deliniated by :separator.
+      # The text matching :separator will be included.
+      class Parser < Threatinator::Parser
+        attr_reader :separator
+
+        # @param [Hash] opts 
+        # @option opts [String] :separator ("\n") A character that will be used
+        #  to detect the end of a line.
+        def initialize(opts = {})
+          @separator = opts.delete(:separator) || "\n"
+          unless @separator.length == 1
+            raise ArgumentError.new(":separator must be exactly one character long")
+          end
+          super(opts)
+        end
+
+        def ==(other)
+          @separator == other.separator &&
+            super(other)
+        end
+
+        # @param [IO] io The IO to be parsed
+        # @yield [line] Gives one line to the block
+        # @yieldparam line [String] a line from the IO stream.
+        def run(io)
+          return enum_for(:each) unless block_given?
+          lineno = 1
+          while str = io.gets(@separator)
+            return if str.nil?
+            pos_start = io.pos - str.length
+            yield Record.new(str, line_number: lineno, pos_start: pos_start, pos_end: io.pos)
+            lineno += 1
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/threatinator/parsers/json.rb

@@ -0,0 +1,8 @@
+module Threatinator
+  module Parsers
+    module JSON
+      require 'threatinator/parsers/json/parser'
+    end
+  end
+end
+

data/lib/threatinator/parsers/json/adapters/oj.rb

@@ -0,0 +1,65 @@
+require 'threatinator/parsers/json'
+require 'threatinator/exceptions'
+require 'oj'
+
+module Threatinator::Parsers::JSON::Adapters
+  class Oj < ::Oj::ScHandler
+    def initialize
+      @root = nil
+      @depth = 0
+    end
+
+    def run(io, &callback)
+      @callback = callback
+      begin
+        ::Oj.sc_parse(self, io)
+      rescue ::Oj::ParseError => e
+        raise Threatinator::Exceptions::ParseError.new(e)
+      end
+    end
+
+    def do_callback(data, key = nil)
+      @callback.call(data, key: key)
+    end
+
+    def hash_start
+      ret = {}
+      @depth += 1
+      @root = ret if @root.nil?
+      ret
+    end
+
+    def hash_set(h,k,v)
+      if @depth == 1
+        do_callback(v, k)
+      else 
+        h[k] = v
+      end
+      v
+    end
+
+    def hash_end
+      @depth -= 1
+    end
+
+    def array_start
+      ret = []
+      @depth += 1
+      @root = ret if @root.nil?
+      ret
+    end
+
+    def array_append(a,v)
+      if @depth == 1
+        do_callback(v)
+      else 
+        a << v
+      end
+    end
+
+    def array_end
+      @depth -= 1
+    end
+  end
+end
+

data/lib/threatinator/parsers/json/parser.rb

@@ -0,0 +1,45 @@
+require 'threatinator/parser'
+require 'threatinator/parsers/json/record'
+
+module Threatinator
+  module Parsers
+    module JSON
+      class Parser < Threatinator::Parser
+        def initialize(opts = {})
+          @adapter_class = self.class.adapter_class
+          super(opts)
+        end
+
+        # Detects the platform, loads the JSON adapter, and returns the 
+        # adapter's class.
+        def self.adapter_class
+          if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+            #:nocov:
+            raise "JSON parsing not supported for JRuby"
+            #:nocov:
+          else 
+            require 'threatinator/parsers/json/adapters/oj'
+            return Threatinator::Parsers::JSON::Adapters::Oj
+          end
+        end
+
+        def ==(other)
+          super(other)
+        end
+
+        # @param [IO] io
+        # @yield [record] Gives one line to the block
+        # @yieldparam record [Threatinator::Parsers::JSON::Record] a record
+        def run(io)
+          adapter = @adapter_class.new
+          callback = lambda do |object, opts = {}|
+            yield Threatinator::Parsers::JSON::Record.new(object, opts)
+          end
+          adapter.run(io, &callback)
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/threatinator/parsers/json/record.rb

@@ -0,0 +1,20 @@
+require 'threatinator/record'
+
+module Threatinator
+  module Parsers
+    module JSON
+      class Record < Threatinator::Record
+        attr_reader :key
+        def initialize(object, opts = {})
+          @key = opts.delete(:key)
+          super(object, opts)
+        end
+
+        def ==(other)
+          @key == other.key &&
+            super(other)
+        end
+      end
+    end
+  end
+end

data/lib/threatinator/parsers/xml.rb

@@ -0,0 +1,8 @@
+module Threatinator
+  module Parsers
+    module XML
+      require 'threatinator/parsers/xml/parser'
+      require 'threatinator/parsers/xml/pattern'
+    end
+  end
+end

data/lib/threatinator/parsers/xml/node.rb

@@ -0,0 +1,79 @@
+module Threatinator
+  module Parsers
+    module XML
+      class Node
+        attr_accessor :text
+        attr_reader :name
+        attr_reader :attrs
+        attr_reader :children
+
+        # @param [String, Symbol] name
+        # @param [Hash] opts 
+        # @option opts [String] :text The text
+        # @option opts [Hash] :attrs The attributes
+        # @option opts [Array<Threatinator::Parsers::XML::Node>] :children An array 
+        #   of child child nodes that belong to this node.
+        def initialize(name, opts = {})
+          unless name.kind_of?(::Symbol) or name.kind_of?(::String)
+            raise TypeError.new("name must be a String or a Symbol")
+          end
+
+          @name = name.to_sym
+          @text = opts.delete(:text) || ""
+          unless @text.kind_of?(::String)
+            raise TypeError.new(":text must be a String")
+          end
+          @attrs = opts.delete(:attrs) || {}
+          unless @attrs.kind_of?(::Hash)
+            raise TypeError.new(":text must be a Hash")
+          end
+
+          @children = {}
+          if _children = opts.delete(:children)
+            _children.each do |child|
+              add_child(child)
+            end
+          end
+        end
+
+        def ==(other)
+          @name == other.name &&
+            @attrs == other.attrs &&
+            @text == other.text &&
+            @children == other.children
+        end
+
+        def eql?(other)
+          other.kind_of?(self.class) &&
+            self == other
+        end
+
+        # @return [Integer] the number of children
+        def num_children
+          @children.values.inject(0) {|total, child_set| total + child_set.count}
+        end
+
+        # @param [String, Symbol] name The name of the child element
+        # @return [Array<Node>] An array containing all the child nodes for the given
+        #  name. The array will be empty if there are no children by the given name.
+        def [](name)
+          @children[name.to_sym] || []
+        end
+
+        # @return [Array<Symbol>] an array containing all the names of child elements
+        def child_names
+          @children.keys
+        end
+
+        private
+        def add_child(child)
+          name = child.name
+          unless child_set = @children[name]
+            child_set = @children[name] = []
+          end
+          child_set << child
+        end
+      end
+    end
+  end
+end

data/lib/threatinator/parsers/xml/node_builder.rb

@@ -0,0 +1,39 @@
+require 'threatinator/parsers/xml/node'
+
+module Threatinator
+  module Parsers
+    module XML
+      class NodeBuilder
+        def initialize(name, attributes)
+          @name = name
+          @attributes = {}
+          @children = []
+          @text = ""
+
+          unless attributes.empty?
+            attributes.each { |attr| self.add_attribute(attr.localname, attr.value) }
+          end
+        end
+
+        def append_text(chars)
+          @text << chars
+        end
+
+        def add_attribute(name, value)
+          @attributes[name.to_sym] = value
+        end
+
+        def add_child(node)
+          @children << node
+        end
+
+        def build
+          Threatinator::Parsers::XML::Node.new(@name, 
+                                               attrs: @attributes, 
+                                               text: @text.strip, 
+                                               children: @children)
+        end
+      end
+    end
+  end
+end

data/lib/threatinator/parsers/xml/parser.rb

@@ -0,0 +1,44 @@
+require 'threatinator/parser'
+require 'nokogiri'
+
+module Threatinator
+  module Parsers
+    module XML
+      class Parser < Threatinator::Parser
+        require 'threatinator/parsers/xml/path'
+        require 'threatinator/parsers/xml/record'
+        require 'threatinator/parsers/xml/sax_document'
+
+        attr_reader :pattern
+        # @param [Hash] opts Parameters hash
+        # @option opts [Threatinator::Parsers::XML::Pattern] :pattern The pattern
+        #  object to use for matching chunks of XML
+        def initialize(opts = {})
+          @pattern = opts.delete(:pattern) or raise ArgumentError.new("Missing argument :pattern")
+          @max_cursor_depth = @pattern.max_depth - 1
+          super(opts)
+        end
+
+        def ==(other)
+          @pattern == other.pattern && 
+            super(other)
+        end
+
+        # @param [IO] io
+        # @yield [record] Gives one line to the block
+        # @yieldparam record [Threatinator::Parser::XML::Record] a record
+        def run(io)
+          stack = Path.new
+          callback = lambda do |element|
+            yield(Threatinator::Parsers::XML::Record.new(element))
+          end
+
+          doc = SAXDocument.new(@pattern, callback)
+          parser = Nokogiri::XML::SAX::Parser.new(doc)
+          parser.parse(io)
+        end
+
+      end
+    end
+  end
+end

data/lib/threatinator/parsers/xml/path.rb

@@ -0,0 +1,70 @@
+module Threatinator
+  module Parsers
+    module XML
+      class Path
+        attr_reader :parts
+
+        # @param [String, Array, nil] str_or_parts ([]) If set to a String, splits 
+        #   the string by '/' into an array. If set to an Array, sets parts to a
+        #   duplicate of the array. If set to nil or not specified, defaults to 
+        #   a new array.
+        # @raise [TypeError] if something other than a String, Array, or nil is 
+        #   specified for str_or_parts.
+        def initialize(str_or_parts = nil)
+          @parts = 
+            case str_or_parts
+            when ::String
+              if str_or_parts.length == 0 or !str_or_parts.start_with?('/')
+                raise ArgumentError.new('str_or_parts must be a String beginning with "/"')
+              end
+              r = str_or_parts.split('/')
+              r.shift
+              r
+            when ::Array
+              str_or_parts.dup
+            when nil
+              []
+            else
+              raise TypeError.new("Expected argument must be a String, Array, or nil")
+            end
+        end
+
+        def ==(other)
+          @parts == other.parts
+        end
+
+        def eql?(other)
+          other.kind_of?(self.class) &&
+            self == other
+        end
+
+        # length = 5
+        #   0 1 2 3 4
+        #  /a/b/c/d/e
+        #         0 1
+        #        /d/e
+        def end_with?(other_path)
+          return false if other_path.length > self.length
+          return true if other_path.length == 0
+          pos = length - other_path.length
+          other_path.parts.each_with_index do |other_part, idx|
+            return false unless @parts[(pos + idx)] == other_part
+          end
+          true
+        end
+
+        def push(name)
+          @parts.push(name)
+        end
+
+        def pop
+          @parts.pop
+        end
+
+        def length
+          @parts.length
+        end
+      end
+    end
+  end
+end