talia_core 0.4.2 → 0.4.3

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

@@ -1,75 +0,0 @@
-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

@@ -1,25 +0,0 @@
-# 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

@@ -1,55 +0,0 @@
-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

@@ -1,37 +0,0 @@
-# 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

@@ -1,131 +0,0 @@
-# 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

@@ -1,47 +0,0 @@
-# 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

@@ -1,11 +0,0 @@
-# 
-# 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

data/lib/talia_cl.rb

@@ -1,47 +0,0 @@
-# This is the loader file for the Talia command line tool.
-# 
-# The Talia command line works as follows: This file will load some helper
-# methods that can be used to register subcommands for the command line tool.
-#
-# Each subcommand is registered with a name (as symbol), a description string
-# and a block that will be run if the command is selected.
-#
-# If the command line processing is started, the first command line argument 
-# will be taken as the name of the command to be run. The argument will be
-# removed from ARGV, and then the block belonging to the command will be 
-# executed.
-$: << File.join(File.expand_path(File.dirname(__FILE__)), "talia_cl")
-
-# require basic stuff
-require "talia_core"
-require "talia_util"
-
-include TaliaUtil
-
-require 'command_line'
-require 'core_commands'
-
-# Quick and dirty: Try to load the (Rails) add-on commands. If not found, ignore.
-begin
-  require 'addon_commands'
-  puts "Additional talia commands loaded"
-rescue LoadError
-  puts "No additional talia commands found or loaded."
-end
-
-
-# Runs the command line
-def run_command_line
-  Util::title
-  
-  command = ARGV.shift
-  
-  if(TaliaCommandLine::command?(command))
-    TaliaCommandLine::run_command(command)
-  else
-    puts "Use talia <command> - possible commands:"
-    TaliaCommandLine::each do |command, description| 
-      puts "#{command}\t- #{description}"
-    end
-  end
-end

data/lib/user.rb

@@ -1,116 +0,0 @@
-require 'digest/sha1'
-class User < ActiveRecord::Base
-  include ActsAsRoled
-  has_and_belongs_to_many :roles
-  attr_accessor :roles_attributes
-  attr_accessible :roles_attributes
-  after_update :save_roles
-
-  # authorized_as? simply needs to return true or false whether a user has a role or not.  
-  # It may be a good idea to have "admin" roles return true always
-  def authorized_as?(role_name)
-    return true if role_names.include?("admin")
-    has_role?(role_name)
-  end
-
-  def has_role?(role_name)
-    role_names.include? role_name.to_s
-  end
-
-  def roles_to_sentence
-    role_names.to_sentence
-  end
-
-  # Virtual attribute for the unencrypted password
-  attr_accessor :password
-
-  validates_presence_of     :login, :email
-  validates_presence_of     :password,                   :if => :password_required?
-  validates_presence_of     :password_confirmation,      :if => :password_required?
-  validates_length_of       :password, :within => 4..40, :if => :password_required?
-  validates_confirmation_of :password,                   :if => :password_required?
-  validates_length_of       :login,    :within => 3..40
-  validates_length_of       :email,    :within => 3..100
-  validates_uniqueness_of   :login, :email, :case_sensitive => false
-  before_save :encrypt_password, :normalize_open_id
-  
-  # prevents a user from submitting a crafted form that bypasses activation
-  # anything else you want your user to change should be added here.
-  attr_accessible :login, :email, :password, :password_confirmation, :open_id
-
-  # Authenticates a user by their login name and unencrypted password.  Returns the user or nil.
-  def self.authenticate(login, password)
-    u = find_by_login(login) # need to get the salt
-    u && u.authenticated?(password) ? u : nil
-  end
-  
-  # Authenticates a user by their open id indentifier.  Returns the user or nil.
-  def self.open_id_authentication(identity_url)
-    u = find_by_open_id(identity_url) # need to get the salt
-    u ? u : nil
-  end
-
-  # Encrypts some data with the salt.
-  def self.encrypt(password, salt)
-    Digest::SHA1.hexdigest("--#{salt}--#{password}--")
-  end
-
-  # Encrypts the password with the user salt
-  def encrypt(password)
-    self.class.encrypt(password, salt)
-  end
-
-  def authenticated?(password)
-    crypted_password == encrypt(password)
-  end
-
-  def remember_token?
-    remember_token_expires_at && Time.now.utc < remember_token_expires_at 
-  end
-
-  # These create and unset the fields required for remembering users between browser closes
-  def remember_me
-    remember_me_for 2.weeks
-  end
-
-  def remember_me_for(time)
-    remember_me_until time.from_now.utc
-  end
-
-  def remember_me_until(time)
-    self.remember_token_expires_at = time
-    self.remember_token            = encrypt("#{email}--#{remember_token_expires_at}")
-    save(false)
-  end
-
-  def forget_me
-    self.remember_token_expires_at = nil
-    self.remember_token            = nil
-    save(false)
-  end
-
-  protected
-  # before filter 
-  def encrypt_password
-    return if password.blank?
-    self.salt = Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{login}--") if new_record?
-    self.crypted_password = encrypt(password)
-  end
-
-  def normalize_open_id
-    self.open_id = OpenIdAuthentication.normalize_url(open_id) unless open_id.blank?
-  end
-
-  def password_required?
-    crypted_password.blank? || !password.blank?
-  end
-    
-  def role_names
-    @role_names ||= self.roles.map(&:name)
-  end
-    
-  def save_roles
-    return if roles_attributes.nil?
-    self.roles = Role.find_by_names(roles_attributes)
-  end
-end