opener-s3-outlet 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 10341e220c8473c0a1122c20b7ab9dc7b1f8452e
+  data.tar.gz: e4a9dcf12a019669c8879838ff5f94ac3fc09a9b
+SHA512:
+  metadata.gz: 975df73d82655fe9b781aed0e485a7805c68f3746442dd226d55217abe9acb411b98ea153174035dd242adf346f436ef49cc9b7b2f9a0a5325cebd727eecd073
+  data.tar.gz: ab71c20499c3bae2a3ca8a6e35710520786275c59d47b3ef49b2bacecfedbf133e9243206f258a14c1e136a0bbcb99befe467f026af76e335c3782fa0cf39360

data/README.md

@@ -0,0 +1,57 @@
+# S3-Outlet: Stores the results in an AWS S3 bucket.
+
+Component that stores results from the Opener Web Services chain into an S3
+bucket.
+
+
+## Installation
+
+### As part of a Gemfile in a Ruby application
+
+Add this line to your application's Gemfile:
+
+    gem 'opener-s3-outlet',
+        :git=>"git@github.com:opener-project/s3-outlet.git"
+
+And then execute:
+
+    $ bundle install
+
+## Usage
+
+The Opener S3 Outlet comes equipped with a simple webservice. To start the
+webservice type:
+
+    s3-outlet-server
+
+This will launch a mini webserver with the webservice. It defaults to port 9292,
+so you can access it at:
+
+    http://localhost:9292
+
+To launch it on a different port provide the ```-p [port-number]``` option like
+this:
+
+    s3-outlet-server -p 1234
+
+It then launches at ```http://localhost:1234```
+
+When you run a chain of web services using callbacks, the last URL should be the
+one that points to the S3 Outlet Web Service. A unique id is generated and once the
+chain has finished processing the text, you can view the result in the URL that
+you get.
+
+## Contributing
+
+### Procedure
+
+1. Pull it
+2. Create your feature branch (`git checkout -b features/my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin features/my-new-feature`)
+5. If you're confident, merge your changes into master.
+
+# What's next? 
+
+If you're interested in the opener-s3-outlet, you also might want to check
+out opener-project/s3-outlet.

data/bin/s3-outlet-daemon

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+#
+require 'rubygems'
+require 'opener/daemons'
+
+exec_path = File.expand_path("../../exec/s3-outlet.rb", __FILE__)
+Opener::Daemons::Controller.new(:name=>"s3-outlet",
+                                :exec_path=>exec_path)
+

data/bin/s3-outlet-server

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'rack'
+
+# Without calling `Rack::Server#options` manually the CLI arguments will never
+# be passed, thus the application can't be specified as a constructor argument.
+server                  = Rack::Server.new
+server.options[:config] = File.expand_path('../../config.ru', __FILE__)
+
+server.start

data/config.ru

@@ -0,0 +1,4 @@
+require File.expand_path('../lib/opener/s3_outlet', __FILE__)
+require File.expand_path('../lib/opener/s3_outlet/server', __FILE__)
+
+run Opener::S3Outlet::Server

data/config/aws.rb

@@ -0,0 +1,8 @@
+# These details are tied to the "opener" AWS user.
+AWS.config(
+  :access_key_id     => 'AKIAIZH4THHTIHYS22NA',
+  :secret_access_key => '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',
+  :sqs_region        => 'eu-west-1',
+  :sqs_endpoint      => 'sqs.eu-west-1.amazonaws.com',
+  :s3_endpoint       => 's3-eu-west-1.amazonaws.com',
+)

data/exec/s3-outlet.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require 'opener/daemons'
+require_relative '../lib/opener/s3_outlet'
+
+parser = Opener::Daemons::OptParser.new do |opts, options|
+  opts.on("-b", "--bucket NAME", "Bucket name") do |v|
+    options[:bucket] = v
+  end
+  opts.on("-d", "--directory NAME", "Directory name") do |v|
+    options[:directory] = v
+  end
+end
+
+class S3OutletFactory
+  attr_reader :dir, :bucket
+
+  def initialize(options)
+    @bucket = options.fetch(:bucket)
+    @dir    = options.fetch(:directory)
+  end
+
+  def new
+    Opener::S3Outlet.new(:directory=>dir, :bucket=>bucket)
+  end
+end
+
+options = parser.parse!(ARGV)
+factory = S3OutletFactory.new(options)
+
+daemon = Opener::Daemons::Daemon.new(factory, options)
+daemon.start
+

