urbit-api 0.1.2 → 0.2.0

data/lib/urbit/graph.rb

@@ -0,0 +1,142 @@
+require 'set'
+require 'urbit/node'
+require 'urbit/parser'
+
+module Urbit
+  class Graph
+    attr_reader :host_ship_name, :name, :ship
+
+    def initialize(ship:, graph_name:, host_ship_name:)
+      @ship           = ship
+      @name           = graph_name
+      @host_ship_name = host_ship_name
+      @nodes          = SortedSet.new
+    end
+
+    def add_node(node:)
+      @nodes << node
+    end
+
+    def host_ship
+      "~#{@host_ship_name}"
+    end
+
+    #
+    # This method doesn't have a json mark and thus is not (yet) callable from the Airlock.
+    # Answers a %noun in `(unit mark)` format.
+    #
+    # def mark
+    #   r = self.ship.scry(app: 'graph-store', path: "/graph/#{self.to_s}/mark")
+    # end
+
+    #
+    # Finds a single node in this graph by its index.
+    # The index here should be the atom representation (as returned by Node#index).
+    #
+    def node(index:)
+      self.fetch_node(index).first
+    end
+
+    #
+    # Answers an array with all of this Graph's currently attached Nodes, recursively
+    # inluding all of the Node's children.
+    #
+    def nodes
+      self.fetch_all_nodes if @nodes.empty?
+      @all_n = []
+      @nodes.each do |n|
+        @all_n << n
+        n.children.each do |c|
+          @all_n << c
+        end
+      end
+      @all_n
+    end
+
+    def newest_nodes(count: 10)
+      count = 1 if count < 1
+      return self.fetch_newest_nodes(count) if @nodes.empty? || @nodes.count < count
+      self.nodes.reverse[0..(count - 1)]
+    end
+
+    def oldest_nodes(count: 10)
+      count = 1 if count < 1
+      return self.fetch_oldest_nodes(count) if @nodes.empty? || @nodes.count < count
+      self.nodes[0..(count - 1)]
+    end
+
+    def resource
+      "#{self.host_ship}/#{self.name}"
+    end
+
+    #
+    # Answers the {count} newer sibling nodes relative to the passed {node}.
+    #
+    def newer_sibling_nodes(node:, count:)
+      self.fetch_sibling_nodes(node, :newer, count)[0..(count - 1)]
+    end
+
+    #
+    # Answers the {count} older sibling nodes relative to the passed {node}.
+    #
+    def older_sibling_nodes(node:, count:)
+      self.fetch_sibling_nodes(node, :older, count)[0..(count - 1)]
+    end
+
+    #
+    # the canonical printed representation of a Graph
+    def to_s
+      "a Graph(#{self.resource})"
+    end
+
+    private
+
+    def fetch_all_nodes
+      self.fetch_nodes("#{self.graph_resource}/",
+                       AddGraphParser,
+                       "add-graph")
+    end
+
+    def fetch_newest_nodes(count)
+      self.fetch_nodes("#{self.graph_resource}/node/siblings/newest/kith/#{count}/",
+                       AddNodesParser,
+                       "add-nodes")
+    end
+
+    def fetch_node(index_atom)
+      self.fetch_nodes("#{self.graph_resource}/node/index/kith/#{index_atom}/",
+                       AddNodesParser,
+                       "add-nodes")
+    end
+
+    def fetch_oldest_nodes(count)
+      self.fetch_nodes("#{self.graph_resource}/node/siblings/oldest/kith/#{count}/",
+                       AddNodesParser,
+                       "add-nodes")
+    end
+
+    def fetch_sibling_nodes(node, direction, count)
+      self.fetch_nodes("#{self.graph_resource}/node/siblings/#{direction}/kith/#{count}/#{node.index}/",
+                       AddNodesParser,
+                       "add-nodes")
+    end
+
+    #
+    # Answers an array of Nodes that were fetched or an empty array if nothing found.
+    #
+    def fetch_nodes(endpoint, parser, node)
+      r = self.ship.scry(app: 'graph-store', path: endpoint)
+      if (200 == r[:status])
+        body = JSON.parse(r[:body])
+        if (p = parser.new(for_graph: self, with_json: body["graph-update"][node]))
+          return p.add_nodes
+        end
+      end
+      []
+    end
+
+    def graph_resource
+      "/graph/#{self.resource}"
+    end
+  end
+end

