talia_core 0.4.0

data/lib/talia_core/data_types/path_helpers.rb

@@ -0,0 +1,77 @@
+module TaliaCore
+  module DataTypes
+  
+    # Contains the helpers to obtain path information for data storage
+    module PathHelpers
+      
+      module ClassMethods
+        # Path used to store temporary files.
+        def tempfile_path
+          @@tempfile_path ||= File.join(TALIA_ROOT, 'tmp', 'data_records')
+        end
+
+        # Path used to store data files.
+        def data_path
+          @@data_path ||= File.join(TALIA_ROOT, 'data')
+        end
+        
+      
+            
+        # Extract the filename.
+        def extract_filename(file_data)
+          file_data.original_filename if file_data.respond_to?(:original_filename)
+        end
+      
+      end      
+      
+      # Return the full file path related to the data directory
+      def file_path(relative = false)
+        File.join(data_directory(relative), self.id.to_s)
+      end
+      
+      # Gets the path that will be used for serving the image as a static
+      # resource. Nil if the prefix isn't set
+      def static_path
+        prefix = TaliaCore::CONFIG['static_data_prefix']
+        return unless(prefix)
+        prefix = N::LOCAL + prefix unless(prefix =~ /:\/\//)
+        "#{prefix}/#{class_name}/#{("00" + self.id.to_s)[-3..-1]}/#{self.id}"
+      end
+      
+      # Path used to store temporary files.
+      # This is a wrapper for the tempfile_path class method.
+      def tempfile_path
+        self.class.tempfile_path
+      end
+    
+      # Return the data directory for a specific data file
+      def data_directory(relative = false)
+        class_name = self.class.name.gsub(/(.*::)/, '')
+        if relative == false
+          File.join(TaliaCore::CONFIG["data_directory_location"], class_name, ("00" + self.id.to_s)[-3..-1])
+        else
+          File.join(class_name, ("00" + self.id.to_s)[-3..-1])
+        end
+      end
+    
+      # Path used to store data files.
+      # This is a wrapper for the data_path class method.
+      def data_path
+        self.class.data_path
+      end
+      
+      # Return the full path of the current attachment.
+      def full_filename
+        @full_filename ||= self.file_path #File.join(data_path, class_name, location)
+      end
+      
+      # Extract the filename.
+      # This is a wrapper for the extract_filename class method.
+      def extract_filename(file_data)
+        self.class.extract_filename(file_data)
+      end
+      
+    end
+  
+  end
+end

data/lib/talia_core/data_types/pdf_data.rb

@@ -0,0 +1,42 @@
+module TaliaCore
+  module DataTypes
+
+    # Class to manage PDF data type
+    class PdfData < FileRecord
+     
+      # return the mime_type for a file
+      def extract_mime_type(location)
+        'application/pdf'
+      end
+
+      # Create the PDF data from a PDF writer. This method needs a block
+      # which will be called with the writer object
+      def create_from_writer(writer_opts = {})
+        activate_pdf
+        writer = PDF::Writer.new(writer_opts) do |pdf|
+          yield(pdf)
+        end
+        filename = File.join(Dir.tmpdir, "#{rand 10E16}.pdf")
+        writer.save_as(filename)
+        self.create_from_file('', filename, true) # set to delete tempfile on create
+        self
+      end
+
+      private
+
+      # Little helper method - no need to load the pdf classes unless needed,
+      # but if called every time round it will slow things down (in Rails it will).
+      def self.activate_pdf
+        return if(@pdf_active)
+        require 'pdf/writer'
+        @pdf_active = true
+      end
+
+      def activate_pdf
+        self.class.activate_pdf
+      end
+
+    end
+    
+  end
+end

data/lib/talia_core/data_types/simple_text.rb

@@ -0,0 +1,36 @@
+require 'talia_core/data_types/file_store'
+
+# Class to manage data stored in a text file
+module TaliaCore
+  module DataTypes
+  
+    class SimpleText < FileRecord
+      
+      # return the mime_type for a file
+      def extract_mime_type(location)
+        'text/plain'
+      end
+
+      # Get a line from a text file.
+      # At the end of file: close the file and return
+      def get_line(close_after_single_read=false)
+        if !is_file_open?
+          open_file
+        end
+      
+        # get a new line and return nil is EOF
+        line = @file_handle.gets
+      
+        if line == nil or close_after_single_read
+          close_file
+        end
+      
+        # update the position of reading cursors
+        @position += line.length
+      
+        return line
+      end
+      
+    end
+  end
+end

data/lib/talia_core/data_types/temp_file_handling.rb

@@ -0,0 +1,85 @@
+require 'fileutils'
+
+module TaliaCore
+  module DataTypes
+    
+    # Module for the handling of temporary files in data storage objects
+    module TempFileHandling
+      
+      module ClassMethods
+        
+        # Copies the given file path to a new tempfile, returning the closed tempfile.
+        def copy_to_temp_file(file, temp_base_name)
+          create_tempfile_path
+          returning Tempfile.new(temp_base_name, self.tempfile_path) do |tmp|
+            tmp.close
+            FileUtils.cp file, tmp.path
+          end
+        end
+
+        # Writes the given data to a new tempfile, returning the closed tempfile.
+        def write_to_temp_file(data, filename)
+          create_tempfile_path
+          returning Tempfile.new(filename, self.tempfile_path) do |tmp|
+            tmp.binmode
+            tmp.write data
+            tmp.close
+          end
+        end
+        
+        def create_tempfile_path
+          FileUtils.mkdir_p(tempfile_path) unless File.exists?(tempfile_path)
+        end
+      
+      end
+      
+      # Gets the latest temp path from the collection of temp paths.  While working with an attachment,
+      # multiple Tempfile objects may be created for various processing purposes (resizing, for example).
+      # An array of all the tempfile objects is stored so that the Tempfile instance is held on to until
+      # it's not needed anymore.  The collection is cleared after saving the attachment.
+      def temp_path
+        p = temp_paths.first
+        p.respond_to?(:path) ? p.path : p.to_s
+      end
+    
+      # Gets an array of the currently used temp paths.  Defaults to a copy of #full_filename.
+      def temp_paths
+        @temp_paths ||= (new_record? || !File.exist?(full_filename)) ? [] : [copy_to_temp_file(full_filename)]
+      end
+    
+      # Adds a new temp_path to the array.  This should take a string or a Tempfile.  This class makes no 
+      # attempt to remove the files, so Tempfiles should be used.  Tempfiles remove themselves when they go out of scope.
+      # You can also use string paths for temporary files, such as those used for uploaded files in a web server.
+      def temp_path=(value)
+        temp_paths.unshift value
+        temp_path
+      end
+
+      # Gets the data from the latest temp file.  This will read the file into memory.
+      def temp_data
+        save_attachment? ? File.read(temp_path) : nil
+      end
+    
+      # Writes the given data to a Tempfile and adds it to the collection of temp files.
+      def temp_data=(data)
+        self.temp_path = write_to_temp_file data unless data.nil?
+      end
+      
+      # Copies the given file to a randomly named Tempfile.
+      def copy_to_temp_file(file)
+        self.class.copy_to_temp_file file, random_tempfile_filename
+      end
+    
+      # Writes the given file to a randomly named Tempfile.
+      def write_to_temp_file(data)
+        self.class.write_to_temp_file data, self.location
+      end
+      
+      # Generates a unique filename for a Tempfile. 
+      def random_tempfile_filename
+        "#{rand Time.now.to_i}#{location || 'attachment'}"
+      end
+      
+    end
+  end
+end

data/lib/talia_core/data_types/xml_data.rb

@@ -0,0 +1,169 @@
+require 'talia_core/data_types/file_store'
+require 'rexml/document'
+# require 'xml/xslt'
+
+begin
+  # if tidy is not present, disable it
+  require 'tidy'
+  
+  # Tidy_enable constant is not defined?
+  if ((defined? Tidy_enable) == nil)
+    if ENV['TIDYLIB'].nil?
+      # disable tidy
+      Tidy_enable = false
+    else
+      # set path and enable tidy
+      Tidy.path = ENV['TIDYLIB']
+      Tidy_enable = true
+    end
+  end
+
+rescue LoadError
+  # disable tidy
+  Tidy_enable = false if ((defined? Tidy_enable) == nil)
+end
+      
+
+module TaliaCore
+  module DataTypes
+  
+    # Class to manage XML and HTML data type
+    class XmlData < FileRecord
+      
+      # return the mime_type for a file
+      def extract_mime_type(location)
+        case File.extname(location).downcase
+        when '.htm', '.html','.xhtml'
+          'text/html'
+        when '.hnml'
+          'text/hnml'
+        when '.xml'
+          'text/xml'
+        end
+      end
+      
+      # return the mime subtype for this specified class
+      def mime_subtype
+        mime_type.split(/\//)[1]
+      end    
+
+      # return contect of the object as REXML::Elements
+      # * options: Options for getting context. Default nil.
+      # * options[:xsl_file]: xsl file path for transformation.
+      def get_content(options = nil)
+        text_to_parse = all_text
+      
+        if (!options.nil?)
+          # if xsl_file option is specified, execute transformation
+          if (!options[:xsl_file].nil?)
+            text_to_parse = xslt_transform(file_path, options[:xsl_file])
+          end
+        end
+      
+        # create document object
+        document = REXML::Document.new text_to_parse
+      
+        # get content
+        if ((mime_subtype == "html") or 
+              ((mime_subtype == "xml") and (!options.nil?) and (!options[:xsl_file].nil?)))
+          content = document.elements['//body'].elements
+        elsif ((mime_subtype == "xml") or (mime_subtype == "hnml"))
+          content = document.root.elements
+        end
+      
+        # adjust/replace items path
+        content.each { |i| wrapItem i }
+      
+        # return content
+        return content
+      end
+    
+      # Returns an xml string of the elements returned by get_content
+      def get_content_string(options = nil)
+        xml_str = ''
+        get_content(options).each do |element|
+          xml_str << element.to_s
+        end
+        xml_str
+      end
+    
+      # Returns an xml string that is escaped for HTML inclusing
+      def get_escaped_content_string(options = nil)
+        get_content_string(options).gsub(/</, "&lt;").gsub(/>/, "&gt;")
+      end
+    
+      # Add data as string into file
+      # * location: location
+      # * data: data to write
+      # * options: options
+      # * options[:tidy]: enable or disable tidy (convert html into xhtml). Default value is true
+      def create_from_data(location, data, options = {:tidy => true})
+        # check tidy option
+        if (((options[:tidy] == true) and (Tidy_enable == true)) and 
+              ((File.extname(location) == '.htm') or (File.extname(location) == '.html') or (File.extname(location) == '.xhtml')))        
+        
+          # apply tidy on data
+          data_to_write = Tidy.open(:show_warnings => false) do |tidy|
+            tidy.options.output_xhtml = true
+            tidy.options.tidy_mark = false
+            xhtml = tidy.clean(data)
+            xhtml
+          end
+        else
+          data_to_write = data
+        end
+      
+        # write data
+        super(location, data_to_write, options)
+      end
+    
+      private
+      # adjusted/replaced items path
+      # * item: REXML::Element to parse
+      def wrapItem item
+        if item.class == REXML::Element
+          # recursive execution
+          item.each_child { |subItem| wrapItem subItem}
+    
+          case item.name
+          when "img"
+            if item.attributes.include? "src"
+              # get path
+              path = Pathname.new(item.attributes['src']).split
+              # adjust src attribute
+              item.attributes['src'] = "/source_data/image_data/#{path[1].to_s}" if path[0].relative?
+            end
+          when "a"
+            if item.attributes.include? "href"
+              # get path
+              path = Pathname.new(item.attributes['href']).split
+              # adjust href attribute
+              case File.extname(path[1].to_s)
+              when ".txt"
+                item.attributes['href'] = "/source_data/simple_text/#{path[1].to_s}" if path[0].relative?
+              when '.htm', '.html','.xhtml','.hnml','.xml'
+                item.attributes['href'] = "/source_data/xml_data/#{path[1].to_s}" if path[0].relative?
+              end
+            end
+          end
+       
+        end
+      end
+    
+      # execute xslt transformation
+      # * document: xml document. Can be file path as string or REXML::Document
+      # * xsl_file: xsl file for transformation. Can be file path as string or REXML::Document
+      def xslt_transform(document, xsl_file)
+        xslt = XML::XSLT.new()
+        # get xml document
+        xslt.xml = document
+        # get xslt document
+        xslt.xsl = xsl_file
+
+        # return transformation output
+        return xslt.serve()      
+      end
+    
+    end
+  end
+end

data/lib/talia_core/dc_resource.rb

@@ -0,0 +1,20 @@
+module TaliaCore
+  
+  # A generic resource that should contain the most important 
+  # Dublin Core metadata fields
+  class DcResource < Source
+    
+    # General metadata
+    singular_property :identifier, N::DCNS.identifier
+    simple_property :creators, N::DCNS.creator
+    singular_property :date, N::DCNS.date
+    singular_property :description, N::DCNS.description
+    simple_property :publishers, N::DCNS.publisher
+    singular_property :language, N::DCNS.language
+    simple_property :subjects, N::DCNS.subject
+    singular_property :rights, N::DCNS.rights
+    singular_property :title, N::DCNS.title
+    
+  end
+  
+end

data/lib/talia_core/dummy_handler.rb

@@ -0,0 +1,34 @@
+require 'active_rdf'
+require 'semantic_naming'
+require 'assit'
+require 'errors'
+
+module TaliaCore
+  
+  # This is an internal class for "dummy handler invocations" on sources
+  # The problem is that invocations like source.namespace::name are
+  # evaluated to (source.namespace).name 
+  # This means that source.namespace must return an object on which
+  # "name" can be called with the desired effect. This is the "dummy handler"
+  class DummyHandler
+    
+    # Create the new handler
+    def initialize(namespace, subject)
+      assit_kind_of(N::URI, namespace)
+      assit_kind_of(TaliaCore::Source, subject)
+      
+      @namespace = namespace.to_s
+      @subject = subject
+    end
+    
+    # Catch the invocations
+    def method_missing(method, *args)
+      # read value
+      raise(SemanticNamingError, "Wrong number of arguments") if(args.size != 0)
+      @subject[@namespace + method.to_s]
+    end
+    
+    # remove the type call
+    private :type
+  end
+end

data/lib/talia_core/dummy_source.rb

@@ -0,0 +1,20 @@
+module TaliaCore
+
+  # Dummy source class. This will be created by some mechanisms that need to create a relation to a 
+  # not-yet-existing source. The DummySource should only exist temporarily, if some are found inside
+  # the data store it may be a sign of an inconsistent or not completely initialized store.
+  class DummySource < Source
+
+    # Converts the current source into one with a "real" klass. Returns the new, converted sourc
+    def self.make_real(klass)
+      assit_kind_of(Class, klass)
+      self['type'] = klass.name
+      save!
+      new_src = ActiveSource.find(uri)
+      assit_kind_of(klass, new_src)
+      new_src
+    end
+
+  end
+
+end

data/lib/talia_core/errors.rb

@@ -0,0 +1,25 @@
+# This file contains all the errors that can be raised in the 
+# Talia core. Since these are not useful classes, they are grouped
+# together in one file.
+  
+# Indicates that it was tried to create an object with
+# an identifier (e.g. an URI) which already exists in the
+# system.
+class DuplicateIdentifierError < RuntimeError
+end
+
+# Indicates an error during initialization
+class SystemInitializationError < RuntimeError
+end
+
+# Indicates an error with the predicate naming
+class SemanticNamingError < RuntimeError
+end
+
+# Indicates an attempt to save attributes on an unsaved source
+class UnsavedSourceError < RuntimeError 
+end
+
+# Indicates an error in a query
+class QueryError < RuntimeError
+end