gexf 0.0.2

data/lib/gexf.rb

@@ -0,0 +1,21 @@
+$LOAD_PATH << File.expand_path('../gexf', __FILE__)
+
+require 'nokogiri'
+require 'forwardable'
+require 'set'
+
+module GEXF;end
+
+require 'version'
+require 'attribute'
+require 'attribute/definable'
+require 'attribute/assignable'
+require 'set_of_sets'
+require 'node'
+require 'nodeset'
+require 'edge'
+require 'edgeset'
+require 'graph'
+require 'xml_serializer'
+require 'document'
+require 'support'

data/lib/gexf/attribute.rb

@@ -0,0 +1,92 @@
+class GEXF::Attribute
+
+  BOOLEAN     = :boolean
+  STRING      = :string
+  INTEGER     = :integer
+  FLOAT       = :float
+  ANY_URI     = :anyURI
+  LIST_STRING = :liststring
+  TYPES       = [ BOOLEAN, STRING, INTEGER, FLOAT, ANY_URI, LIST_STRING]
+
+  DYNAMIC     = :dynamic
+  STATIC      = :static
+  MODES       = [DYNAMIC, STATIC]
+
+  NODE        = :node
+  EDGE        = :edge
+  CLASSES     = [NODE, EDGE]
+
+  attr_reader :type, :id, :title, :options, :mode, :attr_class, :default
+
+  def initialize(id, title, opts={})
+
+    attr_class = opts[:class] || NODE
+    mode       = opts[:mode]  || STATIC
+    type       = opts[:type]  || STRING
+    default    = opts[:default]
+    options    = opts[:options]
+    id         = id.to_s
+
+    @options   = if type == LIST_STRING && options.respond_to?(:split)
+                   options.split('|').uniq
+                 else
+                   Array(options).uniq
+                 end
+
+
+    raise ArgumentError.new "Invalid or missing type: #{type}" if !TYPES.include?(type)
+    raise ArgumentError.new "invalid or missing class: #{attr_class}" if !CLASSES.include?(attr_class)
+    raise ArgumentError.new "Invalid mode: #{mode}" if !MODES.include?(mode)
+
+    @attr_class = attr_class
+    @type       = type
+    @id         = id
+    @type       = type
+    @mode       = mode
+    @title      = title.to_s
+    self.default=default
+  end
+
+  def default=(value)
+    raise ArgumentError.new "value value '#{value}' is not included in 'options' list" if value && @options.any? && !@options.include?(value)
+    @default=value
+  end
+
+  #Note: is this a violation of the "Tell don't ask principle"?
+  def coherce(value)
+    case @type
+    when BOOLEAN
+      case value
+      when *['1', 'true', 1, true]
+        true
+      when *['0', 'false', 0, false]
+        false
+      end
+    when STRING, ANY_URI
+      value.to_s
+    when FLOAT
+      value.to_f if value.respond_to?(:to_f)
+    when INTEGER
+      value.to_i if value.respond_to?(:to_i)
+
+    when LIST_STRING
+      Array(value).flatten.map(&:to_s).uniq
+    end
+  end
+
+  def is_valid?(value)
+    if @options.empty?
+      true
+    else
+      value = value.first if value.respond_to?(:first)
+      @options.map(&:to_s).include?(value.to_s)
+    end
+  end
+
+  def to_hash
+    optional = {}
+    optional[:options] = options.join('|') if options && options.any?
+
+    {:id => id, :title => title, :type => type}.merge(optional)
+  end
+end

data/lib/gexf/attribute/assignable.rb

@@ -0,0 +1,81 @@
+module GEXF::Attribute::Assignable 
+
+  # Delegates calls for the 'defined_attributes' method to the @collection instance variable
+  #
+  # Returns nothing.
+
+  def self.included(base)
+    base.extend(Forwardable) unless base.ancestors.include?(Forwardable)
+
+    base.def_delegator :collection, :attribute_definitions, :defined_attributes
+    base.def_delegator :attr_values, :[], :attr_value
+  end
+
+  # Reconstructs a hash of attiribute titles/values for the current node/edge
+  #
+  # Example:
+  #
+  #   node.attributes
+  #   => {:site => 'http://www.archive.org', :name => 'The internet archive'}
+  #
+  # Returns
+  #
+  #   The attributes hash
+  #
+  def attributes()
+    Hash[*defined_attributes.map do |_, attr|
+      [attr.title, attr_value(attr.id)]
+    end.flatten]
+  end
+
+  #
+  # Fetches the attribute hash, and sets it to an empty array if this is not defined.
+  #
+  # Returns the 'attr_values' hash.
+  #
+
+  def attr_values
+    @attr_values ||= {}
+  end
+
+  #
+  # Fetches an attribute by title.
+  #
+  # Returns the attribute value.
+  # Raises a warning if the attribute has not been defined..
+  #
+
+  def [](key)
+    if attr = attribute_by_title(key)
+      attr_value(attr.id) || attr.default
+    else
+      Kernel.warn "undefined attribute '#{key}'"
+    end
+  end
+
+  # low level setter, suitable to be used when parsing (see GEXF::Document)
+  def set_attr_by_id(attr_id, value)
+    @attr_values[attr_id] = value
+  end
+
+  def []=(key, value)
+    attr  = attribute_by_title(key)
+    value = attr && attr.coherce(value) || value
+
+    if attr && attr.is_valid?(value)
+      attr_values[attr.id] = value
+    else
+      Kernel.warn "undefined attribute '#{key}'"
+    end
+  end
+
+private
+  def collection
+    @collection || []
+  end
+
+  def attribute_by_title(key)
+    _, attribute = *defined_attributes.find { |id, attr| attr.title == key.to_s }
+    attribute
+  end
+end

