talia_core 0.4.0

data/lib/progressbar.rb

@@ -0,0 +1,236 @@
+#
+# Ruby/ProgressBar - a text progress bar library
+#
+# Copyright (C) 2001-2005 Satoru Takabayashi <satoru@namazu.org>
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms
+# of Ruby's license.
+#
+
+class ProgressBar
+  VERSION = "0.9"
+
+  def initialize (title, total, out = STDERR)
+    @title = title
+    @total = total
+    @out = out
+    @terminal_width = 80
+    @bar_mark = "o"
+    @current = 0
+    @previous = 0
+    @finished_p = false
+    @start_time = Time.now
+    @previous_time = @start_time
+    @title_width = 14
+    @format = "%-#{@title_width}s %3d%% %s %s"
+    @format_arguments = [:title, :percentage, :bar, :stat]
+    clear
+    show
+  end
+  attr_reader   :title
+  attr_reader   :current
+  attr_reader   :total
+  attr_accessor :start_time
+
+  private
+  def fmt_bar
+    bar_width = do_percentage * @terminal_width / 100
+    sprintf("|%s%s|", 
+            @bar_mark * bar_width, 
+            " " *  (@terminal_width - bar_width))
+  end
+
+  def fmt_percentage
+    do_percentage
+  end
+
+  def fmt_stat
+    if @finished_p then elapsed else eta end
+  end
+
+  def fmt_stat_for_file_transfer
+    if @finished_p then 
+      sprintf("%s %s %s", bytes, transfer_rate, elapsed)
+    else 
+      sprintf("%s %s %s", bytes, transfer_rate, eta)
+    end
+  end
+
+  def fmt_title
+    @title[0,(@title_width - 1)] + ":"
+  end
+
+  def convert_bytes (bytes)
+    if bytes < 1024
+      sprintf("%6dB", bytes)
+    elsif bytes < 1024 * 1000 # 1000kb
+      sprintf("%5.1fKB", bytes.to_f / 1024)
+    elsif bytes < 1024 * 1024 * 1000  # 1000mb
+      sprintf("%5.1fMB", bytes.to_f / 1024 / 1024)
+    else
+      sprintf("%5.1fGB", bytes.to_f / 1024 / 1024 / 1024)
+    end
+  end
+
+  def transfer_rate
+    bytes_per_second = @current.to_f / (Time.now - @start_time)
+    sprintf("%s/s", convert_bytes(bytes_per_second))
+  end
+
+  def bytes
+    convert_bytes(@current)
+  end
+
+  def format_time (t)
+    t = t.to_i
+    sec = t % 60
+    min  = (t / 60) % 60
+    hour = t / 3600
+    sprintf("%02d:%02d:%02d", hour, min, sec);
+  end
+
+  # ETA stands for Estimated Time of Arrival.
+  def eta
+    if @current == 0
+      "ETA:  --:--:--"
+    else
+      elapsed = Time.now - @start_time
+      eta = elapsed * @total / @current - elapsed;
+      sprintf("ETA:  %s", format_time(eta))
+    end
+  end
+
+  def elapsed
+    elapsed = Time.now - @start_time
+    sprintf("Time: %s", format_time(elapsed))
+  end
+  
+  def eol
+    if @finished_p then "\n" else "\r" end
+  end
+
+  def do_percentage
+    if @total.zero?
+      100
+    else
+      @current  * 100 / @total
+    end
+  end
+
+  def get_width
+    # FIXME: I don't know how portable it is.
+    default_width = 80
+    begin
+      tiocgwinsz = 0x5413
+      data = [0, 0, 0, 0].pack("SSSS")
+      if @out.ioctl(tiocgwinsz, data) >= 0 then
+        rows, cols, xpixels, ypixels = data.unpack("SSSS")
+        if cols >= 0 then cols else default_width end
+      else
+        default_width
+      end
+    rescue Exception
+      default_width
+    end
+  end
+
+  def show
+    arguments = @format_arguments.map {|method| 
+      method = sprintf("fmt_%s", method)
+      send(method)
+    }
+    line = sprintf(@format, *arguments)
+
+    width = get_width
+    if line.length == width - 1 
+      @out.print(line + eol)
+      @out.flush
+    elsif line.length >= width
+      @terminal_width = [@terminal_width - (line.length - width + 1), 0].max
+      if @terminal_width == 0 then @out.print(line + eol) else show end
+    else # line.length < width - 1
+      @terminal_width += width - line.length + 1
+      show
+    end
+    @previous_time = Time.now
+  end
+
+  def show_if_needed
+    if @total.zero?
+      cur_percentage = 100
+      prev_percentage = 0
+    else
+      cur_percentage  = (@current  * 100 / @total).to_i
+      prev_percentage = (@previous * 100 / @total).to_i
+    end
+
+    # Use "!=" instead of ">" to support negative changes
+    if cur_percentage != prev_percentage || 
+        Time.now - @previous_time >= 1 || @finished_p
+      show
+    end
+  end
+
+  public
+  def clear
+    @out.print "\r"
+    @out.print(" " * (get_width - 1))
+    @out.print "\r"
+  end
+
+  def finish
+    @current = @total
+    @finished_p = true
+    show
+  end
+
+  def finished?
+    @finished_p
+  end
+
+  def file_transfer_mode
+    @format_arguments = [:title, :percentage, :bar, :stat_for_file_transfer]
+  end
+
+  def format= (format)
+    @format = format
+  end
+
+  def format_arguments= (arguments)
+    @format_arguments = arguments
+  end
+
+  def halt
+    @finished_p = true
+    show
+  end
+
+  def inc (step = 1)
+    @current += step
+    @current = @total if @current > @total
+    show_if_needed
+    @previous = @current
+  end
+
+  def set (count)
+    if count < 0 || count > @total
+      raise "invalid count: #{count} (total: #{@total})"
+    end
+    @current = count
+    show_if_needed
+    @previous = @current
+  end
+
+  def inspect
+    "#<ProgressBar:#{@current}/#{@total}>"
+  end
+end
+
+class ReversedProgressBar < ProgressBar
+  def do_percentage
+    100 - super
+  end
+end
+