data/lib/opener/s3_outlet.rb

@@ -0,0 +1,39 @@
+require 'aws-sdk'
+
+require_relative '../../config/aws'
+require_relative 's3_outlet/s3_output'
+require_relative 's3_outlet/version'
+require_relative 's3_outlet/server'
+
+module Opener
+  class S3Outlet
+    attr_reader :options
+
+    def initialize(options={})
+      @options = options
+    end
+
+    def run(input)
+      options[:text] = input
+      S3Output.create(options)
+
+      return input #Return original input so that we can keep on chaining.
+    end
+
+    def self.s3
+      @s3 ||= AWS::S3.new
+    end
+
+    def self.bucket
+      @bucket ||= s3.buckets[bucket_name]
+    end
+
+    def self.bucket_name
+      return "opener-outlet"
+    end
+
+    def self.dir
+      return "webservice"
+    end
+  end
+end

data/lib/opener/s3_outlet/public/outlet.css

@@ -0,0 +1,58 @@
+body {
+  font-family: arial;
+  line-height: 2em;
+  font-size: 15px;
+  margin-top: 3em;
+}
+
+.opener {
+  width: 800px;
+  margin-left: auto;
+  margin-right: auto;
+}
+
+.entities {
+  margin: 1em;
+}
+
+.entities:before {
+  font-size: 16px;
+  font-weight: bold;
+  content: "Entities";
+}
+
+.opinions {
+  margin: 1em;
+}
+
+.opinions:before {
+  font-size: 16px;
+  font-weight: bold;
+  content: "Opinions";
+}
+
+.properties {
+  margin: 1em;
+}
+
+.properties:before {
+  font-size: 16px;
+  font-weight: bold;
+  content: "Aspects";
+}
+
+.positive {
+  background-color: #AFA;
+}
+
+.negative {
+  background-color: #FAA;
+}
+
+.entity {
+  border-bottom: 2px dotted #00F;
+}
+
+.property {
+  border-bottom: 2px solid orange;
+}

data/lib/opener/s3_outlet/s3_output.rb

@@ -0,0 +1,59 @@
+require 'uuidtools'
+
+module Opener
+  class S3Outlet
+    class S3Output
+       #attr_accessor :params, :bucket
+       attr_reader :uuid, :text, :dir, :bucket, :params
+
+       def initialize(params = {})
+         @uuid     = params.fetch(:uuid) { UUIDTools::UUID.random_create }
+         @text     = params.fetch(:text)
+         @dir      = params.fetch(:directory, S3Outlet.dir)
+
+         bucket = params[:bucket]
+         if bucket.kind_of?(String)
+           @bucket = S3Outlet.s3.buckets[bucket]
+         else
+           @bucket = bucket || S3Outlet.bucket
+         end
+       end
+
+       def save
+         object = bucket.objects[filename]
+         object.write(text)
+       end
+
+       def self.find(uuid, dir=nil, bucket=nil)
+         filename = construct_filename(uuid, dir)
+         bucket = bucket || default_bucket
+
+         if bucket.objects[filename].exists?
+           file = bucket.objects[filename]
+           return file.read
+         else
+           return nil
+         end
+       end
+
+       def self.create(params={})
+         new(params).save
+       end
+
+       def filename
+         self.class.construct_filename(uuid, dir)
+       end
+
+       private
+
+       def self.construct_filename(uuid, dir=nil)
+         dir = S3Outlet.dir if dir.nil? || dir.empty?
+         File.join(dir, "#{uuid}.kaf")
+       end
+
+       def self.default_bucket
+         S3Outlet.bucket
+       end
+    end
+  end
+end

