urbit-api 0.1.0 → 0.3.0

data/lib/urbit/graph.rb

@@ -0,0 +1,143 @@
+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 unless node.deleted?
+    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
+      last_node = self.nodes.count - 1
+      self.nodes[(last_node - count)..last_node]
+    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,17 +1,24 @@
-require 'json'
+require 'faraday'
 
 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, mark, json)
-      @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
@@ -32,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
       }
@@ -50,23 +57,10 @@ 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
       response
     end
   end
-
-  class CloseMessage < Message
-    def initialize(channel)
-      @action  = 'delete'
-      @channel = channel
-      @id      = 0
-    end
-
-    def to_h
-      {id: id, action: action}
-    end
-  end
 end

data/lib/urbit/node.rb

@@ -0,0 +1,152 @@
+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
+
+    #
+    # Given a bigint representing an urbit date, returns a unix timestamp.
+    #
+    def self.da_to_unix(da)
+      # ported from urbit lib.ts which in turn was ported from +time:enjs:format in hoon.hoon
+      da_second = 18446744073709551616
+      da_unix_epoch = 170141184475152167957503069145530368000
+      offset = da_second / 2000
+      epoch_adjusted = offset + (da - da_unix_epoch)
+      return (epoch_adjusted * 1000) / da_second
+    end
+
+    #
+    # Given a unix timestamp, returns a bigint representing an urbit date
+    #
+    def self.unix_to_da(unix)
+      da_second = 18446744073709551616
+      da_unix_epoch = 170141184475152167957503069145530368000
+      time_since_epoch =  (unix * da_second) / 1000
+      return da_unix_epoch + time_since_epoch;
+    end
+
+    def ==(another_node)
+      another_node.index == self.index
+    end
+
+    def <=>(another_node)
+      self.time_sent <=> another_node.time_sent
+    end
+
+    def eql?(another_node)
+      another_node.index == self.index
+    end
+
+    def deleted?
+      # This is a "deleted" node. Not sure what to do yet, but for now don't create a Node.
+      @post_h["index"].nil?
+    end
+
+    def hash
+      self.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 datetime_sent
+      Time.at(self.time_sent / 1000).to_datetime
+    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
+      return @post_h["index"].delete_prefix('/') unless self.deleted?
+      (Node.unix_to_da(Time.now.to_i)).to_s
+    end
+
+    #
+    # This is the time sent as recorded by urbit in unix extended format.
+    #
+    def time_sent
+      @post_h['time-sent']
+    end
+
+    def to_h
+      {
+        index: self.index,
+        author: self.author,
+        sent: self.datetime_sent,
+        contents: self.contents,
+        is_parent: !self.children.empty?,
+        child_count: self.children.count
+      }
+    end
+
+    def to_pretty_array
+      self.to_h.each.map {|k, v| "#{k}#{(' ' * (12 - k.length))}#{v}"}
+    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,62 @@
+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
+
+    def resource_hash
+      @j["resource"]
+    end
+  end
+
+  class AddNodesParser < Parser
+    def nodes_hash
+      @j["nodes"]
+    end
+  end
+
+  class RemoveGraphParser < Parser
+    def nodes_hash
+      nil
+    end
+
+    def resource_hash
+      @j["resource"]
+    end
+  end
+
+end

data/lib/urbit/poke_message.rb

@@ -0,0 +1,7 @@
+module Urbit
+  class PokeMessage < Message
+    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 :events
+    attr_accessor :facts
 
-    def initialize(channel)
-      @events = []
-      @headers = {'cookie' => channel.ship.cookie}
-      super(channel.url, {headers: @headers}) do |rec|
+    def initialize(channel:)
+      @facts = []
+      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.events << {typ => dat}
-          channel.send_message(AckMessage.new(channel, event.id))
+          # Wrap the returned event in a Fact.
+          @facts << (f = Fact.collect(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.events += ["I received an error: #{error.class}"]
+          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/setting.rb

@@ -0,0 +1,30 @@
+
+module Urbit
+  class Setting
+     attr_reader :bucket
+
+    def initialize(ship:, desk:, setting:)
+      @ship = ship
+      @desk = desk
+      @bucket = setting.first
+      @entries = setting.last
+    end
+
+    def entries(bucket: nil)
+      return @entries if (bucket.nil? || @bucket == bucket)
+      {}
+    end
+
+    def to_h
+      {
+        desk:    @desk,
+        bucket:  self.bucket,
+        entries: self.entries
+      }
+    end
+
+    def to_s
+      "a Setting(#{self.to_h})"
+    end
+  end
+end