data/lib/role.rb

@@ -0,0 +1,12 @@
+class Role < ActiveRecord::Base
+  has_and_belongs_to_many :users
+    
+  def self.find_all_names
+    self.find(:all, :select => :name).map(&:name)
+  end
+  
+  def self.find_by_names(names)
+    names = names.map(&:to_s)
+    self.find(:all, :conditions => [ "name IN (?)", names])
+  end
+end

data/lib/talia_cl/command_line.rb

@@ -0,0 +1,39 @@
+# 
+# This are the methods to set up the commands for the talia command line tool.
+# 
+module TaliaCommandLine
+  
+  # Hash with the command line commands
+  @commands = {}
+
+  # Set command description
+  def self.desc(description)
+    @description = description
+  end
+
+  # Create a new command for the command line
+  def self.command(name, &block)
+    description = @description ? @description : ""
+    @commands[name.to_sym] = [ description, block ]
+  end
+
+  # Run this to iterate through all the commands. This will pass the following
+  # parameters to the block: command name, description
+  def self.each(&block)
+    @commands.each do |key, value|
+      block.call(key, value[0], value[1])
+    end
+  end
+
+  # Returns true if the command exists
+  def self.command?(command)
+    command && @commands[command.to_sym] != nil 
+  end
+
+  # Run the given command
+  def self.run_command(command, *options)
+    raise(RuntimeError, "Command does not exist: #{command}") unless @commands[command.to_sym]
+    @commands[command.to_sym][1].call(*options)
+  end
+
+end

data/lib/talia_cl/commands/standalone/cl_options.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+gem 'optiflag'
+require 'optiflag'
+
+# Parse for the command line
+module TaliaCommands extend OptiFlagSet
+  
+  and_process!
+end

