gexf 0.0.2

data/lib/gexf/node.rb

@@ -0,0 +1,52 @@
+class GEXF::Node
+  extend Forwardable
+  include GEXF::Attribute::Assignable
+
+  attr_reader :id, :label
+
+  def_delegators :@graph, :edgetype
+
+  def initialize(id, graph, opts={})
+    @graph       = graph
+    @id          = id_type(id)
+    @label       = opts[:label] || @id
+
+    # see GEXF::Attribute::Assignable
+    @collection  = graph.nodes
+    @attr_values = {}
+
+    set_attributes(opts.fetch(:attributes, {}))
+  end
+
+  def connect_to(target, opts={})
+    graph.nodes << target
+    graph.create_edge(self, target, opts)
+  end
+
+  def create_and_connect_to(target_attr, opts={})
+    node = graph.create_node(target_attr)
+    connect_to(node, opts)
+    node
+  end
+
+  def connections(type=nil)
+    graph.edges[self.id].to_a
+  end
+
+  def to_hash
+    {:id => id, :label => label}
+  end
+
+private
+  def set_attributes(attributes={})
+    attributes.each { |attr,value| self[attr]=value }
+  end
+
+  def id_type(id)
+    graph.idtype == GEXF::Graph::INTEGER ? id.to_i : id.to_s
+  end
+
+  def graph
+    @graph
+  end
+end

data/lib/gexf/nodeset.rb

@@ -0,0 +1,19 @@
+class GEXF::NodeSet < Set
+  extend Forwardable
+  include GEXF::Attribute::Definable
+
+  def_delegators :@hash, :[], :fetch, :keys, :values
+
+  def <<(node)
+    @hash[node.id] = node if node.is_a?(GEXF::Node)
+  end
+
+  def each(&block)
+    @hash.values.each(&block)
+  end
+
+  def inspect
+    "<GEXF::NodeSet #{@hash.keys}>"
+  end
+
+end

data/lib/gexf/set_of_sets.rb

@@ -0,0 +1,38 @@
+class GEXF::SetOfSets < Set
+  extend ::Forwardable
+  include GEXF::Attribute::Definable
+
+  def_delegators :@hash, :empty?
+
+  def [](node_id)
+    @hash[node_id]
+  end
+
+  def to_a
+    uniq_items
+  end
+
+  def to_hash
+    @hash
+  end
+
+  def each(&block)
+    uniq_items.each(&block)
+  end
+
+  [:size, :count, :length].each do |method|
+    define_method(method) do
+      uniq_items.count
+    end
+  end
+
+private
+  def append_to_key(key, value)
+    @hash[key] ||= Set.new
+    @hash[key] << value
+  end
+
+  def uniq_items
+    @hash.map {| _, v| v.to_a }.flatten.uniq
+  end
+end

data/lib/gexf/support.rb

@@ -0,0 +1,18 @@
+GEXF::GRAPH_TYPES = (GEXF::Attribute::TYPES   +
+                     GEXF::Edge::TYPES        +
+                     GEXF::Graph::IDTYPES     +
+                     GEXF::Graph::MODES).uniq
+
+class Hash
+  def symbolize_keys
+    hash = {}
+    each { |k,v| hash[k.to_sym] = delete(k) }
+    merge(hash)
+  end
+
+  def symbolize_graph_types
+    hash = {}
+    each { |k, v| hash[k] = delete(k).to_sym if GEXF::GRAPH_TYPES.include?(v.to_sym) }
+    merge(hash)
+  end
+end

data/lib/gexf/version.rb

@@ -0,0 +1,3 @@
+module GEXF
+  VERSION = '0.0.2'
+end

data/lib/gexf/xml_serializer.rb

