neo-viz 1.0.1

data/public/scss/main.scss

@@ -0,0 +1,152 @@
+@import 'mixins.scss';
+
+$page-width: 760px;
+$body-color-top: #ffe;
+$body-color-bottom: #dfa;
+
+$default-radius: .8em;
+
+$header-font: normal 24px Verdana, sans-serif;
+
+.clear { clear: both; }
+
+.neoviz_body {
+  font-family: Century Gothic, sans-serif;
+  font-size: 14px;
+  line-height: 18px;
+  @include background-gradient($body-color-top, $body-color-bottom);
+}
+
+.neoviz_header {
+  p {
+    float: right;
+    width: 240px;
+    margin-right: 1em;
+    margin-top: 0;
+    padding: 1em;
+    @include sym-border-radius($default-radius);
+    color: white;
+    background: gray;
+  }
+
+  td{
+    vertical-align:top;
+  }
+  
+  form {
+    float: left;
+    padding: 0.4em;
+    margin: 1em;
+    @include sym-border-radius($default-radius);
+    color: black;
+    border: gray solid 2px;
+
+    input[type=number] {
+      width: 3em;
+    }
+    textarea {
+      width: 20em;
+      height: 4em;
+    }
+  }
+}
+
+#console {
+    width: 600px;
+    height: 100px;
+}
+
+#consoleOutputArea{
+    width: 600px;
+    height: 50px;
+}
+
+.viewport {
+    width: 960px;
+    height: 500px;
+}
+
+#container {
+  clear: both;
+  margin: 1em 1em 1em 1em;
+  border: 2px gray solid;
+  padding: 2em;
+  @include sym-border-radius($default-radius);
+  @include background-gradient($body-color-top, $body-color-bottom);
+
+  td {
+    vertical-align: top;
+  }
+}
+
+
+.details {
+
+  vertical-align: bottom;
+
+  table {
+    border: 2px solid gray;
+    border-spacing: 0;
+
+    tr {
+      margin: 0;
+      border-width: 0;
+      padding: 0;
+
+      &:nth-child(2n) { background-color: white; }
+      &:nth-child(2n+1) { background-color: lightgray; }
+    }
+    td {
+      border: 0 none black;
+      padding: 0.3em;
+      margin: 0;
+
+      &:first-child {
+        text-align: right;
+        padding-left: 1em;
+        font-weight: bold;
+      }
+    }
+  }
+}
+
+.filters{
+  table {
+    border: 1px solid gray;
+    border-spacing: 0;
+    background-color: #eee;
+
+    tr {
+      margin: 0;
+      border-width: 0;
+      padding: 0;
+
+    }
+    td {
+      border: 0 none black;
+      padding: 0.3em;
+      margin: 0;
+
+      &:first-child {
+        text-align: left;
+      }
+    }
+  }
+}
+
+.relationsFilter{
+   table {
+    tr {
+      &:nth-child(2n) { background-color: white; }
+      &:nth-child(2n+1) { background-color: lightgray; }
+    }
+    td {
+
+      &:first-child {
+        text-align: right;
+        padding-left: 1em;
+      }
+    }
+  }
+}
+

data/public/scss/mixins.scss

@@ -0,0 +1,37 @@
+@mixin reset {
+    html, body, div, span, applet, object, iframe,
+    h1, h2, h3, h4, h5, h6, tr, th, td {
+        margin: 0;
+        padding: 0;
+        border: 0;
+        outline: 0;
+        vertical-align: baseline;
+        background: transparent;
+    }
+    table {
+        border-collapse: collapse;
+        border-spacing: 0;
+    }
+
+}
+
+@mixin border-radius($tl, $tr, $br, $bl) {
+    -webkit-border-radius: $tl $tr $br $bl;
+    -moz-border-radius: $tl $tr $br $bl;
+    border-radius: $tl $tr $br $bl;
+}
+
+@mixin sym-border-radius($r) {
+    @include border-radius($r, $r, $r, $r);
+}
+
+@mixin background-gradient($top, $bottom) {
+  background: -webkit-gradient(linear, left top, left bottom, from($top), to($bottom));
+  background: -webkit-linear-gradient(top, $top, $bottom);
+  background: -moz-linear-gradient(top, $top, $bottom);
+  background: -ms-linear-gradient(top, $top, $bottom);
+  background: -o-linear-gradient(top, $top, $bottom);
+  background: linear-gradient(top, $top, $bottom);
+}
+
+