data/lib/talia_cl/commands/standalone/standalone_generate.rb

@@ -0,0 +1,75 @@
+require 'ftools'
+require 'fileutils'
+
+# This is used to create a skeleton directory with the necessary
+# files to set up a standalone Talia application.
+module TaliaCommandLine
+  
+  class << self
+  
+    # Create a standalone installation directory for Talia
+    def create_standalone(directory)
+      if(File.exist?(directory))
+        puts "The target directory already exists: #{directory}"
+        return -1
+      end
+
+      begin
+        puts("Creating Talia standalone in #{directory}")
+        File.makedirs(directory)
+
+        # Copy the rake task extensions
+        copy_dir(directory, "tasks")
+        
+        # Copy the rakefile
+        copy_file(directory, "", File.join('standalone_templates', 'Rakefile'), 'Rakefile')
+        
+        # copy the config directory
+        File.makedirs(File.join(directory, "config"))
+        copy_file(directory, "config", "database.yml.example", "database.yml")
+        copy_file(directory, "config", "r„dfstore.yml.redland_example", "rdfstore.yml")
+        copy_file(directory, "config", "talia_core.yml.example", "talia_core.yml")
+      rescue
+        puts "Error creating. Removing files."
+        FileUtils.rm_rf(directory)
+        raise
+      end
+    end
+
+    protected
+
+
+    # This goes to the root directory for the "shared" templates. (The ones
+    # contained in the talia generators.
+    def core_root
+      File.join(File.expand_path(File.dirname(__FILE__)), "..", "..", "..", "..")
+    end
+    
+
+    # Recursively copies a directory of template files.
+    def copy_dir(targetdir, dirname)
+      puts "Processing directory #{dirname}"
+      targetdir = dirname unless(targetdir)
+      File.makedirs(File.join(targetdir, dirname))
+      Dir["#{File.join(core_root, dirname)}/**"].each do |file|
+        unless(file =~ /^\..*/) # exclude hidden/directory files
+          if(File.directory?(file))
+            copy_dir(targetdir, File.join(dirname, File.basename(file)))
+          else
+            copy_file(targetdir, dirname, File.basename(file))
+          end
+        end
+      end
+    end
+    
+    # Copies a file to the new target directory in the given path
+    def copy_file(targetdir, relative_path, name, target_name = nil)
+      source = File.join(core_root, relative_path, name)
+      target_name = name unless(target_name)
+      target = File.join(targetdir, relative_path, target_name)
+      File.cp(source, target)
+      puts "Copied #{File.join(relative_path, name)} to #{target_name}"
+    end
+  
+  end
+end

data/lib/talia_cl/commands/standalone.rb

@@ -0,0 +1,25 @@
+# Define the command for generating a standalone Talia application
+module TaliaCommandLine
+ 
+  desc "Generate a standalone application"
+  command(:standalone) do
+    # Loader file for the talia console
+    $: << File.join(File.expand_path(File.dirname(__FILE__)), "standalone")
+    
+    require 'cl_options'
+    require 'standalone_generate'
+    
+    directory = ARGV.shift
+    
+    unless(directory)
+      puts("No directory given. Please use 'talia standalone <directory> [options]'")
+      exit -1
+    end
+    
+    # flags = TaliaCommands::flags
+    
+    create_standalone(directory)
+  end
+
+end
+

data/lib/talia_cl/commands/talia_console/cl_options.rb