@@ -0,0 +1,93 @@
+class GEXF::XmlSerializer
+
+  GEXF_ATTRS = {
+    'xmlns'     => '"http://www.gexf.net/1.2draft',
+    'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+    'xsi'       => 'http://www.gexf.net/1.2draft http://www.gexf.net/1.2draft/gexf.xsd',
+    'version'   => '1.2'
+  }
+
+  def initialize(graph)
+    @graph    = graph
+    @document = nil
+  end
+
+  def serialize!
+    document.to_xml
+  end
+
+private
+  def g
+    @graph
+  end
+
+  def graph_attributes
+    { :defaultedgetype   => g.defaultedgetype,
+      :idtype            => g.idtype,
+      :mode              => g.mode }
+  end
+
+  def build_attributes(xml)
+    %w(nodes edges).each do |type|
+      defined_attributes = g.send(type).defined_attributes
+      next if defined_attributes.empty?
+
+      xml.attributes(:class => type.gsub(/s$/,'')) {
+        defined_attributes.map do |id, attr| 
+          xml.attribute(attr.to_hash) {
+            xml.default(attr.default) if attr.default
+          }
+        end
+      }
+    end
+  end
+
+  def build_nodes(xml)
+    build_collection(xml, 'nodes')
+  end
+
+  def build_edges(xml)
+    build_collection(xml, 'edges')
+  end
+
+  def build_collection(xml, collection_name, tagname=nil)
+    tagname ||= collection_name.gsub /s$/,''
+
+    xml.send(collection_name) do
+      g.send(collection_name).each do |item|
+        build_item(xml, item, tagname)
+      end
+    end
+  end
+
+  def build_item(xml, item, tagname)
+    if item.attr_values.any?
+      xml.send(tagname, item.to_hash) do
+        xml.attvalues do
+          item.attr_values.each do |id, value|
+            value = value.join('|') if value.respond_to?(:join)
+            xml.attvalue(:for => id, :value => value)
+          end
+        end
+      end
+    else
+      xml.send(tagname, item.to_hash)
+    end
+  end
+
+  def document
+    @document ||= build do |xml|
+      xml.gexf(GEXF_ATTRS) do
+        xml.graph(graph_attributes) do
+          build_attributes(xml) 
+          build_nodes(xml)
+          build_edges(xml)
+        end
+      end
+    end
+  end
+
+  def build(&block)
+    Nokogiri::XML::Builder.new(:encoding => 'UTF-8', &block)
+  end
+end

data/spec/gexf/attribute/assignable_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+module FakeClasses
+  class MyClass
+    include GEXF::Attribute::Assignable
+
+    def initialize(collection, attr_values)
+      @collection  = collection
+      @attr_values = attr_values
+    end
+  end
+end
+
+describe GEXF::Attribute::Assignable do
+
+  let(:attribute1)  { double('attribute1', :id => '1', :title => "attribute1", :default => nil) }
+  let(:attribute2)  { double('attribute2', :id => '2', :title => "attribute2", :default => nil) }
+  let(:attribute3)  { double('attribute3', :id => '3', :title => "attribute3", :default => nil) }
+  let(:frog)        { GEXF::Attribute.new(4, 'frog', :default => true, :type => GEXF::Attribute::BOOLEAN) }
+
+  let(:attr_values) {{}}
+
+  let(:attributes)   { { '1' => attribute1,
+                         '2' => attribute2,
+                         '3' => attribute3 } }
+
+  let(:collection)   { double('collection', :attribute_definitions => attributes) }
+
+  subject { FakeClasses::MyClass.new(collection, attr_values) }
+
+  describe "#attributes" do
+    context "when graph has no attribute definition" do
+      let(:attributes) {{}}
+      its(:attributes) { should == attributes }
+    end
+
+    context "when graph has attributes" do
+      context "node/edge has no values set" do
+        it "returns a hash of attributes with nil values" do
+          subject.attributes.should == {
+            'attribute1' => nil,
+            'attribute2' => nil,
+            'attribute3' => nil
+          }
+        end
+      end
+
+      context "node/edge has values" do
+
+        let(:attr_values) {{ '1' => 'foo',
+                             '2' => 'bar'}}
+
+        it "returns a hash of attributes with non-nil values" do
+          subject.attributes.should == {
+            'attribute1' => 'foo',
+            'attribute2' => 'bar',
+            'attribute3' => nil
+          }
+        end
+      end
+    end
+  end
+
+  describe "#[]" do
+    context 'when attribute title does not exist' do
+      it "raises a warning, and returns nil" do
+        Kernel.should_receive(:warn).with("undefined attribute 'other-attribute'")
+        subject['other-attribute'].should be_nil
+      end
+    end
+    context "when node/edge has no attribute values" do
+      it "returns nil" do
+        Kernel.should_not_receive(:warn)
+        subject['attribute1'].should be_nil
+      end
+    end
+
+    context "when node/edge has a value" do
+      let(:attr_values) {{ '1' => 'foo' }}
+
+      it "returns the value" do
+        subject[:attribute1].should == 'foo'
+      end
+    end
+
+    context "when attribute has a default value" do
+      let(:attributes) {{ frog.id => frog }}
+
+      it "returns the default value" do
+        subject[:frog].should == true
+      end
+    end
+  end
+
+  describe "#[]=" do
+
+    let(:value) { '22' }
+
+    context 'when attribute title does not exist' do
+      it "prints a warning, does not set the attribute value" do
+        Kernel.should_receive(:warn).with("undefined attribute 'other-attribute'")
+        attr_values.should_not_receive(:[]=)
+        subject['other-attribute'] = value
+      end
+    end
+
+    context "when attribute title does exist" do
+      it "sets the attribute value" do
+        Kernel.should_not_receive(:warn)
+        attribute2.should_receive(:coherce).with(value).and_return(value)
+        attribute2.should_receive(:is_valid?).with(value).and_return(true)
+        attr_values.should_receive(:[]=).with('2', value)
+        subject['attribute2'] = value
+      end
+    end
+  end
+
+end

