talia_core 0.4.0

data/lib/talia_core/workflow.rb

@@ -0,0 +1,300 @@
+module TaliaCore                     #:nodoc:
+  module Workflow                  #:nodoc:
+    class InvalidState < Exception #:nodoc:
+    end
+    class NoInitialState < Exception #:nodoc:
+    end
+    class NoAuthorizedException < Exception #:nodoc:
+    end
+      
+      
+    def self.included(base)        #:nodoc:
+      base.extend WorkflowMacro
+    end
+      
+    module SupportingClasses
+      class State
+        attr_reader :name
+        
+        def initialize(name, opts)
+          @name, @opts = name, opts
+        end
+        
+        def entering(record)
+          enteract = @opts[:enter]
+          record.send(:run_transition_action, enteract) if enteract
+        end
+        
+        def entered(record)
+          afteractions = @opts[:after]
+          return unless afteractions
+          Array(afteractions).each do |afteract|
+            record.send(:run_transition_action, afteract)
+          end
+        end
+        
+        def exited(record)
+          exitact  = @opts[:exit]
+          record.send(:run_transition_action, exitact) if exitact
+        end
+      end
+
+      class StateTransition
+        attr_reader :from, :to, :opts
+          
+        def initialize(opts)
+          @from, @to, @guard = opts[:from], opts[:to], opts[:guard]
+          @opts = opts
+        end
+          
+        def guard(obj, args)
+          @guard ? obj.send(:run_transition_action, @guard, args) : true
+        end
+          
+        def on_transition(obj, args = nil)
+          action = @opts[:on_transition]
+          obj.send(:run_transition_action, action, args) if action
+        end
+        
+        def perform(record, args = nil)
+          return false unless guard(record, args)
+          loopback = record.current_state == to
+          states = record.class.read_inheritable_attribute(:states)
+          next_state = states[to]
+          old_state = states[record.current_state]
+          
+          # permform action
+          on_transition(record, args)
+            
+          next_state.entering(record) unless loopback
+          
+          record.update_attribute(record.class.state_column, to.to_s)
+          
+          next_state.entered(record) unless loopback
+          old_state.exited(record) unless loopback
+          true
+        end
+          
+        def ==(obj)
+          @from == obj.from && @to == obj.to
+        end
+      end
+        
+      class Event
+        attr_reader :name
+        attr_reader :transitions
+        attr_reader :opts
+
+        def initialize(name, opts, transition_table, &block)
+          @name = name.to_sym
+          @transitions = transition_table[@name] = []
+          instance_eval(&block) if block
+          @opts = opts
+          @opts.freeze
+          @transitions.freeze
+          freeze
+        end
+          
+        def next_states(record)
+          @transitions.select { |t| t.from == record.current_state }
+        end
+          
+        def fire(record, user, args = nil)
+          # check user role
+          unless @opts[:require_role].nil?
+            raise NoAuthorizedException unless user.authorized_as?(@opts[:require_role])
+          end
+            
+          # perform transition
+          next_states(record).each do |transition|
+            break true if transition.perform(record, args)
+          end
+        end
+          
+        def transitions(trans_opts)
+          Array(trans_opts[:from]).each do |s|
+            @transitions << SupportingClasses::StateTransition.new(trans_opts.merge({:from => s.to_sym}))
+          end
+        end
+      end
+    end
+      
+    module WorkflowMacro
+      # Configuration options are
+      #
+      # * +column+ - specifies the column name to use for keeping the state (default: state)
+      # * +property+ - specifies the column name to use for keeping the property of current state (default: state_properties)
+      # * +initial+ - specifies an initial state for newly created objects (required)
+      def workflow_machine(opts)
+        self.extend(ClassMethods)
+        raise NoInitialState unless opts[:initial]
+          
+        write_inheritable_attribute :states, {}
+        write_inheritable_attribute :initial_state, opts[:initial]
+        write_inheritable_attribute :initial_state_properties, opts[:initial_properties] || {}
+        write_inheritable_attribute :transition_table, {}
+        write_inheritable_attribute :event_table, {}
+        write_inheritable_attribute :state_column, opts[:column] || 'state'
+        write_inheritable_attribute :state_properties_column, opts[:properties] || 'state_properties'
+          
+        class_inheritable_reader    :initial_state
+        class_inheritable_reader    :initial_state_properties
+        class_inheritable_reader    :state_column
+        class_inheritable_reader    :state_properties_column
+        class_inheritable_reader    :transition_table
+        class_inheritable_reader    :event_table
+          
+        self.send(:include, TaliaCore::Workflow::InstanceMethods)
+
+        before_create               :set_initial_state, :set_initial_state_properties
+        after_create                :run_initial_state_actions
+      end
+    end
+      
+    module InstanceMethods
+      def state_properties
+        Marshal.load(self.send(self.class.state_properties_column))
+      end
+        
+      def state_properties=(value)
+        write_attribute self.class.state_properties_column, Marshal.dump(value)
+      end
+        
+      def set_initial_state #:nodoc:
+        write_attribute self.class.state_column, self.class.initial_state.to_s
+      end
+        
+      def set_initial_state_properties #:nodoc:
+        write_attribute self.class.state_properties_column, Marshal.dump(self.class.initial_state_properties)
+      end
+
+      def run_initial_state_actions
+        initial = self.class.read_inheritable_attribute(:states)[self.class.initial_state.to_sym]
+        initial.entering(self)
+        initial.entered(self)
+      end
+      
+      # Returns the current state the object is in, as a Ruby symbol.
+      def current_state
+        self.send(self.class.state_column).to_sym
+      end
+      
+      # Returns what the next state for a given event would be, as a Ruby symbol.
+      def next_state_for_event(event)
+        ns = next_states_for_event(event)
+        ns.empty? ? nil : ns.first.to
+      end
+
+      def next_states_for_event(event)
+        self.class.read_inheritable_attribute(:transition_table)[event.to_sym].select do |s|
+          s.from == current_state
+        end
+      end
+
+      def run_transition_action(action, args = nil)
+        Symbol === action ? self.method(action).call(args) : action.call(self)
+      end
+      private :run_transition_action
+    end
+
+    module ClassMethods
+      # Returns an array of all known states.
+      def states
+        read_inheritable_attribute(:states).keys
+      end
+        
+      # Define an event.  This takes a block which describes all valid transitions
+      # for this event.
+      #
+      # Example:
+      #
+      # class Order < ActiveRecord::Base
+      #   acts_as_state_machine :initial => :open
+      #
+      #   state :open
+      #   state :closed
+      #
+      #   event :close_order do
+      #     transitions :to => :closed, :from => :open
+      #   end
+      # end
+      #
+      # +transitions+ takes a hash where <tt>:to</tt> is the state to transition
+      # to and <tt>:from</tt> is a state (or Array of states) from which this
+      # event can be fired.
+      #
+      # This creates an instance method used for firing the event.  The method
+      # created is the name of the event followed by an exclamation point (!).
+      # Example: <tt>order.close_order!</tt>.
+      def event(event, opts={}, &block)
+        tt = read_inheritable_attribute(:transition_table)
+          
+        et = read_inheritable_attribute(:event_table)
+        e = et[event.to_sym] = SupportingClasses::Event.new(event, opts, tt, &block)
+        define_method("#{event.to_s}!") { |user, *args| e.fire(self, user, args) }
+      end
+        
+      # Define a state of the system. +state+ can take an optional Proc object
+      # which will be executed every time the system transitions into that
+      # state.  The proc will be passed the current object.
+      #
+      # Example:
+      #
+      # class Order < ActiveRecord::Base
+      #   acts_as_state_machine :initial => :open
+      #
+      #   state :open
+      #   state :closed, Proc.new { |o| Mailer.send_notice(o) }
+      # end
+      def state(name, opts={})
+        state = SupportingClasses::State.new(name.to_sym, opts)
+        read_inheritable_attribute(:states)[name.to_sym] = state
+        
+        define_method("#{state.name}?") { current_state == state.name }
+      end
+        
+      # Wraps ActiveRecord::Base.find to conveniently find all records in
+      # a given state.  Options:
+      #
+      # * +number+ - This is just :first or :all from ActiveRecord +find+
+      # * +state+ - The state to find
+      # * +args+ - The rest of the args are passed down to ActiveRecord +find+
+      def find_in_state(number, state, *args)
+        with_state_scope state do
+          find(number, *args)
+        end
+      end
+        
+      # Wraps ActiveRecord::Base.count to conveniently count all records in
+      # a given state.  Options:
+      #
+      # * +state+ - The state to find
+      # * +args+ - The rest of the args are passed down to ActiveRecord +find+
+      def count_in_state(state, *args)
+        with_state_scope state do
+          count(*args)
+        end
+      end
+        
+      # Wraps ActiveRecord::Base.calculate to conveniently calculate all records in
+      # a given state.  Options:
+      #
+      # * +state+ - The state to find
+      # * +args+ - The rest of the args are passed down to ActiveRecord +calculate+
+      def calculate_in_state(state, *args)
+        with_state_scope state do
+          calculate(*args)
+        end
+      end
+        
+      protected
+      def with_state_scope(state)
+        raise InvalidState unless states.include?(state)
+          
+        with_scope :find => {:conditions => ["#{table_name}.#{state_column} = ?", state.to_s]} do
+          yield if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/talia_core.rb

