juxta 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9537d609ce2a9506964a49b399dce7a4f54b4cd7
+  data.tar.gz: be87bc4c13083793d5a0afdf3cb57edec7ae66db
+SHA512:
+  metadata.gz: d11ec8282f12f0656d0eece0923ffbdfa33370f049a855a4af93e061384574e0ed0a1648ae58f0cbe201626a58978a293e4fe685df9dd7e787298ddcf428185d
+  data.tar.gz: 013597f634a633718c0fbc9cc2f7df724fc5014b5a3f4b27cb73b205ac282b41ab70b0525b69725908e356cabeb3ce9fde51604f3bf68ecbf5125cf502c2ec15

data/lib/juxta/connection.rb

@@ -0,0 +1,107 @@
+require 'json'
+require 'rest_client'
+require 'base64'
+
+class Connection
+
+   attr_reader :url
+   attr_reader :workspace
+
+   def initialize( url, workspace, username, password )
+
+      @authtoken = "Basic #{Base64.encode64("#{username}:#{password}")}"
+      @url = "#{url}/juxta"
+      @workspace = workspace
+
+      @timeout = 600        # 10 minute get timeout...
+      @open_timeout = 600   # 10 minute post timeout
+
+      opts = {
+          :timeout => @timeout,
+          :open_timeout=> @open_timeout
+      }
+
+      @rest_client = RestClient::Resource.new( @url, opts )
+   end
+
+   def get_ws_version()
+      start_time = Time.now.to_f
+      resp = @rest_client.get :content_type => "application/json", :authorization => @authtoken
+      dump_time( "get", start_time )
+      json = JSON.parse(resp)
+      return json['version']
+   end
+
+   def get( request )
+      start_time = Time.now.to_f
+      resp = @rest_client[ make_url( request ) ].get :content_type => "application/json", :accept=>'application/json', :authorization => @authtoken
+      dump_time( "get", start_time )
+      JSON.parse(resp)
+   end
+   
+   def get_html( request )
+      start_time = Time.now.to_f
+      resp = @rest_client[ make_url( request ) ].get :content_type => "text/html", :authorization => @authtoken
+      dump_time( "get", start_time )
+      return resp
+   end
+   
+   def get_xml( request )
+      start_time = Time.now.to_f
+      resp = @rest_client[ make_url( request ) ].get :content_type => "text/xml", :authorization => @authtoken
+      dump_time( "get", start_time )
+      return resp
+   end
+
+   def post( request, payload )
+      start_time = Time.now.to_f
+      if payload.nil? == true
+         resp = @rest_client[ make_url( request ) ].post "", :authorization => @authtoken
+      else
+         resp = @rest_client[ make_url( request ) ].post payload.to_json, :authorization => @authtoken, :content_type => "application/json"
+      end
+      dump_time( "post", start_time )
+      return resp
+   end
+   
+   def upload_file( file_name, content_type, file ) 
+      opts = {
+         :sourceName=> file_name,
+         :contentType => content_type, 
+         :sourceFile=> file, 
+         :multipart => true
+      }
+      start_time = Time.now.to_f
+      resp = @rest_client[ make_url( "source" ) ].post opts, :authorization => @authtoken
+      dump_time( "post", start_time )
+      json = JSON.parse(resp)
+      return json[ 0 ]
+   end
+
+   def put( request, payload )
+      start_time = Time.now.to_f
+      resp = @rest_client[ make_url( request ) ].put payload.to_json, :authorization => @authtoken, :content_type => "application/json"
+      dump_time( "put", start_time )
+      return resp
+   end
+
+   def delete( request )
+      start_time = Time.now.to_f
+      resp =  @rest_client[ make_url( request ) ].delete :authorization => @authtoken
+      dump_time( "delete", start_time )
+      return resp
+   end
+
+   def make_url( request )
+     if @workspace.length != 0
+       url = "#{@workspace}/#{request}"
+     else
+       url = request
+     end
+     return url
+   end
+
+   def dump_time( what, start_time )
+     #puts "#{what}: %0.2f mS" % ( ( Time.now.to_f - start_time ) * 1000 )
+   end
+end

data/lib/juxta/utilities.rb