data/lib/urbit/message.rb

@@ -1,18 +1,24 @@
 require 'faraday'
-require 'json'
 
 module Urbit
   class Message
     attr_accessor :id
-    attr_reader :action, :app, :channel, :json, :mark
+    attr_reader :app, :channel, :contents, :mark
 
-    def initialize(channel, action, app = nil, mark = nil, json = nil)
-      @action  = action
-      @app     = app
-      @channel = channel
-      @id      = 0
-      @json    = json
-      @mark    = mark
+    def initialize(channel:, app: nil, mark: nil, contents: nil)
+      @app      = app
+      @channel  = channel
+      @contents = contents
+      @id       = 0
+      @mark     = mark
+    end
+
+    #
+    # The value for "action" that the inbound API expects for this message type.
+    # defaults to "poke" for historical reasons, but each subclass should override appropriately.
+    #
+    def action
+      "poke"
     end
 
     def channel_url
@@ -33,10 +39,10 @@ module Urbit
 
     def to_h
       {
-        action: action,
+        action: self.action,
         app:    app,
         id:     id,
-        json:   json,
+        json:   contents,
         mark:   mark,
         ship:   ship.untilded_name
       }
@@ -51,7 +57,6 @@ module Urbit
         req.headers['Cookie'] = self.ship.cookie
         req.headers['Content-Type'] = 'application/json'
         req.body = request_body
-        # puts req.body.to_s
       end
 
       # TODO: handle_error if response.status != 204

data/lib/urbit/node.rb

@@ -0,0 +1,112 @@
+require 'set'
+
+module Urbit
+  class Node
+    attr_accessor :node_json
+    def initialize(graph:, node_json:)
+      @graph      = graph
+      @post_h     = node_json['post']
+      @children_h = node_json['children']
+      @persistent = false
+      @index      = nil
+    end
+
+    def ==(another_node)
+      another_node.raw_index == self.raw_index
+    end
+
+    def <=>(another_node)
+      self.time_sent <=> another_node.time_sent
+    end
+
+    def eql?(another_node)
+      another_node.raw_index == self.raw_index
+    end
+
+    def hash
+      self.raw_index.hash
+    end
+
+    def author
+      @post_h["author"]
+    end
+
+    def children
+      @children = SortedSet.new
+      if @children_h
+        @children_h.each do |k, v|
+          @children << (n = Urbit::Node.new(graph: @graph, node_json: v))
+          # Recursively fetch all the children's children until we reach the bottom...
+          n.children.each {|c| @children << c} if !n.children.empty?
+        end
+      end
+      @children
+    end
+
+    def contents
+      @post_h['contents']
+    end
+
+    def persistent?
+      @persistent
+    end
+
+    #
+    # Answers the memoized @index or calculates it from the raw_index.
+    #
+    def index
+      return @index if @index
+      @index = self.index_to_atom
+    end
+
+    #
+    # Answers the next {count} Nodes relative to this Node.
+    # Defaults to the next Node if no {count} is passed.
+    #
+    def next(count: 1)
+      @graph.newer_sibling_nodes(node: self, count: count)
+    end
+
+    #
+    # Answers the previous {count} Nodes relative to this Node.
+    # Defaults to the next Node if no {count} is passed.
+    #
+    def previous(count: 1)
+      @graph.older_sibling_nodes(node: self, count: count)
+    end
+
+    def raw_index
+      @post_h["index"].delete_prefix('/')
+    end
+
+    def time_sent
+      @post_h['time-sent']
+    end
+
+    def to_h
+      {
+        index: self.index,
+        author: self.author,
+        contents: self.contents,
+        time_sent: self.time_sent,
+        is_parent: !self.children.empty?,
+        child_count: self.children.count
+      }
+    end
+
+    def to_s
+      "a Node(#{self.to_h})"
+    end
+
+    private
+
+    def index_to_atom
+      subkeys = self.raw_index.split("/")
+      subatoms = []
+      subkeys.each do |s|
+        subatoms << s.reverse.scan(/.{1,3}/).join('.').reverse
+      end
+      subatoms.join('/')
+    end
+  end
+end

data/lib/urbit/parser.rb

