opener-kaf-parser 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: efcd70b4613807928b75e36c34e96b8ec22737e1
+  data.tar.gz: 7fb60e7fb63d37192efd2e2938b2a503e712358d
+SHA512:
+  metadata.gz: b920bcb157bc0d1c5ce592ea7da6c454b89b2842dc055712d662f3a3fd8cdd762ecc3f61a4cfc15cc26e11e87ee701ab8a116734e92d13996d7b5efc0fa03d7c
+  data.tar.gz: cb85a15b2dc234e5d9abe33222f64131cbb6491a40ea243b3178065d73f30cb050c350cc9ce064a6fa7ac2c85d4fbf27bd1f9341971e3e47a417da9ce5912753

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013, Olery
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,72 @@
+[![Build Status](https://drone.io/github.com/opener-project/ruby-kaf-parser/status.png)](https://drone.io/github.com/opener-project/ruby-kaf-parser/latest)
+
+# Ruby KAF Parser
+
+This repository contains the source code of the opener-kaf-parser, a simple and
+fast KAF parser based on Nokogiri. The KAF parser is a stack based parser that
+uses the SAX parsing API of Nokogiri, thus it should (in theory) be able to
+handle large KAF files without too much trouble.
+
+## Usage
+
+Create a parser instance and parse some KAF:
+
+    require 'opener/kaf_parser'
+
+    parser = Opener::KafParser::Parser.new
+    ast    = parser.parse('...')
+
+The return value is a list of `Opener::KafParser::AST` nodes which behave like
+S expressions (and are formatted that way when calling `#inspect` on them).
+Currently there are 3 node types:
+
+* document
+* text
+* opinion
+
+The latter groups a set of text nodes together that make up the opinion.
+
+To iterate over these nodes you'd do something along the lines of the
+following:
+
+    ast.language # => "en"
+
+    ast.children.each do |node|
+      if node.type == :text
+        puts "Word: #{node.inspect}"
+      else
+        puts "Opinion: #{node.inspect}"
+      end
+    end
+
+## Presenting Text
+
+To present an AST/text you can use one of the standard presenter classes. For
+example, if you want to turn an AST in a regular Ruby String you can use the
+Text presenter:
+
+    ast       = parser.parse('...')
+    presenter = Opener::KafParser::Presenter::Text.new
+
+    puts presenter.present(ast) # => "Hello, you are doing great"
+
+Currently the following presenters are available:
+
+* `Opener::KafParser::Presenter::Text`
+* `Opener::KafParser::Presenter::HTML`
+
+## Requirements
+
+* Ruby 1.9.3 or newer
+* libxml2 (newer versions of Nokogiri ship libxml themselves)
+
+## Installation:
+
+Installing as a Gem:
+
+    gem install opener-kaf-parser
+
+Using Bundler:
+
+    gem 'opener-kaf-parser',
+      :git => 'git@github.com:opener-project/ruby-kaf-parser'

data/doc/css/common.css

@@ -0,0 +1,68 @@
+body
+{
+    font-size:   14px;
+    line-height: 1.6;
+    margin:      0 auto;
+    max-width:   960px;
+}
+
+p code
+{
+    background:    #f2f2f2;
+    padding-left:  3px;
+    padding-right: 3px;
+}
+
+pre.code
+{
+    font-size:   13px;
+    line-height: 1.4;
+}
+
+/**
+ * YARD uses generic table styles, using a special class means those tables
+ * don't get messed up.
+ */
+.table
+{
+    border:          1px solid #ccc;
+    border-right:    none;
+    border-collapse: separate;
+    border-spacing:  0;
+    text-align:      left;
+}
+
+.table.full
+{
+    width: 100%;
+}
+
+    .table .field_name
+    {
+        min-width: 160px;
+    }
+
+    .table thead tr th.no_sort:first-child
+    {
+        width: 25px;
+    }
+
+    .table thead tr th, .table tbody tr td
+    {
+        border-bottom:  1px solid #ccc;
+        border-right:   1px solid #ccc;
+        min-width:      20px;
+        padding:        8px 5px;
+        text-align:     left;
+        vertical-align: top;
+    }
+
+    .table tbody tr:last-child td
+    {
+        border-bottom: none;
+    }
+
+    .table tr:nth-child(odd) td
+    {
+        background: #f9f9f9;
+    }

data/lib/opener/kaf_parser.rb

@@ -0,0 +1,16 @@
+require 'nokogiri'
+require 'time'
+require 'builder'
+
+require_relative 'kaf_parser/version'
+
+require_relative 'kaf_parser/ast/base'
+require_relative 'kaf_parser/ast/document'
+require_relative 'kaf_parser/ast/text'
+require_relative 'kaf_parser/ast/opinion'
+
+require_relative 'kaf_parser/sax_parser'
+require_relative 'kaf_parser/parser'
+
+require_relative 'kaf_parser/presenter/text'
+require_relative 'kaf_parser/presenter/html'

data/lib/opener/kaf_parser/ast/base.rb

@@ -0,0 +1,76 @@
+module Opener
+  module KafParser
+    module AST
+      ##
+      # Base node class that provides some common boilerplate for the various
+      # other node classes.
+      #
+      # @!attribute [rw] type
+      #  @return [Symbol]
+      #
+      # @!attribute [rw] value
+      #  @return [String]
+      #
+      # @!attribute [rw] children
+      #  @return [Array<Opener::KafParser::AST::Base>]
+      #
+      class Base
+        attr_accessor :type, :value, :children
+
+        ##
+        # @param [Hash] attributes
+        #
+        def initialize(attributes = {})
+          attributes.each do |key, value|
+            instance_variable_set("@#{key}", value) if respond_to?(key)
+          end
+
+          @children ||= []
+          @type     ||= :generic
+
+          after_initialize if respond_to?(:after_initialize)
+        end
+
+        ##
+        # @return [String]
+        #
+        def inspect(indent = 0)
+          spaces       = ' ' * indent
+          child_values = children.map { |c| c.inspect(indent + 2) }
+          segments     = ["#{spaces}(#{type}"]
+
+          if value
+            segments << "#{value.inspect}"
+          end
+
+          unless child_values.empty?
+            segments << "\n#{child_values.join("\n")}"
+          end
+
+          return segments.join(' ') + ')'
+        end
+
+        ##
+        # @return [Hash]
+        #
+        def attributes
+          return {}
+        end
+
+        ##
+        # @return [TrueClass|FalseClass]
+        #
+        def text?
+          return type == :text
+        end
+
+        ##
+        # @return [TrueClass|FalseClass]
+        #
+        def opinion?
+          return type == :opinion
+        end
+      end # Base
+    end # AST
+  end # KafParser
+end # Opener

data/lib/opener/kaf_parser/ast/document.rb

@@ -0,0 +1,33 @@
+module Opener
+  module KafParser
+    module AST
+      ##
+      # The Document node class contains information about a `<KAF>` tag and
+      # all the child nodes.
+      #
+      # @!attribute [rw] language
+      #  @return [String]
+      #
+      # @!attribute [rw] version
+      #  @return [String]
+      #
+      class Document < Base
+        attr_accessor :language, :version
+
+        ##
+        # Called after a new instance of this class is created.
+        #
+        def after_initialize
+          @type = :document
+        end
+
+        ##
+        # @return [Hash]
+        #
+        def attributes
+          return {:language => language, :version => version}
+        end
+      end # Document
+    end # AST
+  end # KafParser
+end # Opener

data/lib/opener/kaf_parser/ast/opinion.rb

@@ -0,0 +1,52 @@
+module Opener
+  module KafParser
+    module AST
+      ##
+      # The Opinion node class contains information about a opinion, the
+      # expression, polarity and more. The nodes that make up the expression of
+      # the opinion are stored in the `children` method.
+      #
+      # @!attribute [rw] id
+      #  @return [String]
+      #
+      # @!attribute [rw] holder The nodes that make up the opinion holder.
+      #  @return [Array]
+      #
+      # @!attribute [rw] target The nodes that make up the opinion target.
+      #  @return [Array]
+      #
+      # @!attribute [rw] polarity
+      #  @return [String]
+      #
+      # @!attribute [rw] strength
+      #  @return [Numeric]
+      #
+      class Opinion < Base
+        attr_accessor :id, :holder, :target, :polarity, :strength
+
+        ##
+        # Called after a new instance of this class is created.
+        #
+        def after_initialize
+          @type = :opinion
+
+          @holder ||= []
+          @target ||= []
+        end
+
+        ##
+        # @return [Hash]
+        #
+        def attributes
+          return {
+            :id       => id,
+            :holder   => holder,
+            :target   => target,
+            :polarity => polarity,
+            :strength => strength
+          }
+        end
+      end # Opinion
+    end # AST
+  end # KafParser
+end # Opener

data/lib/opener/kaf_parser/ast/text.rb

@@ -0,0 +1,75 @@
+module Opener
+  module KafParser
+    module AST
+      ##
+      # Node class that contains information about a set of characters such as
+      # the polarity and POS.
+      #
+      # @!attribute [rw] id
+      #  @return [Numeric]
+      #
+      # @!attribute [rw] sentence
+      #  @return [Numeric]
+      #
+      # @!attribute [rw] paragraph
+      #  @return [Numeric]
+      #
+      # @!attribute [rw] offset
+      #  @return [Numeric]
+      #
+      # @!attribute [rw] length
+      #  @return [Numeric]
+      #
+      # @!attribute [r] word_type
+      #  @return [String]
+      #
+      # @!attribute [r] pos
+      #  @return [String]
+      #
+      # @!attribute [rw] morphofeat
+      #  @return [String]
+      #
+      # @!attribute [rw] sentiment_modifier
+      #  @return [String]
+      #
+      # @!attribute [rw] polarity
+      #  @return [String]
+      #
+      # @!attribute [rw] property
+      #  @return [String]
+      #
+      class Text < Base
+        attr_accessor :id, :sentence, :paragraph, :offset, :length, :word_type,
+          :pos, :morphofeat, :sentiment_modifier, :polarity, :property
+
+        ##
+        # Called after a new instance of this class is created.
+        #
+        def after_initialize
+          @type = :text
+
+          @length ||= value.length
+        end
+
+        ##
+        # @return [Hash]
+        #
+        def attributes
+          return {
+            :id                 => id,
+            :sentence           => sentence,
+            :paragraph          => paragraph,
+            :offset             => offset,
+            :length             => length,
+            :word_type          => word_type,
+            :pos                => pos,
+            :morphofeat         => morphofeat,
+            :sentiment_modifier => sentiment_modifier,
+            :polarity           => polarity,
+            :property           => property
+          }
+        end
+      end # Generic
+    end # AST
+  end # KafParser
+end # Opener

data/lib/opener/kaf_parser/parser.rb

@@ -0,0 +1,25 @@
+module Opener
+  module KafParser
+    ##
+    # The Parser class acts as a slightly more user friendly interface around
+    # the Nokogiri SAX based parser.
+    #
+    class Parser
+      ##
+      # Parses the input KAF/XML and returns an instance of
+      # {Opener::KafParser::AST::Document}.
+      #
+      # @param [String] input The XML/KAF to parse.
+      # @return [Opener::KafParser::AST::Document]
+      #
+      def parse(input)
+        sax_parser      = SaxParser.new
+        nokogiri_parser = Nokogiri::XML::SAX::Parser.new(sax_parser)
+
+        nokogiri_parser.parse(input)
+
+        return sax_parser.document
+      end
+    end # Parser
+  end # KafParser
+end # Opener

data/lib/opener/kaf_parser/presenter/html.rb

@@ -0,0 +1,111 @@
+module Opener
+  module KafParser
+    module Presenter
+      ##
+      # The HTML presenter takes an AST and turns it into a block of HTML where
+      # each word is wrapped in a tag and has various meta information (e.g.
+      # the polarity) assigned to it.
+      #
+      # Basic usage:
+      #
+      #     parser    = Opener::KafParser::Parser.new
+      #     ast       = parser.parse('...')
+      #     presenter = Opener::KafParser::Presenter::HTML.new
+      #
+      #     puts presenter.present(ast)
+      #
+      # ## Output
+      #
+      # The output is a set of span tags for each set of characters, span tags
+      # for whitespace and a set of span tags that group opinion expressions.
+      # Each span tag has a class indicating the type ("text", "opinion", etc)
+      # and a set of `data-*` attributes containing data such as the polarity.
+      # For example, the ID of a text node would be stored in `data-id`, the
+      # polarity in `data-polarity` and so forth.
+      #
+      class HTML < Text
+        ##
+        # @return [String]
+        #
+        SPACE = '&nbsp;'
+
+        ##
+        # @return [Array]
+        #
+        TYPES_WHITELIST = [String, Numeric]
+
+        ##
+        # Presents the AST as a collection of HTML tags.
+        #
+        # @param [Opener::KafParser::AST::Base] ast
+        # @return [String]
+        #
+        def present(ast)
+          offset  = 0
+          builder = Builder::XmlMarkup.new
+
+          render_ast(ast, offset, builder)
+
+          return builder.target!
+        end
+
+        private
+
+        ##
+        # @param [Opener::KafParser::AST::Base] ast
+        # @param [Numeric] offset
+        # @param [Builder::XmlMarkup] builder
+        #
+        def render_ast(ast, offset, builder)
+          ast.children.each do |node|
+            if node.text?
+              offset = render_node(node, offset, builder)
+            else
+              render_span(node, builder) do |sub_builder|
+                render_ast(node, offset, builder)
+              end
+            end
+          end
+        end
+
+        ##
+        # @see #render_ast
+        #
+        def render_node(node, offset, builder)
+          diff = node.offset - offset
+
+          if diff > 0
+            builder.span(:class => 'whitespace') do |sub_builder|
+              sub_builder << SPACE * diff
+            end
+          end
+
+          render_span(node, builder)
+
+          return calculate_offset(node)
+        end
+
+        ##
+        # @param [Opener::KafParser::AST::Base] node
+        # @param [Builder::XmlMarkup] builder
+        #
+        def render_span(node, builder)
+          attrs = {'class' => node.type}
+
+          # Only store simple values in the HTML attributes.
+          node.attributes.each do |key, value|
+            if TYPES_WHITELIST.include?(value.class)
+              attrs["data-#{key}"] = value
+            end
+          end
+
+          if block_given?
+            builder.span(node.value, attrs) { |sub_builder| yield sub_builder }
+          else
+            builder.span(node.value, attrs)
+          end
+        end
+      end # HTML
+    end # Presenter
+  end # KafParser
+end # Opener

data/lib/opener/kaf_parser/presenter/text.rb

@@ -0,0 +1,69 @@
+module Opener
+  module KafParser
+    module Presenter
+      ##
+      # The Text presenter class takes an AST and builds a plain Ruby string
+      # containing the correct whitespace between various nodes.
+      #
+      class Text
+        ##
+        # Presents the AST as a plain Ruby String with no special formatting.
+        #
+        # @param [Opener::KafParser::AST::Base] ast
+        # @return [String]
+        #
+        def present(ast)
+          offset = 0
+          buffer = ''
+
+          render_ast(ast, offset, buffer)
+
+          return buffer
+        end
+
+        private
+
+        ##
+        # @param [Opener::KafParser::AST::Base] ast
+        # @param [Numeric] offset
+        # @param [String] buffer
+        #
+        def render_ast(ast, offset, buffer)
+          ast.children.each do |node|
+            if node.text?
+              offset = render_node(node, offset, buffer)
+            else
+              render_ast(node, offset, buffer)
+            end
+          end
+        end
+
+        ##
+        # @param [Opener::KafParser::AST::Text] node
+        # @param [Numeric] offset
+        # @param [String] buffer
+        # @return [Numeric]
+        #
+        def render_node(node, offset, buffer)
+          diff = node.offset - offset
+
+          if diff > 0
+            buffer << ' ' * diff
+          end
+
+          buffer << node.value
+
+          return calculate_offset(node)
+        end
+
+        ##
+        # @param [Opener::KafParser::AST::Text] node
+        # @return [Numeric]
+        #
+        def calculate_offset(node)
+          return node.offset + node.length
+        end
+      end # Text
+    end # Presenter
+  end # KafParser
+end # Opener

data/lib/opener/kaf_parser/sax_parser.rb

@@ -0,0 +1,351 @@
+module Opener
+  module KafParser
+    ##
+    # The SaxParser class is a Nokogiri SAX parser that builds a list of
+    # {Opener::KafParser::AST::Base} nodes containing word information such as
+    # the polarity and Part Of Speech as well as grouping words together based
+    # on the opinion expression they belong to.
+    #
+    # This SAX parser is a stack based parser and parses only relevant
+    # information of KAF documents. For example, the `<head>` of a KAF document
+    # is completely ignored.
+    #
+    # @!attribute [r] document
+    #  @return [Opener::KafParser::Element::Document]
+    #
+    class SaxParser < Nokogiri::XML::SAX::Document
+      attr_reader :document
+
+      ##
+      # @see Nokogiri::XML::SAX::Document#initialize
+      #
+      def initialize(*args)
+        super
+
+        @stack             = []
+        @attributes        = []
+        @document          = nil
+        @characters        = ''
+        @targets           = []
+        @buffer_characters = false
+        @buffer_targets    = false
+        @word_mapping      = {}
+        @term_mapping      = {}
+      end
+
+      ##
+      # Called at the start of an XML element. This method delegates the work
+      # to individual method calls based on the node name.
+      #
+      # @param [String] name The name of the element.
+      # @param [Array] attributes
+      #
+      def start_element(name, attributes)
+        callback   = 'on_' + callback_name(name)
+        attributes = associate_attributes(attributes)
+
+        execute_callback(callback, attributes)
+      end
+
+      ##
+      # @param [String] name The name of the element.
+      #
+      def end_element(name)
+        callback = 'after_' + callback_name(name)
+
+        execute_callback(callback)
+      end
+
+      ##
+      # Processes the characters of an XML node.
+      #
+      # @param [String] text
+      #
+      def characters(text)
+        @characters << text if @buffer_characters
+      end
+
+      ##
+      # Processes a `<KAF>` node.
+      #
+      # @param [Hash] attr
+      #
+      def on_kaf(attr)
+        @stack << AST::Document.new(
+          :language => attr.fetch('xml:lang', 'en'),
+          :version  => attr['version']
+        )
+      end
+
+      ##
+      # @see #on_kaf
+      #
+      def after_kaf
+        @document = @stack.pop
+      end
+      ##
+      # Processes a `<wf>` node.
+      #
+      # @param [Hash] attr
+      #
+      def on_wf(attr)
+        @stack << AST::Text.new(
+          :id        => attr['wid'],
+          :sentence  => attr['sent'].to_i,
+          :offset    => attr['offset'].to_i,
+          :length    => attr['length'].to_i,
+          :paragraph => attr['para'].to_i
+        )
+
+        @buffer_characters = true
+      end
+
+      ##
+      # @see #on_wf
+      #
+      def after_wf
+        wf       = @stack.pop
+        wf.value = @characters
+
+        current_object.children << wf
+
+        @word_mapping[wf.id] = wf
+
+        reset_character_buffer
+      end
+
+      ##
+      # Processes a `<term>` node.
+      #
+      # @param [Hash] attr
+      #
+      def on_term(attr)
+        @attributes << attr
+
+        @buffer_targets = true
+      end
+
+      ##
+      # @see #on_term
+      #
+      def after_term
+        attrs, sentiment = @attributes
+
+        @targets.each do |target|
+          word = @word_mapping[target]
+
+          word.morphofeat = attrs['morphofeat']
+          word.word_type  = attrs['type']
+          word.pos        = attrs['pos']
+
+          if sentiment
+            word.sentiment_modifier = sentiment['sentiment_modifier']
+            word.polarity           = sentiment['polarity']
+          end
+
+          # Map the term IDs to the word form node.
+          @term_mapping[attrs['tid']] = word
+        end
+
+        reset_target_buffer
+        reset_attributes_buffer
+      end
+
+      ##
+      # Processes a `<target>` node.
+      #
+      # @param [Hash] attr
+      #
+      def on_target(attr)
+        @targets << attr['id'] if @buffer_targets
+      end
+
+      ##
+      # Processes a `<sentiment>` node.
+      #
+      # @param [Hash] attr
+      #
+      def on_sentiment(attr)
+        @attributes << attr
+      end
+
+      ##
+      # Processes a `<opinion>` node.
+      #
+      # @param [Hash] attr
+      #
+      def on_opinion(attr)
+        @stack << AST::Opinion.new(:id => attr['oid'])
+      end
+
+      ##
+      # @see #on_opinion
+      #
+      def after_opinion
+        opinion = @stack.pop
+        remove  = opinion.children.each_with_object({}) do |node, hash|
+          hash[node.id] = true
+        end
+
+        # Insert the opinion node before the first node of the expression.
+        first_index = current_object.children.index(opinion.children[0])
+
+        current_object.children.insert(first_index, opinion)
+
+        # Remove the word nodes from the current object since they have been
+        # moved into the opinion node.
+        current_object.children.each do |node|
+          if node.is_a?(AST::Text) and remove.key?(node.id)
+            current_object.children.delete(node)
+          end
+        end
+      end
+
+      ##
+      # @param [Hash] attr
+      #
+      def on_opinion_holder(attr)
+        @buffer_targets = true
+      end
+
+      ##
+      # @see #on_opinion_holder
+      #
+      def after_opinion_holder
+        @targets.each do |target|
+          current_object.holder << @term_mapping[target]
+        end
+
+        reset_target_buffer
+      end
+
+      ##
+      # @param [Hash] attr
+      #
+      def on_opinion_target(attr)
+        @buffer_targets = true
+      end
+
+      ##
+      # @see #on_opinion_target
+      #
+      def after_opinion_target
+        @targets.each do |target|
+          current_object.target << @term_mapping[target]
+        end
+
+        reset_target_buffer
+      end
+
+      ##
+      # Processes an `<opinion-expression>` node.
+      #
+      # @param [Hash] attr
+      #
+      def on_opinion_expression(attr)
+        current_object.polarity = attr['polarity']
+        current_object.strength = attr['strength'].to_i
+
+        @buffer_targets = true
+      end
+
+      ##
+      # @see #on_opinion_expression
+      #
+      def after_opinion_expression
+        @targets.each do |target|
+          current_object.children << @term_mapping[target]
+        end
+
+        reset_target_buffer
+      end
+
+      ##
+      # Processes a `<property>` node.
+      #
+      # @param [Hash] attr
+      #
+      def on_property(attr)
+        @attributes << attr
+
+        @buffer_targets = true
+      end
+
+      ##
+      # @see #on_property
+      #
+      def after_property
+        attrs = @attributes.pop
+
+        @targets.each do |target|
+          @term_mapping[target].property = attrs['lemma']
+        end
+
+        reset_attributes_buffer
+        reset_target_buffer
+      end
+
+      private
+
+      ##
+      # Returns a callback name for the given XML node name.
+      #
+      # @param [String] name
+      # @return [String]
+      #
+      def callback_name(name)
+        return name.gsub(/([^A-Z]+)([A-Z]+)/, '\\1_\\2').downcase
+      end
+
+      ##
+      # @param [String] name
+      # @param [Array] args
+      #
+      def execute_callback(name, *args)
+        send(name, *args) if respond_to?(name)
+      end
+
+      ##
+      # Converts an Array of attributes into a Hash.
+      #
+      # @param [Array] attributes
+      # @return [Hash]
+      #
+      def associate_attributes(attributes)
+        return attributes.each_with_object({}) do |pair, hash|
+          hash[pair[0]] = pair[1]
+        end
+      end
+
+      ##
+      # @return [Mixed]
+      #
+      def current_object
+        return @stack.last
+      end
+
+      ##
+      # Resets the character buffer and disables buffering.
+      #
+      def reset_character_buffer
+        @buffer_characters = false
+        @characters        = ''
+      end
+
+      ##
+      # Resets the target buffer and disables buffering.
+      #
+      def reset_target_buffer
+        @buffer_targets = false
+        @targets        = []
+      end
+
+      ##
+      # Resets the attributes buffer.
+      #
+      def reset_attributes_buffer
+        @attributes = []
+      end
+    end # SaxParser
+  end # KafParser
+end # Opener

data/lib/opener/kaf_parser/version.rb

@@ -0,0 +1,5 @@
+module Opener
+  module KafParser
+    VERSION = '1.0.0'
+  end # KafParser
+end # Opener

data/opener-kaf-parser.gemspec

@@ -0,0 +1,29 @@
+require File.expand_path('../lib/opener/kaf_parser/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = 'opener-kaf-parser'
+  gem.version     = Opener::KafParser::VERSION
+  gem.authors     = ['Yorick Peterse <yorickpeterse@olery.com>']
+  gem.summary     = 'A KAF parser written in Ruby.'
+  gem.description = gem.summary
+  gem.has_rdoc    = 'yard'
+
+  gem.required_ruby_version = '>= 1.9.3'
+
+  gem.files = Dir.glob([
+    'doc/**/*',
+    'lib/**/*',
+    'LICENSE',
+    '*.gemspec',
+    'README.md'
+  ]).select { |file| File.file?(file) }
+
+  gem.add_dependency 'nokogiri'
+  gem.add_dependency 'builder'
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'yard'
+  gem.add_development_dependency 'redcarpet', ['>= 2.0']
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: opener-kaf-parser
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Yorick Peterse <yorickpeterse@olery.com>
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: A KAF parser written in Ruby.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- doc/css/common.css
+- lib/opener/kaf_parser.rb
+- lib/opener/kaf_parser/ast/base.rb
+- lib/opener/kaf_parser/ast/document.rb
+- lib/opener/kaf_parser/ast/opinion.rb
+- lib/opener/kaf_parser/ast/text.rb
+- lib/opener/kaf_parser/parser.rb
+- lib/opener/kaf_parser/presenter/html.rb
+- lib/opener/kaf_parser/presenter/text.rb
+- lib/opener/kaf_parser/sax_parser.rb
+- lib/opener/kaf_parser/version.rb
+- opener-kaf-parser.gemspec
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A KAF parser written in Ruby.
+test_files: []
+has_rdoc: yard