ruby-xes 0.1.0

data/lib/xes/classifier.rb

@@ -0,0 +1,63 @@
+module XES
+  # Classifier represents "classifier" element of XES.
+  class Classifier
+    # @return [String]
+    #   classifier name
+    attr_reader :name
+
+    # @return [String]
+    #   classifier keys
+    attr_reader :keys
+
+    # Create a XES classifier element.
+    #
+    # @param name [String]
+    #   classifier name
+    # @param keys [String]
+    #   classifier keys
+    def initialize(name, keys)
+      @name = name
+      @keys = keys
+    end
+
+    # Return true if the element is formattable.
+    #
+    # @return [Boolean]
+    #   true if the element is formattable
+    def formattable?
+      not(@name.nil? or @keys.nil?)
+    end
+
+    # Format as a XML element.
+    #
+    # @return [REXML::Element]
+    #   XML element
+    def format
+      raise FormatError.new(self) unless formattable?
+
+      REXML::Element.new("classifier").tap do |ext|
+        ext.attributes["name"] = @name
+        ext.attributes["keys"] = @keys
+      end
+    end
+
+    # @api private
+    def ==(other)
+      return false unless other.kind_of?(self.class)
+      @name == other.name and @keys == other.keys
+    end
+    alias :eql? :"=="
+
+    # @api private
+    def hash
+      @name.hash + @keys.hash
+    end
+  end
+
+  # known XES classifier elements
+  CLASSIFIER = {
+    :mxml_legacy_classifier => Classifier.new("MXML Legacy Classifier", "concept:name lifecycle:transition"),
+    :event_name => Classifier.new("Event Name", "concept:name"),
+    :resource => Classifier.new("Resource", "org:resource")
+  }
+end

data/lib/xes/document.rb

@@ -0,0 +1,48 @@
+module XES
+  # Document is a class for XES event log doucment.
+  class Document
+    # @return [Log]
+    #   log element
+    attr_accessor :log
+
+    # @param log [Log]
+    def initialize(log=nil)
+      @log = log
+    end
+
+    # Return true if the document is formattable.
+    #
+    # @return [Boolean]
+    #   true if the element is formattable
+    def formattable?
+      not(@log.nil?) and @log.formattable?
+    end
+
+    # Format as a XML document.
+    #
+    # @return [REXML::Document]
+    #   XML document
+    # @raise FormatError
+    #   format error when the document is not formattable
+    def format
+      raise FormatError.new(self) unless formattable?
+
+      REXML::Document.new.tap do |doc|
+        doc << REXML::XMLDecl.new
+        doc.elements << @log.format
+      end
+    end
+
+    # @api private
+    def ==(other)
+      return false unless other.kind_of?(self.class)
+      @log == other.log
+    end
+    alias :eql? :"=="
+
+    # @api private
+    def hash
+      @attributes.hash + @events.hash
+    end
+  end
+end

data/lib/xes/event.rb

@@ -0,0 +1,50 @@
+module XES
+  # XESEvent represents "event" element of XES.
+  class Event
+    include EventAttributeAccessor
+
+    # @return [Array<Attribute>]
+    #   event attributes
+    attr_accessor :attributes
+
+    # Create a XES event.
+    #
+    # @param attributes [Array<Attribute>]
+    #   attributes of the event
+    def initialize(attributes=[])
+      @attributes = attributes
+    end
+
+    # Return true if the element is formattable.
+    #
+    # @return [Boolean]
+    #   true if the element is formattable
+    def formattable?
+      not(@attributes.empty?)
+    end
+
+    # Format as a XML element.
+    #
+    # @return [REXML::Element]
+    #   XML element
+    def format
+      REXML::Element.new("event").tap do |event|
+        @attributes.each do |attribute|
+          event.elements << attribute.format if attribute.formattable?
+        end
+      end
+    end
+
+    # @api private
+    def ==(other)
+      return false unless other.kind_of?(self.class)
+      @attributes == other.attributes
+    end
+    alias :eql? :"=="
+
+    # @api private
+    def hash
+      @attributes.hash
+    end
+  end
+end

data/lib/xes/extension.rb