data/spec/gexf/attribute/definable_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+module FakeClassess
+  class NodeSet < Set
+    include GEXF::Attribute::Definable
+  end
+end
+
+describe GEXF::Attribute::Definable do
+  let(:node1)     { mock('node', :id => '1' )}
+  let(:node2)     { mock('node', :id => '2' )}
+  let(:nodeset)   { FakeClassess::NodeSet.new }
+  let(:attr_id)   { '22' }
+  let(:title)     { 'tags' }
+  let(:attr_type) { GEXF::Attribute::LIST_STRING }
+  let(:opts)      {{ :type => attr_type }}
+  let(:arguments) {[attr_id, title, opts]}
+
+  before do
+    nodeset << node1 << node2
+  end
+
+  describe "#define_attribute" do
+    subject { nodeset.define_attribute(*arguments) }
+
+    it "Instantiates an new GEXF::Attribute" do
+      subject.should be_a_kind_of(GEXF::Attribute)
+    end
+  end
+
+  describe "#attribute_definitions" do
+
+    let(:attribute) { mock('attribute') }
+
+    subject { nodeset }
+
+    before(:each) do
+      GEXF::Attribute.should_receive(:new).and_return(attribute)
+      nodeset.define_attribute(*arguments)
+    end
+
+    its(:attribute_definitions) { should have_key(attr_id) }
+    its(:attribute_definitions) { should have_value(attribute) }
+    its(:attribute_definitions) { should have(1).item }
+  end
+
+  describe "#attributes" do
+    let(:nodeattrs)  {{ :foo => 'fooval', :bar => 'barval' }}
+
+    subject { nodeset.attributes }
+
+    before(:each) do
+      node1.stub(:attributes).and_return(nil)
+      node2.stub(:attributes).and_return(nodeattrs)
+
+      nodeset.define_attribute('1', 'foo')
+      nodeset.define_attribute('2', 'bar')
+    end
+
+    it "returns a hash of items with attributes" do
+      subject.should_not have_key('1')
+      subject.should have_key('2')
+      subject.should have_value(nodeattrs)
+    end
+  end
+end