@@ -0,0 +1,48 @@
+require 'set'
+require 'urbit/node'
+
+module Urbit
+  class Parser
+    def initialize(for_graph:, with_json:)
+      @g = for_graph
+      @j = with_json
+    end
+
+    #
+    # Parses the embedded json and adds any found nodes to the graph.
+    # Answers an array of nodes.
+    #
+    def add_nodes
+      added_nodes = []
+      # Make sure we are adding to the correct graph...
+      if (@g.resource == self.resource)
+        self.nodes_hash.each do |k, v|
+          added_nodes << (n = Urbit::Node.new(graph: @g, node_json: v))
+          @g.add_node(node: n)
+        end
+      end
+      added_nodes
+    end
+
+    def resource
+      "~#{self.resource_hash["ship"]}/#{self.resource_hash["name"]}"
+    end
+
+    def resource_hash
+      @j["resource"]
+    end
+  end
+
+  class AddGraphParser < Parser
+    def nodes_hash
+      @j["graph"]
+    end
+
+  end
+
+  class AddNodesParser < Parser
+    def nodes_hash
+      @j["nodes"]
+    end
+  end
+end

data/lib/urbit/poke_message.rb

@@ -1,7 +1,7 @@
 module Urbit
   class PokeMessage < Message
-    def initialize(channel, app, mark, a_string)
-      super(channel, 'poke', app, mark, a_string)
+    def initialize(channel:, app:, mark:, a_string:)
+      super(channel: channel, app: app, mark: mark, contents: a_string)
     end
   end
 end

data/lib/urbit/receiver.rb

@@ -1,27 +1,47 @@
 require 'ld-eventsource'
 
 require 'urbit/ack_message'
+require 'urbit/fact'
 
 module Urbit
   class Receiver < SSE::Client
     attr_accessor :facts
 
-    def initialize(channel)
+    def initialize(channel:)
       @facts = []
-      @headers = {'cookie' => channel.ship.cookie}
-      super(channel.url, {headers: @headers}) do |rec|
+      super(channel.url, {headers: self.headers(channel)}) do |rec|
+        # We are now listening on a socket for SSE::Events. This block will be called for each one.
         rec.on_event do |event|
-          typ = event.type
-          dat = JSON.parse(event.data)
-          self.facts << {typ => dat}
-          channel.send_message(AckMessage.new(channel, event.id))
+          # Wrap the returned event in a Fact.
+          @facts << (f = Fact.new(channel: channel, event: event))
+
+          # We need to acknowlege each message or urbit will eventually disconnect us.
+          # We record the ack with the Fact itself.
+          f.add_ack(ack: (ack = AckMessage.new(channel: channel, sse_message_id: event.id)))
+          channel.send(message: ack)
         end
 
         rec.on_error do |error|
           self.facts += ["I received an error fact: #{error.class}"]
         end
       end
+      @is_open = true
+    end
+
+    def open?
+      @is_open
     end
 
+    private
+
+    def headers(channel)
+      {
+        "Accept"        => "text/event-stream",
+        "Cache-Control" => "no-cache",
+        'Cookie'        => channel.ship.cookie,
+        "Connection"    => "keep-alive",
+        "User-Agent"    => "urbit-ruby"
+      }
+    end
   end
 end

data/lib/urbit/ship.rb

@@ -2,6 +2,7 @@ require 'faraday'
 
 require 'urbit/channel'
 require 'urbit/config'
+require 'urbit/graph'
 
 module Urbit
   class Ship
@@ -12,6 +13,7 @@ module Urbit
       @auth_cookie = nil
       @channels    = []
       @config      = config
+      @graphs      = []
       @logged_in   = false
     end
 
@@ -27,6 +29,37 @@ module Urbit
       auth_cookie
     end
 
+    def graph(resource:)
+      self.graphs.find {|g| g.resource == resource}
+    end
+
+    #
+    # Answers a collection of all the top-level graphs on this ship.
+    # This collection is cached and will need to be invalidated to discover new graphs.
+    #
+    def graphs(flush_cache: false)
+      @graphs = [] if flush_cache
+      if @graphs.empty?
+        if self.logged_in?
+          r = self.scry(app: 'graph-store', path: '/keys')
+          if r[:body]
+            body = JSON.parse r[:body]
+            body["graph-update"]["keys"].each do |k|
+              @graphs << Graph.new(ship: self, graph_name: k["name"], host_ship_name: k["ship"])
+            end
+          end
+        end
+      end
+      @graphs
+    end
+
+    #
+    # A helper method to just print out the descriptive names of all the ship's graphs.
+    #
+    def graph_names
+      self.graphs.collect {|g| g.resource}
+    end
+
     def login
       return self if logged_in?
 