@@ -0,0 +1,73 @@
+module XES
+  # Extension represents "extension" element of XES.
+  class Extension
+    # @return [String]
+    #   extension name
+    attr_reader :name
+
+    # @return [String]
+    #   extension prefix
+    attr_reader :prefix
+
+    # @return [String]
+    #   extension URI
+    attr_reader :uri
+
+    # Create a XES extension element.
+    #
+    # @param name [String]
+    #   extension name
+    # @param prefix [String]
+    #   extension prefix
+    # @param uri [String]
+    #   extension definition URI
+    def initialize(name, prefix, uri)
+      @name = name
+      @prefix = prefix
+      @uri = uri
+    end
+
+    # Return true if the element is formattable.
+    #
+    # @return [Boolean]
+    #   true if the element is formattable
+    def formattable?
+      not(@name.nil? or @prefix.nil? or @uri.nil?)
+    end
+
+    # Format as a XML element.
+    #
+    # @return [REXML::Element]
+    #   XML element
+    def format
+      raise FormatError.new(self) unless formattable?
+
+      REXML::Element.new("extension").tap do |ext|
+        ext.attributes["name"] = @name
+        ext.attributes["prefix"] = @prefix
+        ext.attributes["uri"] = @uri
+      end
+    end
+
+    # @api private
+    def ==(other)
+      return false unless other.kind_of?(self.class)
+      @name == other.name and @prefix == other.prefix and @uri == other.uri
+    end
+    alias :eql? :"=="
+
+    # @api private
+    def hash
+      @name.hash + @prefix.hash + @uri.hash
+    end
+  end
+
+  # known XES extension elements
+  EXTENSION = {
+    :concept => Extension.new("Concept", "concept", "http://www.xes-standard.org/concept.xesext"),
+    :identity => Extension.new("Identity", "identity", "http://www.xes-standard.org/identity.xesext"),
+    :time => Extension.new("Time", "time", "http://www.xes-standard.org/time.xesext"),
+    :lifecycle => Extension.new("Lifecycle", "lifecycle", "http://www.xes-standard.org/lifecycle.xesext"),
+    :organizational => Extension.new("Organizational", "org", "http://www.xes-standard.org/org.xesext")
+  }
+end

data/lib/xes/format-error.rb

@@ -0,0 +1,15 @@
+module XES
+  # FormatError is raised when you failed to format XES element.
+  class FormatError < StandardError
+    # @param element [Object]
+    #   object that caused to raise this exception
+    def initialize(element)
+      @element = element
+    end
+
+    # @api private
+    def message
+      "Error happened on formatting %s" % @element.inspect
+    end
+  end
+end

data/lib/xes/global.rb

@@ -0,0 +1,75 @@
+module XES
+  # Global represents "global" element of XES.
+  class Global
+    class << self
+      # Create an event global. The object extended by EventAttributeAccessor.
+      #
+      # @param attributes [Array<Attribute>]
+      #   event global attributes
+      def event(attributes=[])
+        new("event", attributes).tap do |global|
+          global.extend EventAttributeAccessor
+        end
+      end
+
+      # Create a trace global. The object extended by TraceAttributeAccessor.
+      #
+      # @param attributes [Array<Attribute>]
+      #   trace global attributes
+      def trace(attributes=[])
+        new("trace", attributes).tap do |global|
+          global.extend TraceAttributeAccessor
+        end
+      end
+    end
+
+    # @return [String]
+    #   scope name
+    attr_reader :scope
+
+    # @return [Array<Attribute>]
+    #   global attributes
+    attr_accessor :attributes
+
+    # @param scope [String]
+    #   scope of global attributes
+    # @param attributes [Arrray<Attribute>]
+    #   global attributes
+    def initialize(scope, attributes=[])
+      @scope = scope
+      @attributes = attributes
+    end
+
+    # Return true if the element is formattable.
+    #
+    # @return [Boolean]
+    #   true if the element is formattable
+    def formattable?
+      not(@attributes.empty?)
+    end
+
+    # Format as a XML element.
+    #
+    # @return [REXML::Element]
+    #   XML element
+    def format
+      raise FormatError.new(self) unless formattable?
+
+      REXML::Element.new("global").tap do |global|
+        global.attributes["scope"] = @scope.to_s
+        @attributes.each {|attribute| global.elements << attribute.format}
+      end
+    end
+
+    # @api private
+    def ==(other)
+      @scope == other.scope and @attributes == other.attributes
+    end
+    alias :eql? :"=="
+
+    # @api private
+    def hash
+      @scope.hash + @attributes.hash
+    end
+  end
+end

data/lib/xes/log.rb