data/lib/opener/s3_outlet/server.rb

@@ -0,0 +1,76 @@
+require 'sinatra'
+require 'nokogiri'
+require 'stringio'
+require_relative './visualizer'
+
+require File.expand_path('../../../../config/aws', __FILE__)
+
+module Opener
+  class S3Outlet
+    class Server < Sinatra::Base
+
+      post '/' do
+        output = S3Output.create(:uuid => params[:request_id], :text => params[:input])
+      end
+
+      get '/' do
+        if params[:request_id]
+          redirect "#{url("/")}#{params[:request_id]}"
+        else
+          erb :index
+        end
+      end
+
+      get '/:request_id' do
+        unless params[:request_id] == 'favicon.ico'
+          begin
+            output = S3Output.find(params[:request_id])
+
+            if output
+              content_type(:xml)
+              body(output)
+            else
+              halt(404, "No record found for ID #{params[:request_id]}")
+            end
+          rescue => error
+            error_callback = params[:error_callback]
+
+            submit_error(error_callback, error.message) if error_callback
+
+            raise(error)
+          end
+        end
+      end
+
+      get '/html/:request_id' do
+        unless params[:request_id] == 'favicon.ico'
+          begin
+            output = S3Output.find(params[:request_id])
+            if output
+              output = StringIO.new(output)
+              parser = Opener::Kaf::Visualizer::Parser.new(output)
+              doc = parser.parse
+              html = Opener::Kaf::Visualizer::HTMLTextPresenter.new(doc)
+              @parsed = html.to_html
+              erb :show
+            else
+              halt(404, "No record found for ID #{params[:request_id]}")
+            end
+          rescue => error
+            error_callback = params[:error_callback]
+
+            submit_error(error_callback, error.message) if error_callback
+
+            raise(error)
+          end
+        end
+      end
+
+      private
+
+      def submit_error(url, message)
+        HTTPClient.post(url, :body => {:error => message})
+      end
+    end # Server
+  end # S3Outlet
+end # Opener

data/lib/opener/s3_outlet/version.rb

@@ -0,0 +1,5 @@
+module Opener
+  class S3Outlet
+    VERSION = "1.0.0"
+  end
+end

data/lib/opener/s3_outlet/views/index.erb

@@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <link type="text/css" rel="stylesheet" charset="UTF-8" href="markdown.css"/>
+    <title>Opener S3 Outlet</title>
+  </head>
+  <body>
+    <h1>Opener S3 Outlet</h1>
+
+    <p>This Web Service, stores the output from a chain of Opener components in a
+      S3 bucket.</p>
+    <p>When using callbacks, the last Callback URL should be the URL that points
+      to S3 Outlet. Then, when you submit your text, you get a URL where the result
+      will be shown, when the processing is over.</p>
+      
+      <h2>Search for an output</h2>
+
+      <p>* required</p>
+      
+
+      <form action="<%=url("/")%>" method="GET">
+        <div>
+          <label for="request_id"/>Type the ID here*</label>
+          <br/>
+
+          <input type="text" name="request_id" id="text" rows="10" cols="50"/>
+        </div>
+        <input type="submit" value="Submit" />
+      </form>
+
+  </body>
+</html>
+

data/lib/opener/s3_outlet/views/show.erb

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <link type="text/css" rel="stylesheet" charset="UTF-8" href="/outlet.css"/>
+    <title>Opener S3 Outlet</title>
+  </head>
+  <body>
+    <%= @parsed%>
+  </body>
+</html>

data/lib/opener/s3_outlet/views/show.html.erb

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <link type="text/css" rel="stylesheet" charset="UTF-8" href="markdown.css"/>
+    <title>Opener S3 Outlet</title>
+  </head>
+  <body>
+    <h1>Opener S3 Outlet</h1>
+    <%=parsed%>
+  </body>
+</html>

data/lib/opener/s3_outlet/visualizer.rb