data/spec/gexf/attribute_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+TRUTHY_INPUTS = [1, '1', true, 'true']
+FALSY_INPUTS  = [0, '0', false, 'false']
+EMPTY_ARRAY   = []
+EMPTY_STRING  = []
+OBJECT        = Object.new
+
+describe GEXF::Attribute do
+
+  let(:id)           { 22 }
+  let(:type)         { nil }
+  let(:mode)         { nil }
+  let(:attr_class)   { nil }
+  let(:title)        { 'foo' }
+  let(:attr_options) { ['foo', 'bar', 'baz'] }
+  let(:title)        { 'bar' }
+  let(:default)      { 'foo' }
+
+  let(:options)      {{ :mode    => mode,
+                        :class   => attr_class,
+                        :default => default,
+                        :type    => type,
+                        :options => attr_options }}
+
+  let(:arguments)    { [id, title, options] }
+
+  subject { GEXF::Attribute.new(*arguments) }
+
+  describe "getter methods" do
+    its(:title)      { should == 'bar' }
+    its(:type)       { should == GEXF::Attribute::STRING }
+    its(:id)         { should == id.to_s }
+    its(:options)    { should == attr_options }
+    its(:default)    { should == default }
+    its(:mode)       { should == GEXF::Attribute::STATIC }
+    its(:attr_class) { should == GEXF::Attribute::NODE }
+
+    context "with invalid type" do
+      let(:type) { :BANANA }
+
+      it "raises an ArgumentError" do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+    {:mode => :FOO, :attr_class => :BANANA}.each do |attr, invalid_value|
+      context "when :#{attr} is not valid" do
+        let(attr) { invalid_value }
+
+        it "raises an ArgumentError" do
+          expect { subject }.to raise_error(ArgumentError)
+        end
+      end
+    end
+
+    context "when 'options' do not include 'default' value" do
+      let(:default) { :bacon }
+
+      it "raises an ArgumentError" do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "is_valid?" do
+    context "when :options is empty/nil" do
+      let(:attr_options) { nil }
+
+      it "returns true" do
+        subject.is_valid?('whaterver').should be_true
+      end
+    end
+
+    context "when :options is not empty" do
+      context "and :options include input value" do
+        it "returns true" do
+          subject.is_valid?('foo').should be_true
+        end
+      end
+      context "and :options do not include input value" do
+        it "returns false" do
+          subject.is_valid?('bacon').should be_false
+        end
+      end
+    end
+  end
+
+  describe "coherce" do
+
+    subject { GEXF::Attribute.new(*arguments).coherce(value) }
+
+    context "when attribute type is :BOOLEAN" do
+      let(:type) { GEXF::Attribute::BOOLEAN }
+
+      context "Falsy inputs" do
+        FALSY_INPUTS.each do |value|
+          context "and input value is #{value}" do
+            let(:value) { value }
+            it { subject.should be_false }
+          end
+        end
+      end
+      context "Truty inputs" do
+        TRUTHY_INPUTS.each do |value|
+          context "and input value is #{value}" do
+            let(:value) { value }
+            it { subject.should be_true }
+          end
+        end
+      end
+      context "other input types" do
+        [22, -2, Object.new, [1,2,3], 'hello', :hi].each do |value|
+          context "input value is '#{value.inspect}'" do
+            let(:value) { value }
+
+            it { subject.should be_nil }
+          end
+        end
+      end
+    end
+
+    [GEXF::Attribute::STRING, GEXF::Attribute::ANY_URI].each do |type|
+      context "when attribute type is #{type}" do
+        let(:type) { type }
+
+        [22, 2.1, Object.new, nil, true, false].each do |value|
+          context "and input value is '#{value.inspect}'" do
+            let(:value) { value }
+            it { should == value.to_s }
+          end
+        end
+      end
+    end
+
+    context "when attribute type is :INTEGER" do
+      let(:type) { GEXF::Attribute::INTEGER }
+
+      [22, 2.1, nil].each do |value|
+        context "and input value is '#{value.inspect}'" do
+          let(:value) { value }
+          it { should == value.to_i }
+        end
+      end
+
+      [Object.new, true, false].each do |value|
+        context "and input value is '#{value.inspect}'" do
+          let(:value) { value }
+          it { should be_nil }
+        end
+      end
+    end
+
+    context "when attribute type is :LIST_STRING" do
+      let(:type) { GEXF::Attribute::LIST_STRING }
+
+      context "input is nil" do
+        let(:value) { nil }
+
+        it { subject.should == [] }
+      end
+
+      context "input is not empty" do
+        let(:value) { [:foo, :bar, 22] }
+        it { subject.should == value.map(&:to_s) }
+      end
+
+      context "input contains duplicates" do
+        let(:value) { [:foo, :bar, 22, 'foo'] }
+        it { subject.should == %w(foo bar 22) }
+      end
+
+      context "input contains nested lists" do
+        let(:value) { [:foo, :bar, 22, ['foo']] }
+        it { subject.should == %w(foo bar 22) }
+      end
+    end
+  end
+end