@@ -0,0 +1,55 @@
+require 'rubygems'
+gem 'optiflag'
+require 'optiflag'
+
+# Parse for the command line
+module TaliaCommands extend OptiFlagSet
+  
+  optional_flag "talia_root" do
+    description "Path to the TALIA_ROOT. (default: automatic)"
+    one_arg
+  end
+  
+  optional_flag "talia_config" do
+    description "Talia configuration file name. (default: talia_core.yml)"
+    one_arg
+  end
+  
+  optional_flag "environment" do
+    description "Environment for connections. (default: devlopement)"
+    one_arg
+  end
+  
+  optional_switch_flag "reset_db" do
+    description "Reset the database"
+  end
+  
+  optional_switch_flag "reset_rdf" do
+    description "Reset the RDF store"
+  end
+  
+  optional_switch_flag "verbose" do
+    description "Turn on the verbose mode"
+  end
+  
+  optional_switch_flag "noinit" do
+    description "Do not initialize the Talia core"
+  end
+  
+  and_process!
+  
+  # Putting the flags into the environment, and remove them to avoid 
+  # having them interpreted by irb
+  flags.each do |flag, content|
+    my_content = content
+    my_content = "yes" if(content == true)
+    ENV[flag.to_s] = my_content
+    killed = ARGV.index("-#{flag}") # Delete the flag
+    if(killed)
+      ARGV.delete_at(killed + 1) if(content.is_a?(String)) # delete the parameter, if there is one
+      ARGV.delete_at(killed)
+    end
+  end
+  
+  # puts ENV.each { |k,v| puts "#{k} - #{v}"} if(flags[:verbose])
+end

data/lib/talia_cl/commands/talia_console/console_commands.rb

@@ -0,0 +1,37 @@
+# This adds the console commands for the talia console
+
+module TaliaCommandLine
+
+  # Array with command descriptions
+  @console_commands = Array.new
+
+  # Add a new console command
+  def self.console(command, &command_block)
+    # Add the description
+    description = @desc ? @desc : "Generic command: #{command}"
+    @desc = nil
+    @console_commands << [command.to_s, description]
+
+    command = command.to_sym
+
+    (class << MAIN_OBJECT; self; end).class_eval do
+      define_method(command, command_block)
+    end
+  end
+
+  # Add an instance variable
+  def self.to_var(name, value)
+    (class << MAIN_OBJECT; self; end).class_eval do
+      raise(RuntimeError, "Method already defined: #{name}") if(method_defined?(name)) 
+      define_method(name) { value }
+    end
+    value
+  end
+  
+  # Returns the defined console commands
+  def self.console_commands
+    @console_commands
+  end
+
+end
+

data/lib/talia_cl/commands/talia_console/talia_commands.rb