@@ -0,0 +1,278 @@
+#require "opener/kaf/visualizer/version"
+require 'nokogiri'
+
+module Opener
+  module Kaf
+    module Visualizer
+      class Parser
+        attr_reader :doc
+        attr_reader :words, :terms, :entities, :properties, :opinions, :document
+
+        def initialize(input_file_handler)
+          @doc = Nokogiri::XML(input_file_handler)
+        end
+
+        def parse
+          @words      = parse_words
+          @terms      = parse_terms
+          @entities   = parse_entities
+          @properties = parse_properties
+          @opinions   = parse_opinions
+          @document   = KAFDocument.new(
+            :words => words,
+            :terms => terms,
+            :entities => entities,
+            :properties => properties,
+            :opinions => opinions
+          )
+
+          return document
+        end
+
+        def parse_words
+          parse_elements("//wf", Word)
+        end
+
+        def parse_terms
+          # Of course terms should be words here.
+          # Dirty Hack, sufficient for now.
+          parse_elements("//term", Term, :terms=>words)
+        end
+
+        def parse_entities
+          parse_elements("//entity", Entity, :terms=>terms)
+        end
+
+        def parse_properties
+          parse_elements("//property", Property, :terms=>terms)
+        end
+
+        def parse_opinions
+          parse_elements("//opinion", Opinion, :terms=>terms)
+        end
+
+        def parse_elements(xpath, klass, opts={})
+          elements = doc.xpath(xpath)
+          lookup_table = Hash.new
+          elements.each do |element|
+            instance = klass.new(element, opts)
+            lookup_table[instance.id] = instance
+          end
+          lookup_table
+        end
+
+      end
+
+      class KAFNode
+        attr_reader :content, :targets, :tag, :references
+
+        def initialize(tag, references)
+          @references = references
+          @tag = tag
+
+          set_instance_variables
+          set_content
+          set_targets
+          process_subnodes
+        end
+
+        def set_content
+          @content = tag.content
+        end
+
+        def set_instance_variables
+          tag.keys.each do |key|
+            if respond_to?("#{key}=".to_sym)
+              send("#{key}=".to_sym, tag[key])
+            else
+              instance_variable_set("@#{key}", tag[key])
+            end
+          end
+        end
+
+        def set_targets
+          @targets = []
+          tag.css("span target").each do |target|
+            id = target["id"]
+            @targets << references[:terms][id]
+          end
+        end
+
+        def process_subnodes
+        end
+
+        def has_target?(*ids)
+          ids.flatten.each do |id|
+            return true if target_ids.include?(id)
+          end
+          return false
+        end
+
+        def to_s
+          if targets.size > 0
+            return targets.map(&:to_s).join(" ")
+          else
+            return content
+          end
+        end
+
+        def target_ids
+          @targets.map(&:id)
+        end
+
+      end
+
+      class Word < KAFNode
+        attr_reader :wid, :sent, :para, :offset
+
+        def id
+          wid
+        end
+
+        def offset=(offset)
+          @offset = offset.to_i
+        end
+
+        def length
+          content.nil? ? 0 : content.length
+        end
+
+      end
+
+      class Term < KAFNode
+        attr_reader :tid, :type, :lemma, :pos, :morphofeat
+
+        def id
+          tid
+        end
+      end
+
+      class Entity < KAFNode
+        attr_reader :eid, :type
+
+        def id
+          eid
+        end
+
+        def to_s
+          "#{type}: #{targets.map(&:to_s).join(", ")}"
+        end
+      end
+
+      class Property < KAFNode
+        attr_reader :pid, :lemma
+
+        def id
+          pid
+        end
+
+        def to_s
+          "#{lemma}: #{targets.map(&:to_s).join(", ")}"
+        end
+      end
+
+      class Opinion < KAFNode
+        attr_reader :oid, :expression
+
+        def id
+          oid
+        end
+
+        def process_subnodes
+          @expression = tag.xpath("opinion_expression").first["polarity"].to_sym
+        end
+
+        def to_s
+          "#{expression}: #{targets.map(&:to_s).join(", ")}"
+        end
+
+      end
+
+      class KAFDocument
+        attr_reader :words, :terms, :entities, :properties, :opinions
+
+        def initialize(opts={})
+          @words = opts.fetch(:words)
+          @terms = opts.fetch(:terms)
+          @entities = opts.fetch(:entities)
+          @properties = opts.fetch(:properties)
+          @opinions = opts.fetch(:opinions)
+        end
+
+      end
+
+      class HTMLTextPresenter
+        attr_reader :document
+        def initialize(document)
+          @document = document
+        end
+
+        def to_html
+          offset = 0
+          prev = Struct.new(:offset).new(0)
+
+          builder = Nokogiri::HTML::Builder.new do |html|
+            html.div(:class=>"opener") do
+              html.p do
+                document.words.values.sort_by(&:offset).each do |word|
+                  if offset < word.offset
+                    spacer = word.offset - offset
+                    spacer = Array.new(spacer, " ").join
+                    html.span(spacer)
+                  end
+
+                  terms      = targets_for(:terms, word.id)
+                  entities   = targets_for(:entities, terms)
+                  opinions   = opinions_for(terms)
+                  properties = targets_for(:properties, terms)
+
+                  generics = []
+                  generics << "term"     if terms.size > 0
+                  generics << "entity"   if entities.size > 0
+                  generics << "opinion"  if opinions.size > 0
+                  generics << "property" if properties.size > 0
+
+                  classes = [terms, entities, opinions, properties, generics].flatten.uniq
+
+                  word_annotations = classes.join(" ")
+
+                  html.span(word.content, :class=>word_annotations, :id=>word.id)
+                  offset = word.offset + word.length
+                end
+              end
+
+              [:entities, :opinions, :properties].each do |sym|
+                html.div(:class=>sym) do
+                  document.public_send(sym).values.each do |entity|
+                    html.div(entity.to_s, :id=>entity.id, :class=>entity.target_ids.join(" "))
+                  end
+                end
+              end
+            end
+          end
+
+          builder.to_html
+        end
+
+        def targets_for(variable, *ids)
+          targets = document.public_send(variable.to_sym).values.select do |value|
+            value.has_target?(ids.flatten)
+          end
+
+          targets.map(&:id)
+        end
+
+        def opinions_for(*ids)
+          targets = document.opinions.values.select do |value|
+            value.has_target?(ids.flatten)
+          end
+
+          ids = targets.map(&:id)
+          sentiments = targets.map(&:expression)
+          return ids.concat(sentiments).uniq
+        end
+
+      end
+    end
+  end
+end