@@ -0,0 +1,9 @@
+# TaliaCore loader
+require File.dirname(__FILE__) + '/talia_dependencies'
+
+TLoad::force_rails_parts unless(defined?(ActiveRecord))
+
+# Load local things
+require 'talia_core/errors'
+require 'talia_core/rails_ext'
+require 'talia_core/initializer'

data/lib/talia_dependencies.rb

@@ -0,0 +1,12 @@
+# TaliaCore loader
+require File.dirname(__FILE__) + '/loader_helper'
+
+# This is also needed for local loading
+RAILS_GEM_VERSION = '2.3.4' unless defined? RAILS_GEM_VERSION
+
+# Stuff we may need to load from sources/uninstalled versions
+TLoad::require_module("assit", "assit", "/../../assit") unless(defined?(assit))
+TLoad::require_module("activerdf", "active_rdf", "/../../ActiveRDF")
+TLoad::require_module("semantic_naming", "semantic_naming", "/../../semantic_naming")
+
+require 'version'

data/lib/talia_util/bar_progressor.rb

@@ -0,0 +1,15 @@
+require File.join(File.dirname(__FILE__), 'progressbar')
+
+module TaliaUtil
+  
+  # Helper class for command-line progress bars as progressor objects
+  class BarProgressor
+    
+    def self.run_with_progress(message, size)
+      progress = ProgressBar.new(message, size)
+      yield(progress)
+      progress.finish
+    end
+    
+  end
+end