@@ -0,0 +1,158 @@
+module XES
+  # Log represents log element of XES.
+  class Log
+    extend AttributeAccessor
+
+    # @!attribute [rw] concept_name
+    #   @return [String]
+    #     the value of attribute "concept:name"
+    define_attribute "concept:name", "string"
+
+    # @!attribute [rw] lifecycle_model
+    #   @return [String]
+    #     the value of attribute "lifecycle:model"
+    define_attribute "lifecycle:model", "string"
+
+    # @!attribute [rw] semantic_modelReference
+    #   @return [String]
+    #     the value of attribute "semantic:modelReference"
+    define_attribute "semantic:modelReference", "string"
+
+    # @!attribute [rw] identity_id
+    #   @return [String]
+    #     the value of attribute "identity:id"
+    define_attribute "identity:id", "id"
+
+    class << self
+      # Create new instance with default values.
+      #
+      # @return [Log]
+      #   new log instance
+      def default
+        new.tap do |log|
+          log.xes_version = "1.4"
+          log.xes_features = "nested-attributes"
+          log.openxes_version = "1.0RC7"
+          log.extensions = [
+            EXTENSION[:concept],
+            EXTENSION[:identity],
+            EXTENSION[:time],
+            EXTENSION[:lifecycle],
+            EXTENSION[:organizational],
+          ]
+          log.classifiers = [
+            CLASSIFIER[:mxml_legacy_classifier],
+            CLASSIFIER[:event_name],
+            CLASSIFIER[:resource]
+          ]
+        end
+      end
+    end
+
+    # @return [String]
+    #   XES version
+    attr_accessor :xes_version
+
+    # @return [String]
+    #   XES features
+    attr_accessor :xes_features
+
+    # @return [String]
+    #   openxes version for faking ProM
+    attr_accessor :openxes_version
+
+    # @return [String]
+    #   xmlns value
+    attr_accessor :xmlns
+
+    # @return [Array<Extension>]
+    #   XES extensions
+    attr_accessor :extensions
+
+    # @return [Array<Classifier>]
+    #   XES classifiers
+    attr_accessor :classifiers
+
+    # @return [Array<Global>]
+    #   XES global elements for event attributes
+    attr_accessor :event_global
+
+    # @return [Array<Global>]
+    #   XES global elements for trace attributes
+    attr_accessor :trace_global
+
+    # @return [Array<Attribute>]
+    #   XES attribute elements
+    attr_accessor :attributes
+
+    # @return [Array<XESTrace>]
+    #   XES trace elements
+    attr_accessor :traces
+
+    def initialize
+      @xes_version = "1.4"
+      @xes_features = ""
+      @openxes_version = nil
+      @xmlns = "http://www.xes-standard.org/"
+      @extensions = []
+      @event_global = Global.event
+      @trace_global = Global.trace
+      @classifiers = []
+      @attributes = []
+      @traces = []
+    end
+
+    # Return true if the element is formattable.
+    #
+    # @return [Boolean]
+    #   true if the element is formattable
+    def formattable?
+      @traces.any? {|trace| trace.formattable?}
+    end
+
+    # Format as a XML element.
+    #
+    # @return [REXML::Element]
+    #   XML element
+    # @raise FormatError
+    #   format error when the log is formattable
+    def format
+      raise FormatError.new(self) unless formattable?
+
+      REXML::Element.new("log").tap do |log|
+        log.attributes["xes.version"] = @xes_version.to_s if @xes_version
+        log.attributes["xes.features"] = @xes_features.to_s if @xes_features
+        log.attributes["openxes.version"] = @openxes_version.to_s if @openxes_version
+        log.attributes["xmlns"] = @xmlns.to_s if @xmlns
+        @extensions.each {|ext| log.elements << ext.format if ext.formattable?}
+        @classifiers.each {|classifier| log.elements << classifier.format if classifier.formattable?}
+        log.elements << @event_global.format if @event_global.formattable?
+        log.elements << @trace_global.format if @trace_global.formattable?
+        @attributes.each {|attribute| log.elements << attribute.format if attribute.formattable?}
+        @traces.each {|trace| log.elements << trace.format if trace.formattable?}
+      end
+    end
+
+    # @api private
+    def ==(other)
+      return false unless other.kind_of?(self.class)
+      return false unless @xes_version == other.xes_version
+      return false unless @xes_features == other.xes_features
+      return false unless @openxes_version == other.openxes_version
+      return false unless @xmlns == other.xmlns
+      return false unless @extensions == other.extensions
+      return false unless @event_global == other.event_global
+      return false unless @trace_global == other.trace_global
+      return false unless @classifiers == other.classifiers
+      return false unless @attributes == other.attributes
+      return false unless @traces == other.traces
+      return true
+    end
+    alias :eql? :"=="
+
+    # @api private
+    def hash
+      @attributes.hash + @events.hash
+    end
+  end
+end