data/opener-s3-outlet.gemspec

@@ -0,0 +1,38 @@
+require File.expand_path('../lib/opener/s3_outlet/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name                  = 'opener-s3-outlet'
+  gem.version               = Opener::S3Outlet::VERSION
+  gem.authors               = ['development@olery.com']
+  gem.summary               = 'S3 Bucket data storing for the web services output when using callbacks.'
+  gem.description           = gem.summary
+  gem.homepage              = "http://opener-project.github.com/"
+  gem.has_rdoc              = 'yard'
+  gem.required_ruby_version = '>= 1.9.2'
+
+  gem.files = Dir.glob([
+    'config/**/*',
+    'exec/**/*',
+    'lib/**/*',
+    'config.ru',
+    '*.gemspec',
+    'README.md',
+    'visualizer.rb'
+  ]).select { |file| File.file?(file) }
+
+  gem.executables = Dir.glob('bin/*').map { |file| File.basename(file) }
+
+  gem.add_dependency 'builder'
+  gem.add_dependency 'sinatra', '~>1.4.2'
+  gem.add_dependency 'nokogiri'
+  gem.add_dependency 'httpclient'
+  gem.add_dependency 'uuidtools'
+  gem.add_dependency 'opener-webservice'
+  gem.add_dependency 'opener-daemons'
+  gem.add_dependency 'aws-sdk'
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'cucumber'
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'rake'
+end

data/visualizer.rb

@@ -0,0 +1,278 @@
+require 'nokogiri'
+
+module Opener
+  module Kaf
+    module Visualizer
+      class Parser
+        attr_reader :doc
+        attr_reader :words, :terms, :entities, :properties, :opinions, :document
+
+        def initialize(input_file_handler)
+          @doc = Nokogiri::XML(input_file_handler)
+        end
+
+        def parse
+          @words      = parse_words
+          @terms      = parse_terms
+          @entities   = parse_entities
+          @properties = parse_properties
+          @opinions   = parse_opinions
+          @document   = KAFDocument.new(
+            :words => words,
+            :terms => terms,
+            :entities => entities,
+            :properties => properties,
+            :opinions => opinions
+          )
+
+          return document
+        end
+
+        def parse_words
+          parse_elements("//wf", Word)
+        end
+
+        def parse_terms
+          # Of course terms should be words here.
+          # Dirty Hack, sufficient for now.
+          parse_elements("//term", Term, :terms=>words)
+        end
+
+        def parse_entities
+          parse_elements("//entity", Entity, :terms=>terms)
+        end
+
+        def parse_properties
+          parse_elements("//property", Property, :terms=>terms)
+        end
+
+        def parse_opinions
+          parse_elements("//opinion", Opinion, :terms=>terms)
+        end
+
+        def parse_elements(xpath, klass, opts={})
+          elements = doc.xpath(xpath)
+          lookup_table = Hash.new
+          elements.each do |element|
+            instance = klass.new(element, opts)
+            lookup_table[instance.id] = instance
+          end
+          lookup_table
+        end
+
+      end
+
+      class KAFNode
+        attr_reader :content, :targets, :tag, :references
+
+        def initialize(tag, references)
+          @references = references
+          @tag = tag
+
+          set_instance_variables
+          set_content
+          set_targets
+          process_subnodes
+        end
+
+        def set_content
+          @content = tag.content
+        end
+
+        def set_instance_variables
+          tag.keys.each do |key|
+            if respond_to?("#{key}=".to_sym)
+              send("#{key}=".to_sym, tag[key])
+            else
+              instance_variable_set("@#{key}", tag[key])
+            end
+          end
+        end
+
+        def set_targets
+          @targets = []
+          tag.css("span target").each do |target|
+            id = target["id"]
+            @targets << references[:terms][id]
+          end
+        end
+
+        def process_subnodes
+        end
+
+        def has_target?(*ids)
+          ids.flatten.each do |id|
+            return true if target_ids.include?(id)
+          end
+          return false
+        end
+
+        def to_s
+          if targets.size > 0
+            return targets.map(&:to_s).join(" ")
+          else
+            return content
+          end
+        end
+
+        def target_ids
+          @targets.map(&:id)
+        end
+
+      end
+
+      class Word < KAFNode
+        attr_reader :wid, :sent, :para, :offset
+
+        def id
+          wid
+        end
+
+        def offset=(offset)
+          @offset = offset.to_i
+        end
+
+        def length
+          content.nil? ? 0 : content.length
+        end
+
+      end
+
+      class Term < KAFNode
+        attr_reader :tid, :type, :lemma, :pos, :morphofeat
+
+        def id
+          tid
+        end
+      end
+
+      class Entity < KAFNode
+        attr_reader :eid, :type
+
+        def id
+          eid
+        end
+
+        def to_s
+          "#{type}: #{targets.map(&:to_s).join(", ")}"
+        end
+      end
+
+      class Property < KAFNode
+        attr_reader :pid, :lemma
+
+        def id
+          pid
+        end
+
+        def to_s
+          "#{lemma}: #{targets.map(&:to_s).join(", ")}"
+        end
+      end
+
+      class Opinion < KAFNode
+        attr_reader :oid, :expression
+
+        def id
+          oid
+        end
+
+        def process_subnodes
+          @expression = tag.xpath("//opinion_expression").first["polarity"].to_sym
+        end
+
+        def to_s
+          "#{expression}: #{targets.map(&:to_s).join(", ")}"
+        end
+
+      end
+
+      class KAFDocument
+        attr_reader :words, :terms, :entities, :properties, :opinions
+
+        def initialize(opts={})
+          @words = opts.fetch(:words)
+          @terms = opts.fetch(:terms)
+          @entities = opts.fetch(:entities)
+          @properties = opts.fetch(:properties)
+          @opinions = opts.fetch(:opinions)
+        end
+
+      end
+
+      class HTMLTextPresenter
+        attr_reader :document
+        def initialize(document)
+          @document = document
+        end
+
+        def to_html
+          offset = 0
+          prev = Struct.new(:offset).new(0)
+
+          builder = Nokogiri::HTML::Builder.new do |html|
+            html.div(:class=>"opener") do
+              html.p do
+                document.words.values.sort_by(&:offset).each do |word|
+                  if offset < word.offset
+                    spacer = word.offset - offset
+                    spacer = Array.new(spacer, " ").join
+                    html.span(spacer)
+                  end
+
+                  terms      = targets_for(:terms, word.id)
+                  entities   = targets_for(:entities, terms)
+                  opinions   = opinions_for(terms)
+                  properties = targets_for(:properties, terms)
+
+                  generics = []
+                  generics << "term"     if terms.size > 0
+                  generics << "entity"   if entities.size > 0
+                  generics << "opinion"  if opinions.size > 0
+                  generics << "property" if properties.size > 0
+
+                  classes = [terms, entities, opinions, properties, generics].flatten.uniq
+
+                  word_annotations = classes.join(" ")
+
+                  html.span(word.content, :class=>word_annotations, :id=>word.id)
+                  offset = word.offset + word.length
+                end
+              end
+
+              [:entities, :opinions, :properties].each do |sym|
+                html.div(:class=>sym) do
+                  document.public_send(sym).values.each do |entity|
+                    html.div(entity.to_s, :id=>entity.id, :class=>entity.target_ids.join(" "))
+                  end
+                end
+              end
+            end
+          end
+
+          builder.to_html
+        end
+
+        def targets_for(variable, *ids)
+          targets = document.public_send(variable.to_sym).values.select do |value|
+            value.has_target?(ids.flatten)
+          end
+
+          targets.map(&:id)
+        end
+
+        def opinions_for(*ids)
+          targets = document.opinions.values.select do |value|
+            value.has_target?(ids.flatten)
+          end
+
+          ids = targets.map(&:id)
+          sentiments = targets.map(&:expression)
+          return ids.concat(sentiments).uniq
+        end
+
+      end
+    end
+  end
+end
+

metadata

@@ -0,0 +1,230 @@
+--- !ruby/object:Gem::Specification
+name: opener-s3-outlet
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- development@olery.com
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-20 00:00:00.000000000 Z
+dependencies:
+- !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: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+- !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: httpclient
+  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: uuidtools
+  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: opener-webservice
+  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: opener-daemons
+  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: aws-sdk
+  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: cucumber
+  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: pry
+  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'
+description: S3 Bucket data storing for the web services output when using callbacks.
+email: 
+executables:
+- s3-outlet-daemon
+- s3-outlet-server
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/s3-outlet-daemon
+- bin/s3-outlet-server
+- config.ru
+- config/aws.rb
+- exec/s3-outlet.rb
+- lib/opener/s3_outlet.rb
+- lib/opener/s3_outlet/public/outlet.css
+- lib/opener/s3_outlet/s3_output.rb
+- lib/opener/s3_outlet/server.rb
+- lib/opener/s3_outlet/version.rb
+- lib/opener/s3_outlet/views/index.erb
+- lib/opener/s3_outlet/views/show.erb
+- lib/opener/s3_outlet/views/show.html.erb
+- lib/opener/s3_outlet/visualizer.rb
+- opener-s3-outlet.gemspec
+- visualizer.rb
+homepage: http://opener-project.github.com/
+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.2
+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: S3 Bucket data storing for the web services output when using callbacks.
+test_files: []
+has_rdoc: yard