talia_core 0.5.4 → 0.7.0

data/config/database.yml

@@ -1,19 +0,0 @@
---- 
-development: 
-  adapter: jdbcmysql
-  database: testx_talia_development
-  username: talia
-  password: talia
-  host: localhost
-test: 
-  adapter: jdbcmysql
-  database: testx_talia_test
-  username: talia
-  password: talia
-  host: localhost
-production: 
-  adapter: jdbcmysql
-  database: testx_talia_production
-  username: talia
-  password: talia
-  host: localhost

data/config/rdfstore.yml

@@ -1,13 +0,0 @@
---- 
-production: 
-  type: sesame
-  backend: native
-  location: ./sesame_production.db
-test: 
-  type: sesame
-  backend: native
-  location: ./sesame_test.db
-development: 
-  type: sesame
-  backend: native
-  location: ./sesame_development.db

data/config/talia_core.yml

@@ -1,24 +0,0 @@
---- 
-local_uri: http://localhost:5000/
-default_namespace_uri: http://default.dummy/
-rdf_connection_file: rdfstore
-ardf_log_level: 0
-standalone_db: true
-db_file: database
-namespaces: 
-  hyper: http://www.hypernietzsche.org/ontology/
-  foaf: http://xmlns.com/foaf/0.1/
-  skos: http://www.w3.org/2004/02/skos/core#
-  dct: http://purl.org/dc/terms/
-  dcmit: http://purl.org/dc/dcmitype/
-  dcns: http://purl.org/dc/elements/1.1/
-  luccadom: http://trac.talia.discovery-project.eu/wiki/LuccaOntology#
-  talias: http://trac.talia.discovery-project.eu/wiki/StructuralOntology#
-  taliadom: http://trac.talia.discovery-project.eu/wiki/SampleDomainOntology#
-  sesame: http://www.openrdf.org/schema/sesame#
-  swicky: http://discovery-project.eu/ontologies/philoSpace/
-  discovery: http://discovery-project.eu/ontologies/scholar/0.1/
-site_name: Talia Test
-iip_server_uri: http://localhost:80/fcgi-bin/iipsrv.fcgi
-vips_command: /opt/local/vips
-convert_command: /usr/local/bin/convert

data/generators/talia_base/templates/migrations/bj_migration.rb

@@ -1,10 +0,0 @@
-require 'bj'
-
-          class BjMigration < ActiveRecord::Migration
-            def self.up
-              Bj::Table.each{|table| table.up}
-            end
-            def self.down
-              Bj::Table.reverse_each{|table| table.down}
-            end
-          end

data/lib/JXslt/jxslt.rb

@@ -1,60 +0,0 @@
-include Java if jruby?
-module JXslt
-  Dir["#{RAILS_ROOT}/lib/saxon*.jar"].each { |jar| require jar }
-  include_class "javax.xml.transform.TransformerFactory"
-  include_class "javax.xml.transform.Transformer"
-  include_class "javax.xml.transform.stream.StreamSource"
-  include_class "javax.xml.transform.stream.StreamResult"
-  include_class "java.lang.System"
-
-  class XsltProcessor
-
-    puts $CLASSPATH
-
-
-    def transform(xslt, infile, outfile, options)
-      if options[:in] == "stream"
-        in_var = StreamSource.new(infile)
-      else
-        sr = java.io.StringReader.new(infile)
-        in_var =  StreamSource.new(sr)
-      end
-      if options[:out] == "stream"
-        out_var = StreamResult.new(outfile)
-      else
-        sw = java.io.StringWriter.new()
-        out_var = StreamResult.new(sw)
-      end
-      if options[:xslt] == "stream"
-        xslt_var = StreamSource.new(xslt)
-      else
-        sxs = java.io.StringReader.new(xslt)
-        xslt_var = StreamSource.new(sxs)
-      end
-      transformer = @tf.newTransformer(xslt_var)
-      unless options[:transformer_parameters].nil?
-        options[:transformer_parameters].each do |key, value|
-          transformer.setParameter(key, java.lang.String.new(value))
-        end
-      end
-      transformer.transform(in_var, out_var)
-      if options[:out] != "stream"
-        outfile = sw.toString()
-      end
-    end
-  end # XsltProcessor
-  class Saxon < XsltProcessor
-    TRANSFORMER_FACTORY_IMPL = "net.sf.saxon.TransformerFactoryImpl"
-    def initialize
-      System.setProperty("javax.xml.transform.TransformerFactory", TRANSFORMER_FACTORY_IMPL)
-      @tf = TransformerFactory.newInstance
-    end
-  end
-  class Xalan < XsltProcessor
-    TRANSFORMER_FACTORY_IMPL = "org.apache.xalan.processor.TransformerFactoryImpl"
-    def initialize
-      System.setProperty("javax.xml.transform.TransformerFactory", TRANSFORMER_FACTORY_IMPL)
-    @tf = TransformerFactory.newInstance
-  end
-end
-end if jruby?