data/spec/coffeescripts/canvas_util_spec.coffee

@@ -0,0 +1,4 @@
+describe 'canvas_util', ->
+  describe '#centerToEdge', ->
+    it 'calculates the edge from the center', ->
+      expect(CanvasUtil.centerToEdge(200, 30)).toEqual 185

data/spec/coffeescripts/filters_spec.coffee

@@ -0,0 +1,37 @@
+describe 'filters', ->
+
+  it 'can build hiddenNodeData for circular subgraph hidden by user', ->
+    # n0--->---n1-----<-----n3
+    #           \-->--n2->--/
+    nodeData = [{"id":0},{"id":1},{"id":2},{"id":3}]
+    relData = [{"id":0, "start_node":0, "end_node":1, "data":{"rel_type":""}},
+               {"id":1, "start_node":1, "end_node":2, "data":{"rel_type":""}},
+               {"id":2, "start_node":2, "end_node":3, "data":{"rel_type":""}}
+               {"id":3, "start_node":3, "end_node":1, "data":{"rel_type":""}}]
+    graph = new Graph(nodeData, relData)
+
+    activatedNode = graph.load(0)
+    relsHiddenByUser = graph.relationships[0..0]
+    hiddenNodeData =  test_buildHiddenNodeData(graph, activatedNode, relsHiddenByUser)
+
+    expect(hiddenNodeData.nodeIds.length).toEqual(3)
+    expect(hiddenNodeData.relIds.length).toEqual(4) #4: rels hidden by user should be included
+
+  it 'can build hiddenNodeData for 6 node mesh with one hidden rel', ->
+    nodeData = [{"id":0},{"id":1},{"id":2},{"id":3},{"id":4},{"id":5}]
+    relData = [{"id":0, "start_node":0, "end_node":1, "data":{"rel_type":""}},
+               {"id":1, "start_node":1, "end_node":2, "data":{"rel_type":""}},
+               {"id":2, "start_node":2, "end_node":3, "data":{"rel_type":""}},
+               {"id":3, "start_node":3, "end_node":0, "data":{"rel_type":""}},
+               {"id":4, "start_node":3, "end_node":4, "data":{"rel_type":""}},
+               {"id":5, "start_node":4, "end_node":5, "data":{"rel_type":""}},
+               {"id":6, "start_node":5, "end_node":0, "data":{"rel_type":""}}]
+    graph = new Graph(nodeData, relData)
+
+    activatedNode = graph.load(0)
+    relsHiddenByUser = graph.relationships[6..6]
+    hiddenNodeData =  test_buildHiddenNodeData(graph, activatedNode, relsHiddenByUser)
+
+    expect(hiddenNodeData.nodeIds.length).toEqual(0)
+    expect(hiddenNodeData.relIds.length).toEqual(1)
+    expect(hiddenNodeData.relIds[0]).toEqual(6)

data/spec/coffeescripts/neo4j_spec.coffee