data/lib/talia_util/configuration/config_file.rb

@@ -0,0 +1,48 @@
+require 'yaml'
+
+module TaliaUtil
+  module Configuration
+    
+    # This is an object representation of a configuration file, the elements
+    # of the file can be directly accessed using dynamic getters/setters on the
+    # the class.
+    class ConfigFile
+      
+      # Initialize from the given template
+      def initialize(template)
+        @config_doc = YAML::load_file(template)
+      end
+      
+      # Write the configuration to the given file
+      def write(file)
+        open(file, 'w') { |io| io.puts(@config_doc.to_yaml) }
+      end
+      
+      def [](id)
+        @config_doc[id]
+      end
+      
+      # Automatically creates "accessors" for the config properties.
+      def method_missing(method, *params)
+        method = method.to_s
+        assign = method[-1..-1] == '=' # True if last char is a =
+        
+        result = nil
+        
+        if(assign)
+          return super if(params.size != 1)
+          result = @config_doc[method[0..-2]] = params[0]
+        else
+          return super if(params.size != 0)
+          result = @config_doc[method]
+        end
+        
+        result
+      end
+      
+      
+      
+    end
+    
+  end
+end

data/lib/talia_util/configuration/database_config.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/config_file'
+
+module TaliaUtil
+  module Configuration
+    
+    # This contains some special methods for database config files
+    class DatabaseConfig < ConfigFile
+      
+      def initialize(template)
+        @environments = ['test', 'development', 'production']
+        super
+      end
+      
+      # Set the credentials for all environments
+      def set_credentials(db_user, db_pass)
+        @environments.each do |env| 
+          @config_doc[env]['username'] = db_user
+          @config_doc[env]['password'] = db_pass
+        end
+      end
+      
+      # Sets the database adapter for all environments
+      def set_adapter(db_adapter)
+        @environments.each { |env| @config_doc[env]['adapter'] = db_adapter }
+      end
+      
+      # Sets the database names based on the given application name
+      def set_database_names(app_name)
+        @environments.each { |env| @config_doc[env]['database'] = "#{app_name}_#{env}" }
+      end
+      
+      # Sets the socket file for the db
+      def set_socket(socket)
+        @environments.each { |env| @config_doc[env]['socket'] = socket  }
+      end
+      
+    end
+    
+  end
+end

data/lib/talia_util/configuration/mysql_database_setup.rb