@@ -0,0 +1,131 @@
+# Create the commands for the Talia console
+require 'console_commands'
+
+module TaliaCommandLine
+  
+  desc "Show help on the talia console commands"
+  console(:thelp) do
+    puts "Talia console commands:\n\n"
+    TaliaCommandLine::console_commands.each do |command|
+      puts "#{command[0]}\t- #{command[1]}"
+    end
+   nil
+  end
+
+  desc "Get all sources"
+  console(:sources) do
+    TaliaCore::Source.find(:all)
+  end
+
+  desc "Find a source by local uri"
+  console(:tsrc) do |uri|
+    TaliaCore::Source.find(N::LOCAL + uri)
+  end
+
+  desc "Add a RDF source adapter. Result set to 'adapter'. Use: :type, option => ..."
+  console(:rdf_source) do |type, options|
+    options[:type] = type
+    to_var :adapter, ConnectionPool.add_data_source(options)
+  end
+
+  desc "Drop RDF data sources."
+  console(:rdf_down) do
+    ConnectionPool.clear
+  end
+
+  desc "Create a RDFS::Resource. Result set to 'res'"
+  console(:resource) do |uri|
+    to_var :res, RDFS::Resource.new(uri)
+  end
+
+  desc "Print the given element"
+  console(:tprint) do |element|
+    puts element.class
+    if(element.kind_of?(TaliaCore::Source))
+      puts "Source: #{element.uri}"
+      puts "Name:   #{element.name}m"
+      element.direct_predicates.each do |pred|
+        puts "#{pred.to_name_s}:"
+        pred.each { |val| puts val}
+      end
+    elsif(element.kind_of?(RDFS::Resource))
+      puts "RDFS::Resource #{element.uri}"
+      element.direct_predicates.each do |pred|
+        puts "#{pred.uri}:"
+        element[pred.uri].each { |val| puts "\t#{Uri.new(val).to_name_s}\n\n" }
+      end
+    elsif(element.kind_of?(String))
+      puts element
+    elsif(element.respond_to?("each"))
+      element.each { |el| puts el.to_s }
+    else
+      puts "Unknown type: #{element.class}"
+    end
+    nil
+  end
+
+  desc "Print the rdf types"
+  console(:put_types) do 
+    N::SourceClass.rdf_types.each do |type|
+      puts type.to_name_s
+    end
+    nil
+  end
+
+  desc "Import into the Talia store. Can be called with {rdf|data|yaml} as parameter"
+  console(:talia_import) do |type|
+    unless(type)
+      print "Import which type? (rdf|data|yaml) : "
+      type = readline
+    end
+    type = type.to_s.strip
+    print "Enter file pattern: "
+    filepattern = readline
+    case(type)
+    when "rdf":
+      print "Select data file format (ntriples|rdfxml): "
+      dataformat = readline
+      RdfImport::import(dataformat, FileList.new(filepattern))
+    when "yaml":
+      YamlImport::import_multi_files(FileList.new(filepattern))
+    when "data":
+      print "Select data type to import: "
+      datatype = readline
+      DataImport::import(FileList.new(filepattern), datatype)
+    end
+  end
+
+  desc "Quick query for sources. Use nil as a placeholder"
+  console(:tquery) do |subject, predicate, object|
+    variables = []
+    q_subject = if(subject)
+      RDFS::Resource.new(N::URI::make_uri(subject).to_s)
+    else
+      variables << :s
+      :s
+    end
+    q_predicate = if(predicate)
+      RDFS::Resource.new(N::URI::make_uri(predicate).to_s)
+    else
+      variables << :p
+      :p
+    end
+    q_object = if(object)
+      if(object.include?(":"))
+        RDFS::Resource.new(N::URI::make_uri(object).to_s)
+      else
+        object
+      end
+    else
+      variables << :o
+      :o
+    end
+    my_query = Query.new.select(*variables).distinct
+    my_query.where(q_subject, q_predicate, q_object)
+    puts "SPARQL: #{Query2SPARQL.translate(my_query)}"
+    puts ""
+    my_query.execute
+  end
+end
+
+

data/lib/talia_cl/commands/talia_console.rb

@@ -0,0 +1,47 @@
+# We just capture the main object for later reuse, as a workaround for adding
+# the command line commands to it.
+MAIN_OBJECT = self
+
+# Define the command for the Talia console
+module TaliaCommandLine
+ 
+  desc "Start the Talia console"
+  command(:console) do
+    # Loader file for the talia console
+    $: << File.join(File.expand_path(File.dirname(__FILE__)), "talia_console")
+    
+    # Console modules
+    require "talia_commands"
+    require "cl_options"
+
+    # Foreign modules
+    require "irb"
+    require "rake"
+
+    puts "\nEnter <thelp> for help on the Talia-specific commands."
+    puts ""
+
+    flags = TaliaCommands::flags
+
+    unless(flags.noinit?)
+      Util::init_talia
+      Util::talia_config if(flags.verbose?)
+    else
+      puts "Talia not initialized, as requested."
+    end
+    
+    IRB.start
+    
+#    if __FILE__ == $0
+#      IRB.start(__FILE__)
+#    else
+#      # check -e option
+#      if /^-e$/ =~ $0
+#        IRB.start(__FILE__)
+#      else
+#        IRB.setup(__FILE__)
+#      end
+#    end
+  end
+
+end

data/lib/talia_cl/core_commands.rb

@@ -0,0 +1,11 @@
+# 
+# Loads the commands that are defined for the talia core
+#
+
+command_dir = File.expand_path(File.join(File.dirname(__FILE__), 'commands'))
+
+$: << command_dir
+
+Dir["#{command_dir}/*.rb"].each do |file|
+  require File.basename(file.gsub(/\.rb$/, ''))
+end