data/lib/gexf/attribute/definable.rb

@@ -0,0 +1,20 @@
+module GEXF::Attribute::Definable
+
+  def define_attribute(id, title, opts={})
+    @attribute_definitions ||= {}
+    @attribute_definitions[id] = GEXF::Attribute.new(id, title, opts)
+  end
+
+  def attributes
+    Hash[*map do |item|
+      attributes = item.attributes
+      [item.id, attributes] if attributes && attributes.any?
+     end.compact.flatten]
+  end
+
+  def attribute_definitions
+    @attribute_definitions ||= {}
+  end
+
+  alias_method :defined_attributes, :attribute_definitions
+end

data/lib/gexf/document.rb

@@ -0,0 +1,112 @@
+class GEXF::Document < Nokogiri::XML::SAX::Document
+
+  attr_reader :graph, :meta
+
+  def start_document
+    @graph            = nil
+    @node             = nil
+    @edge             = nil
+    @attr_class       = nil
+    @attr             = nil
+    @defined_attrs    = {}
+  end
+
+  def start_element(tagname, attributes)
+    @current_tag       = tagname
+    @current_tag_attrs = attributes
+
+    dispatch_event(tagname, sanitize_attrs(attributes))
+  end
+
+  def end_element(tagname)
+    case tagname
+    when 'attributes'
+      @attr_class     = nil
+    when 'attribute'
+      @attr           = nil
+    when 'node'
+      @node           = nil
+    when 'edge'
+      @edge           = nil
+    end
+
+    @current_tag_attrs = {}
+    @current_tag       = nil
+  end
+
+  def characters(chars)
+    chars = chars.strip
+    case @current_tag
+    when 'default'
+      @attr.default = chars
+    end
+  end
+
+private
+   def dispatch_event(tagname, attributes)
+     case tagname
+     when 'graph'
+       on_graph_start(attributes)
+     when 'attributes'
+       @attr_class = attributes[:class]
+     when 'attribute'
+       on_attribute_start(attributes)
+     when 'attvalue'
+       on_attrvalue_start(attributes)
+     when 'node'
+       on_node_start(attributes)
+     when 'edge'
+       on_edge_start(attributes)
+     else
+     end
+   end
+
+   def sanitize_attrs(attributes)
+     Hash[*attributes.flatten].
+       symbolize_keys.
+       symbolize_graph_types
+   end
+
+   def on_graph_start(attributes)
+     @graph = GEXF::Graph.new(attributes)
+   end
+
+   def on_attribute_start(definition)
+     title      = definition.delete(:title)
+     type       = definition[:type]
+     definition.delete(:class)
+
+     @attr = case @attr_class
+            when 'node'
+              graph.define_node_attribute(title, definition)
+            when 'edge'
+              graph.define_edge_attribute(title, definition)
+            end
+
+     @defined_attrs[@attr.id] = @attr.title
+   end
+
+   def on_node_start(attributes)
+     @node = graph.create_node(attributes)
+   end
+
+   def on_edge_start(attributes)
+     source_id = attributes.delete(:source)
+     target_id = attributes.delete(:target)
+
+     source    = graph.nodes[source_id]
+     target    = graph.nodes[target_id]
+
+     @edge = graph.create_edge(source, target, attributes)
+   end
+
+   def on_attrvalue_start(attrs)
+     attr_id = attrs[:for]
+
+     if @defined_attrs[attr_id]
+       @node.set_attr_by_id(attr_id, attrs[:value])
+     else
+       warn "Cannot find an attribute with id: #{id}"
+     end
+   end
+end

data/lib/gexf/edge.rb