@@ -0,0 +1,104 @@
+require 'active_record'
+
+module TaliaUtil
+  module Configuration
+    
+    # This contains some methods to set mysql databases on a production system
+    # from scratch. Setting the root password will apply immediately, the SQL
+    # operations will be cached and applied in one go.
+    class MysqlDatabaseSetup
+     
+      def initialize
+        @sql_statements = []
+      end
+      
+      attr_accessor :host
+      attr_accessor :app_name
+      attr_accessor :sock
+      attr_accessor :db_prefix # Prefix for having multiple databases on one install
+      
+      # Set the root user/pw
+      def root_credentials(root_user = 'root', root_pw = nil)
+        @root_user = root_user
+        @root_pw = root_pw
+      end
+      
+      # Set the normal user/pw
+      def rails_credentials(rails_user, rails_pw)
+        @rails_user = rails_user
+        @rails_pw = rails_pw
+      end
+      
+      
+      # Assign a new root password
+      def assign_root_pw(new_root_pw)
+        success = mysqladmin("password #{new_root_pw}")
+        @root_pw = new_root_pw if(success)
+        success
+      end
+      
+      # Create the given database and set the permssions on it
+      def create_database(database)
+        raise(ArgumentError, "Credentials incomplete") unless(@rails_user && @rails_pw)
+        @sql_statements << "CREATE DATABASE #{database};"
+        @sql_statements << "GRANT ALL ON #{database}.* TO '#{@rails_user}'@'#{@host || 'localhost'}' IDENTIFIED BY '#{@rails_pw}'"
+      end
+      
+      # Creates the default databases for the application. You can call back a
+      # block for each db to do something depending on the success of the
+      # operation
+      def create_default_databases
+        raise(ArgumentError, "App name not set") unless(@app_name)
+        %w(production test development).each do |db_suffix|
+          db_name = "#{db_prefix}#{@app_name}_#{db_suffix}"
+          create_database(db_name)
+        end
+      end
+      
+      # Executes all stored statements
+      def execute
+        execute_as_root do |connection|
+          connection.transaction do
+            @sql_statements.each do |statement|
+                connection.execute(statement)
+            end
+          end
+        end
+      end
+      
+      private
+      
+      # Call the mysqladmin command (as root)
+      def mysqladmin(command)
+        if(@root_pw)
+          system("mysqladmin -u #{@root_user} #{command}")
+        else
+          system("mysqladmin -u #{@root_user} -p#{@root_pw} #{command}")
+        end
+      end
+      
+      # Calls sql commands on the database using root credentials. The open
+      # database (ActiveRecord) connection will be passed. This will open
+      # the given database.
+      def execute_as_root(database = nil)
+        ActiveRecord::Base.establish_connection(root_con_opts(database))
+        yield(ActiveRecord::Base.connection)
+        ActiveRecord::Base.remove_connection
+      end
+      
+      # options for root connection
+      def root_con_opts(database)
+        {
+          :adapter => "mysql",
+          :host => @host || "localhost",
+          :username => @root_user,
+          :password => @root_pw,
+          :database => database,
+          :socket => @sock || '/tmp/mysql.sock'
+        }
+      end
+      
+    end
+    
+  end
+end

data/lib/talia_util/data_import.rb

@@ -0,0 +1,91 @@
+require 'fileutils'
+
+module TaliaUtil
+  
+  # Import data files into the Talia store. This can be used to bootstrap
+  # simple installations
+  class DataImport
+    
+    class << self
+  
+      # Import files with the given type. This is a simple import feature,
+      # it's assumed that the file (without extension is named like the
+      # Source it should be assigned to.
+      def import(files, type)
+    
+        # First get the class for the data type and the directory
+        data_klass = get_data_class(type)
+        replace = ENV['replace_files'] && (ENV['replace_files'] == "yes")
+    
+        progress = ProgressBar.new("Importing #{data_klass}", files.size)
+        not_found = []
+        created = 0
+    
+        files.each do |file|
+          # Get the basename without extension and additions. This strips off
+          # everything after the first point or - character. Examples:
+          # book.html
+          # book-picture.jpg
+          # => Will all be assigned to "book"
+          name = File.basename(file).gsub(/[-|\.].+$/, '')
+          if(TaliaCore::Source.exists?(name))
+            src = TaliaCore::Source.find(name)
+        
+            # Get the filename with extension
+            file_name = File.basename(file)
+            
+            # Create the record if necessary
+            unless(data = src.data_records.find_by_location(file_name))
+              data = data_klass.new
+              File.open(file) do |io|
+                data.create_from_data(file_name, io)
+              end
+              src.data_records << data
+              src.save!
+              data.save!
+              created += 1
+            end
+          else
+            not_found << file
+          end
+          progress.inc
+        end
+    
+        progress.finish
+        puts "Done, #{not_found.size} of #{files.size} files had no record associated."
+        puts "#{created} new records created."
+        puts "\nNot found:" unless(not_found.size == 0)
+        not_found.each { |file| puts file}
+      end
+  
+  
+      # Get the data class for the type. That does some sanity checks 
+      def get_data_class(type)
+        data_klass = nil
+        begin
+          data_klass = TaliaCore::DataTypes.const_get(type)
+        rescue Exception => e
+          puts("Could get the data type #{type}: #{e}")
+          Util.print_options
+          exit(1)
+        end
+    
+        # Do the basic check
+        unless(data_klass && data_klass.kind_of?(Class) && data_klass.method_defined?('data_directory'))
+          puts("Cannot create data class from #{type}")
+          exit(1)
+        end
+    
+        # Now check if we are a subclass of the data class
+        my_instance = data_klass.new
+    
+        unless(my_instance.kind_of?(TaliaCore::DataTypes::DataRecord))
+          puts("The class #{data_klass} is not a DataRecord, can't create data for it.")
+          exit(1)
+        end
+    
+        data_klass
+      end
+    end
+  end
+end