wewoo 0.1.5

data/lib/wewoo/graph.rb

@@ -0,0 +1,233 @@
+require 'typhoeus'
+require 'json'
+require 'map'
+require 'wewoo/adapter'
+
+module Wewoo
+  class Graph
+    include Adapter
+
+    class UnknownGraphError         < RuntimeError; end
+    class GraphElementNotFoundError < RuntimeError; end
+
+    attr_reader :url, :name
+
+    def self.available_graphs
+      res = Adapter::get( "#{Configuration.url}/graphs" )
+      res.graphs
+    end
+
+    def initialize( graph_name, host:nil, port:nil )
+      Configuration.url( host, port )
+
+      @name     = graph_name
+      @base_url = "#{Configuration.url}/graphs"
+      @url      = "#{@base_url}/#{@name}"
+      validate
+    end
+
+    def save( filename )
+      dir = File.dirname( filename )
+      FileUtils.mkdir_p( dir ) unless File.exists?( dir )
+
+      q( "g.saveGraphML( '#{filename}' )" )
+    end
+
+    def load( filename, append:false )
+      raise "Graph file does not exist. #{filename}" unless File.exists?(filename)
+
+      clear unless append
+      q( "g.loadGraphML( '#{filename}' )" )
+    end
+
+    def clear
+      query( 'g.V.remove()')
+    end
+
+    def key_indices
+      Map[ *get( u(:keyindices ) ).flatten]
+    end
+
+    def set_key_index( type, key )
+      post( u( %W[keyindices #{type} #{key}] ) )
+    end
+
+    def drop_index( index_name )
+      delete( u( %W[indices #{index_name}] ) )
+    end
+
+    def ensure_index( key, type=:vertex )
+      unless key_indices[type.to_s].include? key.to_s
+        post( u( %W[keyindices #{type} #{key}] ) )
+      end
+    end
+
+    def index( index_name, clazz:'vertex', options:{} )
+      post( u(%W[indices #{index_name}]), params: {class: clazz}.merge(options))
+    end
+
+    def query( command, page:nil, per_page:nil )
+      # command = "g." + command unless command[/\Ag\./]
+      ResultSet.new( self, get( u(%w[tp gremlin]),
+           params:{script: command}.merge(page_params(page, per_page)),
+           headers: { 'Content-Type'=> 'application/json'} ) ).hydrate
+    end
+    alias :q :query
+
+    def add_vertex( props={} )
+      vertex = Vertex.from_hash( self,
+                                 post( u( %W[vertices] ) ) )
+      update_vertex( vertex.id, props )
+    end
+
+    # BOZO!! - not really an update as all props will be replaced!
+    def update_vertex( id, props )
+      v = find_vertex( id )
+      props = v.props.merge( props )
+      res = put( u( %W[vertices #{id}] ),
+            body:    props.to_json,
+            headers: { 'Content-Type'=> 'application/json'} )
+      Vertex.from_hash( self, res )
+    end
+
+    def vertices( page:nil, per_page:nil )
+      get( u(:vertices), {params: page_params(page, per_page)} ).map do |res|
+        Vertex.from_hash( self, res )
+      end
+    end
+    alias :V :vertices
+
+    def find_vertices( key, value, page:nil, per_page:nil )
+      params = { key: key, value: map_value(value) }.merge page_params( page, per_page )
+      res    = get( u(:vertices), params:  params )
+
+      res.map do |res|
+        Vertex.from_hash( self, res )
+      end
+    end
+    def find_first_vertex( key, value )
+      find_vertices( key, value ).first
+    end
+    def find_vertex_by_gid( gid )
+      find_first_vertex( :gid, gid )
+    end
+    def find_vertex( id )
+      Vertex.from_hash( self, get( u %W[vertices #{id}] ) )
+    rescue InvalidRequestError => ex
+      raise GraphElementNotFoundError, ex.message
+    end
+    alias :v :find_vertex
+
+    def vertex_exists?( id )
+      v(id) && true
+    rescue
+      false
+    end
+
+    def edge_exists?( id )
+      e(id) && true
+      true
+    rescue
+      false
+    end
+
+    def remove_vertex( id )
+      delete( u(%W[vertices #{id}] ) )
+    end
+
+    def update_edge( id, props )
+      e     = find_edge( id )
+      props = e.props.merge( props )
+
+      res = put( u( %W[edges #{id}] ),
+            body: props.to_json,
+            headers: { 'Content-Type'=> 'application/json'} )
+      Edge.from_hash( self, res )
+    end
+
+    def add_edge( from, to, label, props={} )
+      params = {
+        '_outV'  => (from.is_a? Vertex) ? from.id : from,
+        '_inV'   => (to.is_a? Vertex) ? to.id : to,
+        '_label' => label
+      }.merge( props )
+      res = post( u( %W[edges] ),
+            body: params.to_json,
+            headers: { 'Content-Type'=> 'application/json'} )
+      Edge.from_hash( self, res )
+    end
+
+    def remove_edge( id )
+      delete( u %W[edges #{id}] )
+    end
+
+    def find_edge( id )
+      Edge.from_hash( self, get( u %W[edges #{id}] ) )
+    rescue InvalidRequestError => ex
+      raise GraphElementNotFoundError, ex.message
+    end
+    alias :e :find_edge
+
+    def find_edges( key, value, page:nil, per_page:nil )
+      params = { key: key,
+                 value: map_value( value )
+      }.merge page_params( page, per_page )
+      get( u(:edges), params: params ).map { |e| Edge.from_hash( self, e ) }
+    end
+
+    def find_first_edge( key, value )
+      find_edges( key, value, page:1, per_page:1 ).first
+    end
+
+    def edges( page:nil, per_page:nil )
+      get( u(:edges), params: page_params(page, per_page) ).map do |res|
+        Edge.from_hash( self, res )
+      end
+    end
+    alias :E :edges
+
+    def to_s
+      res = get( url, headers: { 'Content-Type' =>
+                                 'application/vnd.rexster-typed-v1+json' } )
+      stats = res.graph.match( /.*\[vertices:(\d+) edges:(\d+)\]/ ).captures
+
+      "#{name} [Vertices:#{stats.first}, Edges:#{stats.last}]"
+    end
+    alias inspect to_s
+
+    private
+
+    def map_value( value )
+      case value
+        when TrueClass
+        when FalseClass
+          "(b,#{value})"
+        when Fixnum
+          "(i,#{value})"
+        when Float
+          "(d,#{value})"
+      else
+        value
+      end
+    end
+
+    def u( path )
+      File.join( url, ((path.is_a? Array) ? path : path.to_s ) )
+    end
+
+    def validate
+      res = get( @base_url )
+
+      unless res.graphs.include?( @name.to_s )
+        raise UnknownGraphError, "Unable to locate graph named `#{@name}"
+      end
+    end
+
+    def page_params( page, per_page )
+      return {} unless page and per_page
+
+      { 'rexster.offset.start' => (page-1)*per_page,
+        'rexster.offset.end'   => page*per_page }
+    end
+  end
+end

data/lib/wewoo/result_set.rb

@@ -0,0 +1,99 @@
+# BOZO !! Refactor
+module Wewoo
+  class ResultSet
+
+    class NoGraphElementError < RuntimeError; end
+
+    def initialize( graph, results )
+      @results = results
+      @graph   = graph
+    end
+
+    def hydrate
+      collapse( _hydrate( @results ) )
+    end
+
+    def graph_element?( item )
+      item.is_a? Hash    and
+      item.key?('_type') and
+      %w(vertex edge).include? item['_type']
+    end
+
+    def build_element( item )
+      type = item['_type']
+      Object.const_get( "Wewoo::#{type.capitalize}" )
+            .from_hash( @graph, item )
+    rescue => boom
+      raise NoGraphElementError, "Unbuildable"
+    end
+
+    private
+
+    def collapse( res )
+      (res.is_a? Enumerable and
+       res.count == 1 and
+       res.first.is_a? Enumerable) ? res.first : res
+    end
+
+    def usable( item )
+      graph_element?( item ) ? build_element( item ) : item
+    end
+
+    def value_hash?( hash )
+      hash.values.first.is_a? Hash
+    end
+
+    def simple_response?( res )
+      res.is_a? Hash and res.key?('success')
+    end
+
+    def key_value_hash?( res )
+      res.is_a? Hash and res.key?('_key') and res.key?('_value')
+    end
+
+    def _deep_hydrate( item, acc )
+      if graph_element?( item )
+        acc << build_element( item )
+      elsif item.is_a? Array
+        tuples = []
+        item.each do |row|
+          _deep_hydrate( row, tuples )
+        end
+        acc << tuples
+      elsif item.is_a? Hash
+        if key_value_hash?( item )
+          key = usable(item['_key'])
+          if item['_value'].is_a? Enumerable
+            acc[key] = []
+            item['_value'].each do |row|
+              acc[key] << usable(row)
+            end
+          else
+            acc[key] = usable(item['_value'])
+          end
+        elsif item.values.first.is_a? Hash
+          res = {}
+          item.values.each do |item|
+            _deep_hydrate( item, res )
+          end
+          acc << res
+        else
+          acc << item
+        end
+      else
+        acc << item
+      end
+    end
+
+    def _hydrate( res )
+      return res['success'] if simple_response?( res )
+      if res.is_a? Array
+        acc = []
+        res.each{ |row| _deep_hydrate( row, acc ) }
+        acc
+      else
+        raise "Unexpected match!!"
+      end
+    end
+  end
+end

data/lib/wewoo/version.rb

@@ -0,0 +1,3 @@
+module Wewoo
+  VERSION = "0.1.5"
+end

data/lib/wewoo/vertex.rb

@@ -0,0 +1,63 @@
+module Wewoo
+  # BOZO !! Need to support chaining!
+  class Vertex < Wewoo::Element
+    include Adapter
+
+    def outE ( *labels ); @outE  || get_edges( :outE , labels ); end
+    def inE  ( *labels ); @inE   || get_edges( :inE  , labels ); end
+    def bothE( *labels ); @bothE || get_edges( :bothE, labels ); end
+
+    def out ( *labels ); @out  || get_vertices( :out , labels ); end
+    def in  ( *labels ); @in   || get_vertices( :in  , labels ); end
+    def both( *labels ); @both || get_vertices( :both, labels ); end
+
+    def ==( o )
+      self.class == o.class and self.id == o.id and self.props == o.props
+    end
+    alias :eql? :==
+    def hash; id; end
+    def <=>(o); self.class == o.class ? self.id <=> o.id : super; end
+
+    def destroy
+      graph.remove_vertex( id )
+    end
+
+    def to_s
+     "v(#{self.id})"
+    end
+    alias :inspect :to_s
+
+    def dump
+      props.clone().merge( id: id )
+    end
+
+    private
+
+    def get_edges( direction, labels )
+      str_labels = labels ? labels.map(&:to_s) : []
+      get( u direction ).map { |hash|
+        if labels.empty? or str_labels.include? hash['_label']
+          Edge.from_hash( graph, hash )
+        end
+      }.compact
+    end
+
+    def get_vertices( direction, labels=[] )
+      get_edges( "#{direction}E",labels ).map{ |e|
+        if direction == :both
+          e.in == self ? e.out : e.in
+        else
+          e.get_vertex( direction==:in ? :out : :in )
+        end
+      }
+    end
+
+    def self.from_hash( graph, hash )
+      new( graph, hash.delete('_id'), Map( hash ) )
+    end
+
+    def u( path )
+      File.join( graph.url, %W[vertices #{id} #{path}] )
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'simplecov'
+if ENV['COV']
+  SimpleCov.start do
+  end
+end
+
+require 'wewoo'
+require 'support/graph_sets'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.filter_run                                      focus: true
+  config.run_all_when_everything_filtered                = true
+end

data/spec/support/graph_sets.rb

@@ -0,0 +1,33 @@
+def build_test_graph( g )
+  g.clear
+
+  @v1 = g.add_vertex( gid: 1  , name:'fred', age:20, rating: 30.5, busy: true )
+  @v2 = g.add_vertex( gid: 2  , name:'joe' , age:30, rating: 20.5, busy: false )
+  @v3 = g.add_vertex( gid: 3  , name:'max' , age:40, rating: 10.5, busy: true )
+  @v4 = g.add_vertex( gid: "4", name:'blee', age:50, rating: 5.5 , busy: true )
+
+  @e1 = g.add_edge( @v1, @v2, :friend, rating: 1.5 )
+  @e2 = g.add_edge( @v1, @v3, :friend, rating: 2.5 )
+  @e3 = g.add_edge( @v1, @v4, :love  , rating: 3.5 )
+  @e4 = g.add_edge( @v2, @v3, :friend, rating: 5.5 )
+  @e5 = g.add_edge( @v3, @v4, :friend, rating: 5.5 )
+end
+
+def build_sample_graph( g )
+  g.clear
+  #g.ensure_index(:name,:vertex)
+
+  @v1 = g.add_vertex( name: :marko , age: 29 )
+  @v2 = g.add_vertex( name: :vadas , age: 27 )
+  @v3 = g.add_vertex( name: :lop   , lang: :java )
+  @v4 = g.add_vertex( name: :josh  , age: 32 )
+  @v5 = g.add_vertex( name: :ripple, lang: :java )
+  @v6 = g.add_vertex( name: :peter , age: 35 )
+
+  @e7  = g.add_edge( @v1, @v2, :knows  , weight: 0.5 )
+  @e8  = g.add_edge( @v1, @v4, :knows  , weight: 1.0 )
+  @e9  = g.add_edge( @v1, @v3, :created, weight: 0.4 )
+  @e10 = g.add_edge( @v4, @v5, :created, weight: 1.0 )
+  @e11 = g.add_edge( @v4, @v3, :created, weight: 0.4 )
+  @e12 = g.add_edge( @v6, @v3, :created, weight: 0.2 )
+end