@@ -0,0 +1,76 @@
+describe 'neo4j', ->
+  describe 'Graph', ->
+
+    describe 'Node', ->
+
+      graph = null
+      node = null
+
+      beforeEach ->
+        nodeData = [{"id":0},{"id":1},{"id":2}]
+        relData = [{"id":0, "start_node":0, "end_node":1, "data":{"rel_type":"friend"}},
+                   {"id":1, "start_node":1, "end_node":2, "data":{"rel_type":"enemy"}},
+                   {"id":2, "start_node":2, "end_node":0, "data":{"rel_type":"brother"}},
+                   {"id":3, "start_node":0, "end_node":2, "data":{"rel_type":"brother"}}]
+        graph = new Graph(nodeData, relData)
+        node = graph.load(0)
+
+      it 'has incoming relationships', ->
+        expect(node.incoming()[0].type).toEqual("brother")
+
+      it 'has outgoing relationships', ->
+        expect(node.outgoing()[0].type).toEqual("friend")
+
+      it 'has incoming relationships of certain type', ->
+        expect(node.incoming(["foo"]).length).toEqual(0)
+        expect(node.incoming(["brother"]).length).toEqual(1)
+
+      it 'has outgoing relationships of certain type', ->
+        expect(node.outgoing(["foo"]).length).toEqual(0)
+        expect(node.outgoing(["friend", "brother"]).length).toEqual(2)
+
+    describe 'Connectivity', ->
+
+      graph = null
+
+      beforeEach ->
+        nodeData = [{"id":0},{"id":1}]
+        relData = [{"id":0, "start_node":0, "end_node":1, "data":{"rel_type":"networks"}}]
+        graph = new Graph(nodeData, relData)
+
+      it 'knows two neighbors are connected', ->
+        expect(graph.areConnected(graph.load(0), graph.load(1))).toEqual(true)
+
+      it 'only considers active relations', ->
+        expect(graph.areConnected(graph.load(0), graph.load(1), [])).toEqual(false)
+
+      it 'knows circular triplet is connected when one relationship is inactive', ->
+        # n0-----<-----n2
+        #  \-->--n1->--/
+        nodeData = [{"id":0},{"id":1},{"id":2}]
+        relData = [{"id":0, "start_node":0, "end_node":1, "data":{"rel_type":""}},
+                   {"id":1, "start_node":1, "end_node":2, "data":{"rel_type":""}},
+                   {"id":2, "start_node":2, "end_node":0, "data":{"rel_type":""}}]
+        graph = new Graph(nodeData, relData)
+
+        # deactivate connection between n0 and n1:
+        activeRels = graph.relationships[1..2]
+
+        expect(graph.areConnected(graph.load(1), graph.load(0), activeRels)).toEqual(true)
+
+      it 'knows a 6 node mesh is connected when one relationship is inactive', ->
+        nodeData = [{"id":0},{"id":1},{"id":2},{"id":3},{"id":4},{"id":5}]
+        relData = [{"id":0, "start_node":0, "end_node":1, "data":{"rel_type":""}},
+                   {"id":1, "start_node":1, "end_node":2, "data":{"rel_type":""}},
+                   {"id":2, "start_node":2, "end_node":3, "data":{"rel_type":""}},
+                   {"id":3, "start_node":3, "end_node":0, "data":{"rel_type":""}},
+                   {"id":4, "start_node":3, "end_node":4, "data":{"rel_type":""}},
+                   {"id":5, "start_node":4, "end_node":5, "data":{"rel_type":""}},
+                   {"id":6, "start_node":5, "end_node":0, "data":{"rel_type":""}}]
+        graph = new Graph(nodeData, relData)
+
+        # deactivate connection between n0 and n5:
+        activeRels = graph.relationships[0..5]
+        console.dir activeRels
+        expect(graph.areConnected(graph.load(0), graph.load(5), activeRels)).toEqual(true)
+

data/spec/neo_viz_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Neo::Viz::App do
+
+  def app
+    Neo::Viz::App
+  end
+
+  specify "get / should return OK" do
+    get '/'
+    last_response.should be_redirect
+  end
+
+  specify 'get /node-count should return number of nodes' do
+    get '/node-count'
+    last_response.body.should == '155'
+  end
+
+  context 'get /nodes/0' do
+    before do
+      get '/nodes/0'
+    end
+
+    let(:body) { last_response.body }
+
+    it 'should return the root node' do
+      body.should struct_match({
+        :nodes => [
+          { :id => 0, :data => {} },
+          { :id => 5, :data => {} },
+          { :id => 1, :data => {} },
+          { :id => 2, :data => {} },
+          { :id => 6, :data => {} },
+          { :id => 4, :data => {} },
+          { :id => 3, :data => {} }
+        ],
+        :rels => [
+          {:id => 4, :start_node => 0, :end_node => 5, :data => { :rel_type => 'BirdiesBackend::User'}},
+          {},
+          {},
+          {},
+          {},
+          {:id => 2, :start_node => 0, :end_node => 3, :data => { :rel_type => 'BirdiesBackend::Tag'}}
+        ]
+      })
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/..'
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'rack/test'
+require 'support/struct_matcher'
+require 'neo-viz'
+
+
+class Neo::Viz::App
+  set :environment, :test
+end
+
+RSpec.configure do |c|
+  c.include Rack::Test::Methods
+  c.mock_with :rspec
+  c.include Matchers
+end