@@ -40,6 +73,23 @@ module Urbit
       config.name
     end
 
+    def remove_graph(graph:)
+      delete_json = %Q({
+        "delete": {
+          "resource": {
+            "ship": "#{self.name}",
+            "name": "#{graph.name}"
+          }
+        }
+      })
+
+      spider = self.spider(mark_in: 'graph-view-action', mark_out: 'json', thread: 'graph-delete', data: delete_json, args: ["NO_RESPONSE"])
+      if (retcode = (200 == spider[:status]))
+        self.graphs.delete graph
+      end
+      retcode
+    end
+
     def untilded_name
       name.gsub('~', '')
     end
@@ -52,9 +102,20 @@ module Urbit
       @channels.select {|c| c.open?}
     end
 
-    def scry(app, path, mark)
+    #
+    # Poke an app with a message using a mark.
+    #
+    # Returns a Channel which has been created and opened and will begin
+    #   to get back a stream of facts via its Receiver.
+    #
+    def poke(app:, mark:, message:)
+      (self.add_channel).poke(app: app, mark: mark, message: message)
+    end
+
+    def scry(app:, path:, mark: 'json')
       self.login
-      scry_url = "#{self.config.api_base_url}/~/scry/#{app}#{path}.#{mark}"
+      mark = ".#{mark}" unless mark.empty?
+      scry_url = "#{self.config.api_base_url}/~/scry/#{app}#{path}#{mark}"
 
       response = Faraday.get(scry_url) do |req|
         req.headers['Accept'] = 'application/json'
@@ -64,10 +125,29 @@ module Urbit
       {status: response.status, code: response.reason_phrase, body: response.body}
     end
 
-    def spider(mark_in, mark_out, thread, data)
+    def spider(mark_in:, mark_out:, thread:, data:, args: [])
       self.login
       url = "#{self.config.api_base_url}/spider/#{mark_in}/#{thread}/#{mark_out}.json"
 
+      # TODO: This is a huge hack due to the fact that certain spider operations are known to
+      #       not return when they should. Instead I just set the timeout low and catch the
+      #       error and act like everything is ok.
+      if args.include?("NO_RESPONSE")
+        conn = Faraday::Connection.new()
+        conn.options.timeout = 1
+        conn.options.open_timeout = 1
+
+        begin
+          response = conn.post(url) do |req|
+            req.headers['Accept'] = 'application/json'
+            req.headers['Cookie'] = self.cookie
+            req.body = data
+          end
+        rescue Faraday::TimeoutError
+          return {status: 200, code: "ok", body: "null"}
+        end
+      end
+
       response = Faraday.post(url) do |req|
         req.headers['Accept'] = 'application/json'
         req.headers['Cookie'] = self.cookie
@@ -79,21 +159,30 @@ module Urbit
 
     #
     # Subscribe to an app at a path.
-    # Returns a Receiver which will begin to get back a stream of facts... which is a... Dictionary? Encyclopedia?
     #
-    def subscribe(app, path)
-      self.login
-      (c = Channel.new self, self.make_channel_name).open("Creating a Subscription Channel.")
-      self.channels << c
-      c.subscribe(app, path)
+    # Returns a Channel which has been created and opened and will begin
+    #   to get back a stream of facts via its Receiver.
+    #
+    def subscribe(app:, path:)
+      (self.add_channel).subscribe(app: app, path: path)
+    end
+
+    def to_h
+      {name: "#{self.pat_p}", host: "#{self.config.host}", port: "#{self.config.port}"}
     end
 
     def to_s
-      "a Ship(name: '#{self.pat_p}', host: '#{self.config.host}', port: '#{self.config.port}')"
+      "a Ship(#{self.to_h})"
     end
 
     private
 
+    def add_channel
+      self.login
+      self.channels << (c = Channel.new(ship: self, name: self.make_channel_name))
+      c
+    end
+
     def make_channel_name
       "Channel-#{self.open_channels.count}"
     end