data/lib/swicky/json_encoder.rb

@@ -1,179 +0,0 @@
-module Swicky
-
-  # Takes a number of triples and encodes them in the SIMILE JSON format
-  class JsonEncoder
-
-    def initialize(triples)
-      @triples = triples
-      @types_hash = {}
-      @properties_hash = {}
-      @label_hash = {}
-      @label_inverse = {}
-    end
-
-    def to_json
-      puts @triples.inspect
-      @items ||= begin
-        items = []
-        # First a round to make sure that each item has a label
-        triple_hash.each { |object, values| values['label'] = make_label!(object, values) }
-        # Now build the items themselves
-        triple_hash.each { |object, values| items += build_item(object, values) }
-        items
-      end
-      # hashy = { 'items' => @items, 'types' => @types_hash, 'properties' => @properties_hash }
-      # puts hashy.inspect
-      { 'items' => @items, 'types' => @types_hash, 'properties' => @properties_hash }.to_json
-    end  
-
-    private
-
-    def triple_hash
-      @triple_hash ||= begin
-        triple_hash = {}
-        # Sort all the triples into a hash, mapping all predicates
-        # to a single subject entry and all objects into a single
-        # predicate entry for each subject or predicate
-        @triples.each do |triple|
-          subject = triple.shift.to_uri
-          triple_hash[subject] ||= {}
-          predicate = triple.shift.to_uri
-          triple_hash[subject][predicate] ||= []
-          triple_hash[subject][predicate] << triple.first
-        end
-        triple_hash
-      end
-    end
-
-    # Builds the entry for one "item". This alwasys returns an array, as there may
-    # be additional items created as placeholders for label references
-    def build_item(object, values)
-      items = []
-      item = {}
-      item['uri'] = object.to_s
-
-      item['type'] = make_types!(values)
-      item['label'] = values.delete('label')
-
-      # Add the normal predicates
-      values.each do |predicate, objects|
-        predicate_local = make_predicate_local(predicate)
-        resource_labels, additional_items = as_labels(objects)
-        item[predicate_local] = resource_labels
-        items += additional_items
-      end
-      
-      items << item
-      items
-    end
-    
-    # Turns the given resources into label references
-    def as_labels(resources)
-      additional_items = []
-      labels = resources.collect do |res| 
-        label, additional = resource_label(res) 
-        additional_items << additional if(additional)
-        label
-      end
-      labels.uniq!
-      [(labels.size == 1) ? labels.first : labels, additional_items]
-    end
-    
-    def resource_label(resource)
-      return resource if(resource.is_a?(String))
-      return @label_inverse[resource.to_s] if(@label_inverse[resource.to_s])
-      label = make_label!(resource, {})
-      [label, {'uri' => resource.to_s, 'label' => label}]
-    end
-
-    # Check the type definitions from the given hash and transform them
-    # to "type" entries in the JSON structure
-    def make_types!(hash)
-      # First, check for the types
-      types = hash.delete(get_key_from(N::RDF.type, hash)) || []
-      # Add a default type if we don't have one
-      if(types.empty?)
-        types = [ N::RDF.Resource ]
-      end
-      # All types will be referred to by their local name
-      types.collect! { |type| make_type_local(type) }
-      types.uniq!
-      types
-    end
-    
-    
-    # Create the label: Either use the RDFS label or the last part of th
-    # uri. This also inserts the label into an "inverse" hash so that 
-    # labels can be looked up by the uri
-    def make_label!(uri, hash)
-      return @label_inverse[uri.to_s] if(@label_inverse[uri.to_s]) # label already exists
-      label = hash.delete(get_key_from(N::RDFS.label, hash)) || []
-      if(label.empty?)
-        label = check_label(label_for(uri), uri)
-      else
-        label = check_label(label.first, uri)
-      end
-      
-      label.to_s
-    end
-
-    # Get the part of the the uri that can be used as a label
-    def label_for(uri)
-      /[\/#]?([^\/#]+)\Z/.match(uri.to_s)[1]
-    end
-    
-    # Check if the given label can be used, and adapt it if necessary
-    def check_label(label, uri)
-      label = first_free(label, uri.to_s, @label_hash)
-      @label_inverse[uri.to_s] ||= label
-      label
-    end
-
-    # Little kludge for getting badly-specified keys
-    def get_key_from(key, hash)
-      hash.keys.find { |k| k.to_s == key.to_s }
-    end
-    
-    # Finds the first "free" element in the hash. This checks
-    # if hash[initial_value] is empty or equal to "value", if that is not the
-    # case if will try "initial_value2", "initial_value3", ... until the
-    # condition is fulfilled
-    def first_free(initial_key, value, hash)
-      candidate = initial_key
-      hash[candidate] ||= value
-      count = 1
-      while(hash[candidate] != value)
-        count += 1
-        candidate = "#{initial_key}#{count}"
-        hash[candidate] ||= value
-      end
-      candidate
-    end
-
-    # Create the local name for the predicate, and add the definition
-    # to the "properties" hash if necessary. This will also attempt to
-    # avoid collisions if some predicates map to the same local name
-    #
-    # TODO: Doesn't force RDF:label etc to map to the "correct" local 
-    #       name in case of collisions
-    def make_predicate_local(predicate)
-      first_free(predicate.to_uri.local_name, { 'uri' => predicate.to_s, 'valueType' => 'item' }, @properties_hash)
-    end
-
-    # Making local for types
-    def make_type_local(type)
-      first_free(type.to_uri.local_name, { 'uri' => type.to_s }, @types_hash)
-    end
-
-
-    # The entry for the "properties" hash for the given predicate
-    def predicate_property(predicate_uri)
-      {
-        "uri" => predicate_url,
-        "valueType" => "item"
-      }
-    end
-
-  end
-
-end

data/lib/talia_core/agent.rb

@@ -1,14 +0,0 @@
-module TaliaCore
-
-  # Some item that "has the power to act". This can either be a person or another
-  # entity, like an institution or a corporation
-  class Agent < Source
-
-    has_rdf_type N::DCT.Agent
-
-    singular_property :name, N::DCNS.title
-    singular_property :description, N::DCNS.description
-
-  end
-
-end

data/lib/talia_core/background_jobs/job.rb

@@ -1,82 +0,0 @@
-module TaliaCore
-  module BackgroundJobs
-
-    # Exception class for blocked jobs
-    class JobBlockedError < RuntimeError
-    end
-
-    # A Background job run from Talia. The Job class is designed to be able to run long-running
-    # tasks both from the command line and Talia's background job runner.
-    class Job
-
-      # Creates a background job with progress metering. If a tag is given, it will attempt to block
-      # the creation of further jobs with the same tag. This will also use the runner script, called
-      # with the current ruby binary
-      def self.submit_with_progress(jobs, options = {})
-        # add the runner script and ruby call to the jobs
-        jobs = make_jobs(jobs)
-        Bj.submit(jobs, options) do |job|
-          if(tag = job.tag)
-            tagged = Bj.table.job.find(:all, :conditions => ["(state != 'finished' and state != 'dead' and tag = ?)", tag])
-            # The error will break the transation and leave the db in a clean state
-            raise(JobBlockedError, "Tried to create another job with tag #{tag}.") unless(tagged.size == 1)
-          end
-          # Update the environment so the runner can find the job id
-          job.env['JOB_ID'] ||= job.id.to_s
-          job.save! 
-          job
-        end
-      end
-
-      # Runs the block with an active progress meter, creating the progress object before starting, and
-      # deleting it from the db after completion. This way the progress_jobs table should remain mostly
-      # clean.
-      def self.run_progress_job
-        job_id = ENV['JOB_ID']
-        raise(RuntimeError, "Cannot run job: Job id not given or non-existent (#{job_id})") unless(job_id && Bj.table.job.exists?(job_id))
-        ProgressJob.create_progress!(job_id) unless(ProgressJob.exists?(:job_id => job_id))
-        yield
-      ensure
-        job_id = ENV['JOB_ID']
-        ProgressJob.delete(:job_id => job_id)
-      end
-
-      # Runs the block with the progress meter for the current job. This may be used multiple times.
-      def self.run_with_progress(message, item_count)
-        # Wrap this in the progress job call. This way it will work fine standalone
-        run_progress_job do
-          job_id = ENV['JOB_ID']
-          # Create the progress meter
-          progress = ProgressJob.find(:first, :conditions => {:job_id => job_id})
-          raise(RuntimeError, 'Progress meter not found for job.') unless progress
-          progress.update_attributes(:item_count => item_count, :progress_message => message, :processed_count => 0, :started_at => Time.now)
-
-          yield(progress)
-
-          progress.finish
-        end
-      end
-
-      private
-
-      def self.ruby
-        return @ruby if(@ruby)
-        c = ::Config::CONFIG
-        ruby = File.join(c['bindir'], c['ruby_install_name']) << c['EXEEXT']
-        @ruby = if system('%s -e 42' % ruby)
-          ruby
-        else
-          system('%s -e 42' % 'ruby') ? 'ruby' : warn('no ruby in PATH/CONFIG')
-        end
-      end
-
-      # Make the caller line for each job
-      def self.make_jobs(jobs)
-        jobs = [ jobs ] unless(jobs.kind_of?(Array))
-        jobs.collect { |current_job| "#{ruby} #{File.join('.', 'script', 'runner')} #{File.join('jobs', current_job)}" }
-      end
-
-    end
-
-  end
-end

data/lib/talia_core/background_jobs/progress_job.rb

@@ -1,68 +0,0 @@
-module TaliaCore
-  module BackgroundJobs
-    
-    # Helper table to track the current status of a long-running task
-    class ProgressJob < ActiveRecord::Base
-      
-      # Minimum interval for database updates. 
-      DB_UPDATE_INTERVAL = 2
-      
-      validates_numericality_of :job_id, :only_integer => true
-      validates_numericality_of :processed_count, :only_integer => true, :greater_than_or_equal => 0
-      validates_numericality_of :item_count, :only_integer => true, :greater_than => 0
-      
-      # Create a new progress job
-      def self.create_progress!(job_id, message = '', item_count = 1)
-        job_prog = new(:job_id => job_id, :progress_message => message, :item_count => item_count, :processed_count => 0)
-        job_prog.save!
-        job_prog
-      end
-      
-      # Clears the progress for processes no longer active
-      def self.clear
-        find(:all).each do |job_prog|
-          delete(job_prog.id) if(!Bg.table.job.exists?(job_id) || Bg.tablejob.find(job_id).finished?)
-        end
-      end
-      
-      # Increments the number of processed items. To avoid flooding the db, the same object will
-      # only save this value at most all DB_UPDATE_INTERVAL seconds. Will return true if the
-      # element was saved, false otherwise. 
-      def inc(inc_value = 1)
-        pc_old = self.processed_count
-        self.processed_count = pc_old + inc_value
-        if(!@last_update || ((Time.now - @last_update) > DB_UPDATE_INTERVAL))
-          save!
-          @last_update = Time.now
-          true
-        else
-          false
-        end
-      end
-      
-      def finish
-        self.processed_count = self.item_count
-        save!
-      end
-      
-      # The percentage completed
-      def percentage
-        [((self.processed_count * 100) / self.item_count), 100].min
-      end
-      
-      # Elapsed time in seconds
-      def elapsed
-        return unless(self.started_at)
-        Time.now - started_at
-      end
-      
-      # Returns the estimated time remaining on the current job
-      def eta
-        ((elapsed * 100) / percentage) - elapsed
-      end
-      
-      
-    end
-    
-  end
-end