data/spec/support/struct_matcher.rb

@@ -0,0 +1,117 @@
+require 'json'
+
+module Matchers
+  # Compares two structures
+  #
+  # If the actual structure is a String it will be converted with JSON.parse
+  # If the expected structure is
+  # A Hash is compared by:
+  # * If the expected value of a key is nil, it must not be present in the actual
+  # * If the expected key is missing, it is allowed in the actual
+  # * Otherwise, the values are compared as if they were structures themselves.
+  # An Array is compared by:
+  # * If the expected value is an empty array, any actual is OK
+  # * Otherwise, the lengths AND the values are compared
+  # A Regexp is compare by =~
+  # All other values are compare by ==
+  #
+  class StructMatcher
+
+    def initialize(expected)
+      @expected = expected
+      @errors = []
+    end
+
+    def matches?(actual)
+      if actual.kind_of? String
+        @actual = JSON.parse(actual)
+      else
+        @actual = actual
+      end
+      match_struct(@expected, @actual, '')
+      @errors.size == 0
+    end
+
+    def match_struct(expected, actual, prop)
+      if expected.kind_of? Hash
+        match_hash(expected, actual, prop)
+      elsif expected.kind_of? Array
+        match_array(expected, actual, prop)
+      elsif expected.kind_of? Regexp
+        match_regexp(expected, actual, prop)
+      elsif expected.kind_of? Class
+        match_class(expected, actual, prop)
+      else
+        match_equals(expected, actual, prop)
+      end
+    end
+
+    def match_hash(expected, actual, prop)
+      unless actual.kind_of? Hash
+        @errors << "(#{prop}) expected Hash, actual #{actual.class}"
+        return
+      end
+      expected.each do |expected_key, expected_value|
+        if expected_value.nil? #value nil means that the key should not exist
+          if actual.has_key? expected_key or actual.has_key? expected_key.to_s
+            @errors << "(#{prop}) expected #{expected_key} to not exists: #{actual[expected_key]}"
+            next
+          end
+        else
+          unless actual.has_key? expected_key or actual.has_key? expected_key.to_s
+            @errors << "(#{prop}) expected #{expected_key} to exists"
+            next
+          end
+          actual_value = actual[expected_key.to_s]
+          match_struct(expected_value, actual_value, "#{prop}-#{expected_key}")
+        end
+      end
+    end
+
+
+    def match_array(expected, actual, prop)
+      unless actual.kind_of? Array
+        @errors << "(#{prop}) expected Array, actual #{actual.class}"
+        return
+      end
+      if actual.size != expected.size and expected.size > 0
+        @errors << "(#{prop}) expected size #{expected.size}, actual #{actual.size}"
+      end
+      min = [actual.size, expected.size].min
+      (0...min).each do |i|
+        match_struct(expected[i], actual[i], "#{prop}[#{i}]")
+      end
+    end
+
+    def match_regexp(expected, actual, prop)
+      unless actual.respond_to? :=~
+        @errors << "(#{prop}) cannot be matched with =~: expected #{expected.inspect}, actual #{actual.inspect}"
+        return
+      end
+      unless actual =~ expected
+        @errors << "(#{prop}) no match: expected #{expected.inspect}, actual #{actual.inspect}"
+      end
+    end
+
+    def match_equals(expected, actual, prop)
+      unless actual == expected
+        @errors << "(#{prop}) not equal: expected #{expected.inspect}, actual #{actual.inspect}"
+      end
+    end
+
+    def match_class(expected, actual, prop)
+      unless actual.kind_of? expected
+        @errors << "(#{prop}) not a kind of: expected #{expected.inspect}, actual #{actual.class.inspect}"
+      end
+    end
+
+    def failure_message_for_should
+      "expected\n#{@actual.inspect}\nto match\n#{@expected.inspect}\nerrors\n#{@errors.join(%{\n})}"
+    end
+  end
+
+  def struct_match(expected)
+    StructMatcher.new(expected)
+  end
+
+end