@@ -0,0 +1,73 @@
+class GEXF::Edge
+  include GEXF::Attribute::Assignable
+
+  DIRECTED   = :directed
+  UNDIRECTED = :undirected
+  MUTUAL     = :mutual
+
+  TYPES = [ DIRECTED, UNDIRECTED, MUTUAL]
+
+  attr_reader :id, :source_id, :target_id, :weight, :type, :label
+
+  def initialize(id, source_id, target_id, opts={})
+
+    type      = opts[:type] || UNDIRECTED
+    weight    = opts[:weight] && opts[:weight].to_f
+    graph     = opts[:graph]
+    label     = opts[:label] && opts[:label].to_s || nil
+    id        = id.to_s
+    source_id = source_id.to_s
+    target_id = target_id.to_s
+
+    raise ArgumentError.new("Invalid type: #{type}")                          if !TYPES.include?(type)
+    raise ArgumentError.new("'weight' should be a positive, numerical value") if weight && weight < 0.1
+    raise ArgumentError.new("Missing graph")                                  if !graph
+    raise ArgumentError.new("Missing id")                                     if !id     || id.empty?
+    raise ArgumentError.new("Missing source_id")                              if !source_id || source_id.empty?
+    raise ArgumentError.new("Missing target_id")                              if !target_id || target_id.empty?
+
+    @id          = id.to_s
+    @label       = label
+    @type        = type
+    @source_id   = source_id.to_s
+    @target_id   = target_id.to_s
+    @weight      = weight || 1.0
+    @graph       = graph
+    # see GEXF::Attribute::Assignable
+    @collection  = @graph.edges
+    @attr_values = {}
+
+    set_attributes(opts.fetch(:attributes, {}))
+  end
+
+  [:directed, :undirected, :mutual].each do |type|
+    define_method("#{type}?") do
+      @type == self.class.const_get(type.to_s.upcase)
+    end
+  end
+
+  def target
+    @graph.nodes[target_id]
+  end
+
+  def source
+    @graph.nodes[source_id]
+  end
+
+  def to_hash
+    optional = {}
+    optional[:label] = label if label && !label.empty?
+
+    {:id => id,
+     :source => source_id,
+     :target => target_id,
+     :type => type
+
+    }.merge(optional)
+  end
+
+private
+  def set_attributes(attributes={})
+    attributes.each { |attr,value| self[attr]=value }
+  end
+end

data/lib/gexf/edgeset.rb

@@ -0,0 +1,7 @@
+class GEXF::EdgeSet < GEXF::SetOfSets
+  def <<(edge)
+    append_to_key(edge.source_id, edge)
+    append_to_key(edge.target_id, edge) unless edge.directed?
+    self
+  end
+end

data/lib/gexf/graph.rb

@@ -0,0 +1,82 @@
+class GEXF::Graph
+
+  STRING    = :string
+  INTEGER   = :integer
+  IDTYPES   = [STRING, INTEGER]
+
+  STATIC    = :static
+  DYNAMIC   = :dynamic
+  MODES     = [STATIC, DYNAMIC]
+
+  EDGETYPES = GEXF::Edge::TYPES
+
+  attr_reader :defaultedgetype, :idtype, :mode, :nodes, :edges
+
+  def initialize(opts={})
+    edgetype   = opts[:defaultedgetype] || GEXF::Edge::UNDIRECTED
+    idtype     = opts[:idtype]   || STRING
+    mode       = opts[:mode]     || STATIC
+    id_counter = Struct.new(:nodes, :edges, :attributes)
+
+    raise ArgumentError.new "Invalid defaultedgetype: '#{edgetype}'" unless EDGETYPES.include?(edgetype)
+    raise ArgumentError.new "Invalid idtype: '#{idtype}'"     unless IDTYPES.include?(idtype)
+    raise ArgumentError.new "Invalid mode: '#{mode}'"         unless MODES.include?(mode)
+
+    @defaultedgetype = edgetype
+    @idtype          = idtype
+    @mode            = mode
+    @id_counter      = id_counter.new(0,0,0)
+    @attributes      = {}
+
+    @nodes           = GEXF::NodeSet.new
+    @edges           = GEXF::EdgeSet.new
+  end
+
+  def defined_attributes
+    nodes.defined_attributes.merge(edges.defined_attributes)
+  end
+
+  def define_node_attribute(title, opts={})
+    id                = assign_id(:attributes, opts.delete(:id)).to_s
+    @nodes.define_attribute(id, title, opts)
+  end
+
+  def define_edge_attribute(title, opts={})
+    id                = assign_id(:attributes, opts.delete(:id)).to_s
+    @edges.define_attribute(id, title, opts)
+  end
+
+  def create_node(opts={})
+    id                = assign_id(:nodes, opts.delete(:id))
+    @nodes << node    = GEXF::Node.new(id, self, opts)
+    node
+  end
+
+  def create_edge(source, target, opts={})
+    opts[:type]       ||= defaultedgetype
+    id                = assign_id(:edges, opts.delete(:id))
+    @edges << edge    = GEXF::Edge.new(id, source.id, target.id, opts.merge(:graph => self))
+    edge
+  end
+
+  def attribute_definitions
+    @attributes.dup
+  end
+
+private
+  def assign_id(counter_name, id=nil)
+    auto_id = @id_counter.send(counter_name) + 1
+
+    if !id
+      id = auto_id
+      @id_counter.send("#{counter_name}=", id)
+    end
+
+    cast_id(id)
+  end
+
+  def cast_id(id)
+    @idtype == INTEGER ? id.to_i : id.to_s
+  end
+
+end