opener-outlet 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: df871ce40445a7412cc20219841a08301b1f6b20
+  data.tar.gz: 616bf3d5e1dc8d18dead07853648ff90af349282
+SHA512:
+  metadata.gz: 48d8ffb897ff377d690a24a5fe3ac54ec1cce3f5750f9d6aafbc15bdd41317b69c1810a26a5eb794bade1053a5c0507a8fc1cf3a026978d5cdf0296b393530b1
+  data.tar.gz: a7003db8bff48097aab1f5afca8f70377174a6c07997eacc5a806faf35467777131dd498209bff78ff50ef24f1127d6e460e0f4b517ab392f0d1e126a6db9011

data/README.md

@@ -0,0 +1,57 @@
+# Outlet
+
+Component that stores results from the Opener Web Services chain into a SQLite 
+Database and shows them into your browser.
+
+
+## Installation
+
+### As part of a Gemfile in a Ruby application
+
+Add this line to your application's Gemfile:
+
+    gem 'opener-outlet',
+        :git=>"git@github.com:opener-project/outlet.git"
+
+And then execute:
+
+    $ bundle install
+
+## Usage
+
+The Opener Outlet comes equipped with a simple webservice. To start the
+webservice type:
+
+    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:
+
+    opinion-detector-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 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-outlet, you also might want to check
+out opener-project/outlet.

data/bin/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/outlet', __FILE__)
+require File.expand_path('../lib/opener/outlet/server', __FILE__)
+
+run Opener::Outlet::Server

data/config/database.rb

@@ -0,0 +1,31 @@
+require 'active_record'
+require 'activerecord-jdbcmysql-adapter'
+
+DB_PASS = ENV["DB_PASS"]
+DB_NAME = ENV["DB_NAME"]
+DB_USER = ENV["DB_USER"]
+DB_HOST = ENV["DB_HOST"]
+
+if ENV["RACK_ENV"] == 'production'
+  ActiveRecord::Base.establish_connection(
+    adapter:  'mysql2',
+    database: DB_NAME,
+    host:     DB_HOST,
+    username: DB_USER,
+    password: DB_PASS
+  )
+else
+  ActiveRecord::Base.establish_connection(
+    adapter:  'mysql2',
+    host:     DB_HOST || 'localhost',
+    username: 'root',
+    password: DB_PASS || '',
+    database: DB_NAME || 'opener_development'
+  )
+end
+
+ActiveRecord::Base.connection.execute("CREATE TABLE IF NOT EXISTS outputs (uuid varchar(40), text text, created_at timestamp DEFAULT CURRENT_TIMESTAMP);")
+
+if ActiveRecord::Base.connection.execute("SHOW INDEX FROM outputs").nil?
+  ActiveRecord::Base.connection.execute("CREATE INDEX uuid_index ON outputs(uuid);")
+end

data/lib/opener/outlet.rb

@@ -0,0 +1,14 @@
+require_relative 'outlet/output'
+require_relative 'outlet/version'
+require_relative 'outlet/server'
+
+module Opener
+  class Outlet
+    def run(input, uuid)
+      output = Output.new(:uuid=>uuid, :text=>input)
+      output.save
+
+      return input
+    end
+  end
+end

data/lib/opener/outlet/output.rb

@@ -0,0 +1,11 @@
+require 'active_record'
+
+module Opener
+  class Outlet
+    class Output < ActiveRecord::Base
+       attr_accessible :uuid, :text
+       
+       validates_uniqueness_of :uuid
+    end
+  end
+end

data/lib/opener/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/outlet/server.rb

@@ -0,0 +1,79 @@
+require 'sinatra'
+require 'nokogiri'
+require 'stringio'
+require_relative './visualizer'
+
+require File.expand_path('../../../../config/database', __FILE__)
+
+module Opener
+  class Outlet
+    class Server < Sinatra::Base
+
+      post '/' do
+        output            = Output.new
+        output.uuid       = params[:request_id]
+        output.text       = params[:input]
+        output.save
+      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 = Output.find_by_uuid(params[:request_id])
+
+            if output
+              content_type(:xml)
+              body(output.text)
+            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 = Output.find_by_uuid(params[:request_id])
+            if output
+              output = StringIO.new(output.text)
+              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 # Outlet
+end # Opener

data/lib/opener/outlet/version.rb

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

data/lib/opener/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 Outlet</title>
+  </head>
+  <body>
+    <h1>Opener Outlet</h1>
+
+    <p>This Web Service, stores the output from a chain of Opener components in a
+      SQlite database when using callbacks and lets you view the output.</p>
+    <p>When using callbacks, the last Callback URL should be the URL that points
+      to 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/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 Outlet</title>
+  </head>
+  <body>
+    <%= @parsed%>
+  </body>
+</html>

data/lib/opener/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 Outlet</title>
+  </head>
+  <body>
+    <h1>Opener Outlet</h1>
+    <%=parsed%>
+  </body>
+</html>

data/lib/opener/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-outlet.gemspec

@@ -0,0 +1,39 @@
+require File.expand_path('../lib/opener/outlet/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name                  = 'opener-outlet'
+  gem.version               = Opener::Outlet::VERSION
+  gem.authors               = ['development@olery.com']
+  gem.summary               = 'Database 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/**/*',
+    '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', '~>3.0.0'
+  gem.add_dependency 'sinatra', '~>1.4.2'
+  gem.add_dependency 'nokogiri'
+  gem.add_dependency 'httpclient'
+  gem.add_dependency 'uuidtools'
+  gem.add_dependency 'jdbc-mysql'
+  gem.add_dependency 'activerecord-jdbcmysql-adapter'
+  gem.add_dependency 'activerecord', '~>3.2'
+  gem.add_dependency 'activesupport', '~>3.2'
+  gem.add_dependency 'opener-webservice'
+
+  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,255 @@
+--- !ruby/object:Gem::Specification
+name: opener-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: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.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: jdbc-mysql
+  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: activerecord-jdbcmysql-adapter
+  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: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !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: 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: Database storing for the web services output when using callbacks.
+email: 
+executables:
+- outlet-server
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/outlet-server
+- config.ru
+- config/database.rb
+- lib/opener/outlet.rb
+- lib/opener/outlet/output.rb
+- lib/opener/outlet/public/outlet.css
+- lib/opener/outlet/server.rb
+- lib/opener/outlet/version.rb
+- lib/opener/outlet/views/index.erb
+- lib/opener/outlet/views/show.erb
+- lib/opener/outlet/views/show.html.erb
+- lib/opener/outlet/visualizer.rb
+- opener-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: Database storing for the web services output when using callbacks.
+test_files: []
+has_rdoc: yard