@@ -0,0 +1,35 @@
+require 'uuidtools'
+
+# coordinate access to stdout...
+Log_sem = Mutex.new
+
+def log_message( message )
+   Log_sem.synchronize {
+      puts "#{Time.now.strftime("%T")}-#{Thread.current.object_id % 10000}: #{message}"
+   }
+end
+
+def error_message( message )
+   Log_sem.synchronize {
+      puts( "#{Time.now.strftime("%T")}-#{Thread.current.object_id % 10000}: ERROR ** #{message} **" )
+   }
+end
+
+def make_guid( )
+  UUIDTools::UUID.random_create.to_s.gsub(/-/, '')
+end
+
+def get_filelist( dir )
+  files = Dir.entries( dir )
+  files = files.map { |f| "#{dir}/#{f}"}
+  files = files.delete_if { |f| File.directory?( "#{f}") == true }   # remove any directories
+  return files
+end
+
+def standard_fileset( )
+  fileset = []
+  fileset.push("good-testdata/MD_AmerCh1b.xml")
+  fileset.push("good-testdata/MD_Brit_v1CH1a.xml")
+  return fileset
+
+end

data/lib/juxta.rb

@@ -0,0 +1,457 @@
+require 'juxta/connection'
+require 'juxta/utilities'
+
+class Juxta
+
+  attr :logging
+  attr_reader :connection
+
+  def initialize( url, workspace )
+    @logging = true
+    @connection = Connection.new( url, workspace, "", "" ) 
+  end
+
+  #
+  # workspace behavior
+  #
+  def list_workspaces
+    log_message( "Listing workspaces..." ) unless @logging == false
+    ws_list = @connection.get( "workspace" )
+    return ws_list
+  end
+
+  def create_workspace( workspace_id )
+    log_message( "Creating workspace #{workspace_id} ..." ) unless @logging == false
+    json = { "name" => workspace_id, "description" => "the description for #{workspace_id}" }
+    workspace_id = @connection.post( "workspace", json )
+    return workspace_id
+  end
+
+  def delete_workspace( workspace_id )
+    return delete_asset( "workspace/#{workspace_id}" )
+  end
+
+  #
+  # witness behavior
+  #
+
+  def list_witnesses
+    log_message( "Listing witnesses..." ) unless @logging == false
+    witness_list = @connection.get( "witness" )
+    return witness_list
+  end
+
+  def get_witness( witness_id )
+    log_message( "Getting witness #{witness_id}..." ) unless @logging == false
+    resp = @connection.get( "witness/#{witness_id}" )
+    return resp
+  end
+
+  def rename_witness( witness_id, new_name )
+    log_message( "Renaming witness #{witness_id} to #{new_name}..." ) unless @logging == false
+    json = { 'name' => new_name }
+    resp = @connection.put( "witness/#{witness_id}", json )
+    return resp
+  end
+
+  #
+  # source behavior
+  #
+
+  def list_sources
+    log_message( "Listing sources..." ) unless @logging == false
+    source_list = @connection.get( "source" )
+    return source_list
+  end
+
+  #
+  # xslt behavior
+  #
+
+  def create_xslt( json )
+     asset_id = "xslt"
+     resp = @connection.post(asset_id, json)
+     return resp
+  end
+
+  def list_xslt
+    log_message( "Listing xslt..." ) unless @logging == false
+    xslt_list = @connection.get( "xslt" )
+    return xslt_list
+  end
+
+  #
+  # annotation behavior
+  #
+
+  def create_annotation( set_id, witness_id, json )
+     asset_id = "set/#{set_id}/witness/#{witness_id}/annotation"
+     log_message( "Posting annotations to #{asset_id}..." ) unless @logging == false   
+     resp = @connection.post(asset_id, json)
+     return resp
+  end
+
+  def list_annotations( set_id, witness_id )
+    asset_id = "set/#{set_id}/witness/#{witness_id}"
+    log_message( "Listing annotations for #{asset_id}..." ) unless @logging == false
+    annotation_list = @connection.get( "#{asset_id}/annotation" )
+    return annotation_list
+  end
+
+  def get_annotation( annotation_id )
+    log_message( "Getting annotation #{annotation_id}..." ) unless @logging == false
+    resp = @connection.get( "#{annotation_id}?content=YES" )
+    return resp
+  end
+
+  #
+  # alignmant behavior
+  #
+
+  def create_alignment( set_id, json )
+     asset_id = "set/#{set_id}/alignment"
+     log_message( "Posting alignments to #{asset_id}..." ) unless @logging == false   
+     resp = @connection.post(asset_id, json)
+     return resp
+  end
+
+  def list_alignments( set_id )
+    asset_id = "set/#{set_id}"
+    log_message( "Listing alignments for #{asset_id}..." ) unless @logging == false
+    annotation_list = @connection.get( "#{asset_id}/alignment" )
+    return annotation_list
+  end
+
+  def get_alignment( set_id, alignment_id )
+    asset_id = "set/#{set_id}/alignment/#{alignment_id}"
+    log_message( "Getting alignment #{asser_id}..." ) unless @logging == false
+    resp = @connection.get( "#{asset_id}" )
+    return resp
+  end
+
+  #
+  # delete behavior
+  #
+
+  def delete_asset( asset_id )
+
+    log_message( "Deleting asset #{asset_id} ..." ) unless @logging == false
+    resp = @connection.delete( asset_id )
+    if resp['status'] == 'FAILED'
+       error_message( "failed to delete asset: #{asset_id}")
+       return false
+    end
+    return true
+  end
+
+  def delete_witness( witness_id )
+     return delete_asset( "witness/#{witness_id}" )
+  end
+
+  def delete_source( source_id )
+    return delete_asset( "source/#{source_id}" )
+  end
+
+  def delete_set( set_id )
+    return delete_asset( "set/#{set_id}" )
+  end
+
+  def delete_annotation( set_id, witness_id, annotation_id )
+    return delete_asset( "set/#{set_id}/witness/#{witness_id}/annotation/#{annotation_id}" )
+  end
+
+  def delete_alignment( set_id, alignment_id )
+    return delete_asset( "set/#{set_id}/alignment/#{alignment_id}" )
+  end
+
+  #
+  # upload behavior
+  #
+
+  def upload_source( file_name )
+
+     id = make_guid()
+     log_message( "Uploading #{file_name} as #{id} ..." ) unless @logging == false
+     src_id = @connection.upload_file( id, "text/xml", open( file_name ))
+
+     srcs = @connection.get("source")
+     srcs.each do |src|
+       if src['id'] == src_id
+         log_message( "successfully uploaded file: #{file_name} (#{src['name']})" ) unless @logging == false
+         return src_id
+       end
+
+     end
+
+     error_message( "failed to upload file: #{file_name}")
+     return nil
+  end
+
+  #
+  # transform behavior
+  #
+
+  def transform_source( file_id )
+
+    log_message( "Transforming #{file_id} ..." ) unless @logging == false
+    json = { 'source' => file_id, 'finalName' => make_guid() }
+    wit_id = @connection.post( "transform", json )
+    return wit_id
+  end
+
+  #
+  # witness set behavior
+  #
+
+  def list_sets
+    log_message( "Listing sets..." ) unless @logging == false
+    set_list = @connection.get( "set" )
+    return set_list
+  end
+
+  def make_set( witness_ids )
+    log_message( "Creating witness set ..." ) unless @logging == false
+    set = { 'name' => make_guid(), 'witnesses' => witness_ids }
+    set_id = @connection.post( "set", set )
+    return set_id
+  end
+
+  def async_tokenize_set( set_id )
+     log_message( "Tokenizing witness set #{set_id}..." ) unless @logging == false
+     task_id = @connection.post( "set/#{set_id}/tokenize", nil)
+     return task_id
+  end
+
+  def tokenize_set( set_id )
+    task_id = async_tokenize_set( set_id )
+    while true do
+      sleep(2.0)
+      resp = get_status( task_id )
+      case resp
+        when 'COMPLETE'
+          return true
+
+        when 'FAILED'
+           error_message( "failed to tokenize set: #{set_id}")
+           return false
+      end
+    end
+  end
+
+  def async_collate_set( set_id )
+     log_message( "Collating witness set #{set_id}..." ) unless @logging == false
+     task_id = @connection.post( "set/#{set_id}/collate", nil)
+     return task_id
+  end
+
+  def collate_set( set_id )
+    task_id = async_collate_set( set_id )
+    while true do
+      sleep(2.0)
+      resp = get_status( task_id )
+      case resp
+        when 'COMPLETE'
+          return true
+
+        when 'FAILED'
+          error_message( "failed to tokenize set: #{set_id}")
+          return false
+      end
+    end
+  end
+
+  #
+  # Search behavior
+  #
+  def search( query )
+    log_message( "Searching for #{query}..." ) unless @logging == false
+    resp = @connection.get("search?q=#{query}")
+    return resp
+  end
+
+  #
+  # task status behavior
+  #
+
+  def get_status( task_id )
+    log_message( "Getting status for #{task_id}..." ) unless @logging == false
+    resp = @connection.get("task/#{task_id}/status")
+    return resp['status']
+  end
+
+  #
+  # get asset behavior
+  #
+
+  def async_get_as_html( asset_id )
+    log_message( "Getting html #{asset_id}..." ) unless @logging == false
+    resp = @connection.get_html( asset_id )
+    if resp.include?('RENDERING') == true
+      return resp.split( ' ' )[ 1 ]
+    end
+    return nil
+  end
+
+  def get_as_html( asset_id )
+     task_id = async_get_as_html( asset_id )
+     if task_id.nil? == false
+        while true do
+           sleep(2.0)
+           resp = get_status( task_id )
+           case resp
+           when 'COMPLETE'
+              return @connection.get_html( asset_id )
+
+           when 'FAILED'
+              error_message( "failed to get html asset: #{asset_id}")
+              return false
+           end
+        end
+     end
+     return resp
+  end
+
+  def async_get_as_json( asset_id )
+    log_message( "Getting json #{asset_id}..." ) unless @logging == false
+    resp = @connection.get( asset_id )
+    if resp['status'] == 'RENDERING'
+      return resp['taskId']
+    end
+    return nil
+  end
+
+  def get_as_json( asset_id )
+     task_id = async_get_as_json( asset_id )
+     if task_id.nil? == false
+        while true do
+           sleep(2.0)
+           resp = get_status( task_id )
+           case resp
+           when 'COMPLETE'
+              return @connection.get( asset_id )
+
+           when 'FAILED'
+              error_message( "failed to get json asset: #{asset_id}")
+              return false
+           end
+        end
+     end
+     return false
+  end
+
+  def get_info( asset_id )
+    log_message( "Getting info for #{asset_id}..." ) unless @logging == false
+    resp = @connection.get( "#{asset_id}/info" )
+    return resp
+  end
+
+  def get_usage( asset_id )
+    log_message( "Getting usage for #{asset_id}..." ) unless @logging == false
+    resp = @connection.get( "#{asset_id}/usage" )
+    return resp
+  end
+
+  def get_xslt( asset_id )
+    log_message( "Getting xslt #{asset_id}..." ) unless @logging == false
+    resp = @connection.get_html( "xslt/#{asset_id}" )
+    return resp
+  end
+
+  #
+  # TEI Parallel segmentation export
+  #
+
+  def export( set_id, base_id )
+    log_message( "Exporting set #{set_id}..." ) unless @logging == false
+    resp = @connection.get_xml( "set/#{set_id}/export?mode=teips&base=#{base_id}&sync" )
+    return resp
+  end
+
+  # 
+  # Edition starter
+  # 
+
+  def edition( set_id, title, line_freq, base_id, wit_siglum_map )
+     data = {}
+     data['title'] = title
+     data['lineFrequency'] = line_freq
+     data['numberBlankLines'] = false
+     witnesses = []
+     wit_siglum_map.each do |id, siglum|
+        wit = {"id"=> id, "include"=>true, "base"=>(id == base_id), "siglum"=>siglum}
+        witnesses << wit
+     end
+     data['witnesses'] = witnesses
+
+     log_message( "Exporting edition for set #{set_id}..." ) unless @logging == false   
+     resp = @connection.post("set/#{set_id}/edition", data)
+
+     # wait for task to complete
+     parsed = JSON.parse(resp)
+     token = parsed['token']
+     task = parsed['taskId']
+
+     while true do
+      sleep(2.0)
+      resp = get_status( task )
+      puts resp
+      case resp
+        when 'COMPLETE'
+          break
+
+        when 'FAILED'
+          error_message( "failed to tokenize set: #{set_id}")
+          return false
+      end
+    end
+
+    # now request the HTML edition and pass along the token
+    html = @connection.get_html("set/#{set_id}/edition?token=#{token}&format=html")
+    return html
+
+  end
+
+  #
+  # convience methods
+  #
+
+  def create_witness_set( file_list )
+
+    src_ids = []
+    wit_ids = []
+
+    file_list.each do |file|
+
+      # create source
+      src_id = upload_source( file )
+      src_ids.push( src_id )
+
+      # xform to witness
+      wit_id = transform_source( src_id )
+      wit_ids.push( wit_id )
+
+    end
+
+    # create set from witnesses
+    set_id = make_set( wit_ids )
+
+    return src_ids, wit_ids, set_id
+  end
+
+  def destroy_witness_set( source_list, witness_list )
+
+    witness_list.each do |wit_id|
+      status = delete_witness( wit_id )
+      return false unless status == true
+    end
+
+    source_list.each do |src_id|
+      status = delete_source( src_id )
+      return false unless status == true
+    end
+
+    return true
+  end
+
+
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: juxta
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Nick Laiacona
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.7
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.7.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.7.7
+- !ruby/object:Gem::Dependency
+  name: OptionParser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+- !ruby/object:Gem::Dependency
+  name: uuidtools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.1.3
+description: JuxtaWS Ruby bindings
+email: nick@performantsoftware.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/juxta.rb
+- lib/juxta/connection.rb
+- lib/juxta/utilities.rb
+homepage: http://rubygems.org/gems/juxta
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: JuxtaWS Ruby bindings
+test_files: []
+has_rdoc: