urbit-api 0.2.0 → 0.4.0

data/lib/urbit/group.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Urbit
+  class Group
+     attr_accessor :manager, :members, :tags
+     attr_reader :hidden, :path, :policy
+
+    def initialize(path:, members:, policy:, tags:, hidden:)
+      @hidden  = hidden
+      @manager = nil
+      @members = Set.new(members)
+      @path    = path
+      @policy  = policy
+      @tags    = self.parse_tags(tags)
+    end
+
+    def ==(another_group)
+      another_group.path == self.path
+    end
+
+    def <=>(another_group)
+      self.path <=> another_group.path
+    end
+
+    #
+    # This is the action labeled as "Archive" in the Landscape UI.
+    # As of now, you can only do this to groups on your own ship.
+    #
+    def delete
+      if (self.host == self.manager.ship.name)
+        spdr = self.manager.spider('group-delete', %Q({"remove": {"ship": "#{self.host}", "name": "#{self.key}"}}))
+        self.manager.remove(self) if 200 == spdr[:status]
+        return spdr
+      end
+      {status: 400, code: 'bad_request', body: 'Can only delete Groups on your own ship.'}
+    end
+
+    def eql?(another_group)
+      another_group.path == self.path
+    end
+
+    def host
+      self.path_tokens[0]
+    end
+
+    def invite(ship_names:, message:)
+      data = %Q({
+        "invite": {
+          "resource": {
+            "ship": "#{self.host}",
+            "name": "#{self.key}"
+          },
+          "ships": [
+            "#{ship_names.join(',')}"
+          ],
+          "description": "#{message}"
+        }
+      })
+      self.manager.spider('group-invite', data)
+    end
+
+    def key
+      self.path_tokens[1]
+    end
+
+    def leave
+      spdr = self.manager.spider('group-leave', %Q({"leave": {"ship": "#{self.host}", "name": "#{self.key}"}}))
+      self.manager.remove(self) if 200 == spdr[:status]
+      spdr
+    end
+
+    def path_tokens
+      self.path.split('/')
+    end
+
+    def pending_invites
+      if (i = @policy["invite"])
+        if (p = i["pending"])
+          return p.count
+        end
+      end
+      '?'
+    end
+
+    def to_h
+    {
+        host:            self.host,
+        key:             self.key,
+        member_count:    self.members.count,
+        pending_invites: self.pending_invites,
+        hidden:          self.hidden
+      }
+    end
+
+    def to_s
+      "a Group(#{self.to_h})"
+    end
+
+    private
+
+    def parse_tags(tags)
+      h = {}
+      return h if tags.empty?
+      tags.each {|k, v| h[k] = Set.new(v)}
+      tags.replace(h)
+    end
+
+  end
+end

data/lib/urbit/group_manager.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Urbit
+  class GroupManager
+    attr_accessor :groups, :ship
+
+    def initialize(ship:)
+      @ship   = ship
+      @groups = []
+    end
+
+    #
+    # Adds a Group to this Manager's groups collection
+    #
+    def add(a_group)
+      @groups << a_group
+    end
+
+    def add_members(group_path:, ships:)
+      if (group = self.find(path: group_path))
+        group.members += ships
+      end
+    end
+
+    def add_tag(group_path:, ships:, tag:)
+      if (group = self.find(path: group_path))
+        if (group.tags.include? tag)
+          group.tags[tag] += ships
+        end
+      end
+    end
+
+    def create(name:, title:, description:)
+      self.spider('group-create', %Q({"create": {"name": "#{name}", "title": "#{title}", "description": "#{description}", "policy": {"open": {"banRanks": [], "banned": []}}}}))
+    end
+
+    def empty?
+      self.groups.empty?
+    end
+
+    #
+    # Answers the Group uniquely keyed by path:, if it exists
+    #
+    def find(path:)
+      if (g = self.groups.select {|g| g.path == path}.first)
+        g.manager = self
+        g
+      end
+    end
+
+    def first
+      g = self.groups.first
+      g.manager = self
+      g
+    end
+
+    def join(host:, name:, share_contact: false, auto_join: false)
+      data = {join: {resource: {ship: "#{host}", name: "#{name}"}, ship: "#{host}", shareContact: share_contact, app: "groups", autojoin: auto_join}}
+      self.ship.poke(app: 'group-view', mark: 'group-view-action', message: data)
+      nil
+    end
+
+    def list
+      self.groups.map {|g| g.path}.join("\n")
+    end
+
+    def remove(group)
+      @groups = self.groups.filter {|g| g != group}
+    end
+
+    def remove_members(group_path:, ships:)
+      if (group = self.find(path: group_path))
+        group.members -= ships
+      end
+    end
+
+    def remove_tag(group_path:, ships:, tag:)
+      if (group = self.find(path: group_path))
+        if (group.tags.include? tag)
+          group.tags[tag] -= ships
+        end
+      end
+    end
+
+    def load
+      if self.ship.logged_in?
+        self.ship.subscribe(app: 'group-store', path: '/groups')
+      end
+      nil
+    end
+
+    def spider(thread, data)
+      self.ship.spider(mark_in: 'group-view-action', mark_out: 'json', thread: thread, data: data)
+    end
+
+    def to_s
+      self.groups.sort.each {|g| puts g}
+    end
+  end
+end

data/lib/urbit/group_parser.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'urbit/parser'
+
+module Urbit
+
+  class GroupParser < Parser
+    def resource
+      "~#{self.resource_hash["ship"]}/#{self.resource_hash["name"]}"
+    end
+
+    def resource_hash
+      @j["resource"]
+    end
+  end
+
+  class AddGroupParser < GroupParser
+    def group
+      Urbit::Group.new(path:    self.resource,
+                       members: [],
+                       policy:  @j["policy"],
+                       tags:    [],
+                       hidden:  @j["hidden"])
+    end
+  end
+
+  class ChangeTagParser < GroupParser
+    def ships
+      @j["ships"]
+    end
+
+    def tag
+      @j["tag"]["tag"]
+    end
+  end
+
+  class ChangeMemberParser < GroupParser
+    def ships
+      @j["ships"]
+    end
+  end
+
+  class InitialGroupParser < Parser
+    def groups
+      self.group_hashes.collect {|k, v| Group.new(path:    k.sub('/ship/', ''),
+                                                  members: v["members"],
+                                                  policy:  v["policy"],
+                                                  tags:    v["tags"],
+                                                  hidden:  v["hidden"])}
+    end
+
+    def group_hashes
+      @j
+    end
+  end
+
+  class InitialGroupGroupParser < GroupParser
+    def group
+      Urbit::Group.new(path:    self.resource,
+                       members: self.group_hash["members"],
+                       policy:  self.group_hash["policy"],
+                       tags:    self.group_hash["tags"],
+                       hidden:  self.group_hash["hidden"])
+    end
+
+    def group_hash
+      @j["group"]
+    end
+  end
+
+end

data/lib/urbit/message.rb

@@ -22,11 +22,11 @@ module Urbit
     end
 
     def channel_url
-      "#{self.ship.config.api_base_url}/~/channel/#{self.channel.key}"
+      "#{self.ship.url}/~/channel/#{self.channel.key}"
     end
 
     def request_body
-      self.to_a.to_json
+      JSON.generate(self.to_a)
     end
 
     def ship

data/lib/urbit/node.rb

@@ -11,8 +11,30 @@ module Urbit
       @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.raw_index == self.raw_index
+      another_node.index == self.index
     end
 
     def <=>(another_node)
@@ -20,11 +42,16 @@ module Urbit
     end
 
     def eql?(another_node)
-      another_node.raw_index == self.raw_index
+      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.raw_index.hash
+      self.index.hash
     end
 
     def author
@@ -47,6 +74,10 @@ module Urbit
       @post_h['contents']
     end
 
+    def datetime_sent
+      Time.at(self.time_sent / 1000).to_datetime
+    end
+
     def persistent?
       @persistent
     end
@@ -76,9 +107,13 @@ module Urbit
     end
 
     def raw_index
-      @post_h["index"].delete_prefix('/')
+      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
@@ -87,13 +122,17 @@ module Urbit
       {
         index: self.index,
         author: self.author,
+        sent: self.datetime_sent,
         contents: self.contents,
-        time_sent: self.time_sent,
         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
@@ -108,5 +147,6 @@ module Urbit
       end
       subatoms.join('/')
     end
+
   end
 end

data/lib/urbit/parser.rb

@@ -3,9 +3,15 @@ require 'urbit/node'
 
 module Urbit
   class Parser
+    def initialize(with_json:)
+      @j = with_json
+    end
+  end
+
+  class GraphParser < Parser
     def initialize(for_graph:, with_json:)
+      super(with_json: with_json)
       @g = for_graph
-      @j = with_json
     end
 
     #
@@ -33,16 +39,30 @@ module Urbit
     end
   end
 
-  class AddGraphParser < Parser
+  class AddGraphParser < GraphParser
     def nodes_hash
       @j["graph"]
     end
 
+    def resource_hash
+      @j["resource"]
+    end
   end
 
-  class AddNodesParser < Parser
+  class AddNodesParser < GraphParser
     def nodes_hash
       @j["nodes"]
     end
   end
+
+  class RemoveGraphParser < GraphParser
+    def nodes_hash
+      nil
+    end
+
+    def resource_hash
+      @j["resource"]
+    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: channel, app: app, mark: mark, contents: a_string)
+    def initialize(channel:, app:, mark:, a_message_hash:)
+      super(channel: channel, app: app, mark: mark, contents: a_message_hash)
     end
   end
 end

data/lib/urbit/receiver.rb

@@ -1,19 +1,19 @@
 require 'ld-eventsource'
+require "logger"
 
 require 'urbit/ack_message'
 require 'urbit/fact'
 
 module Urbit
   class Receiver < SSE::Client
-    attr_accessor :facts
+    attr_accessor :errors, :facts
 
     def initialize(channel:)
-      @facts = []
-      super(channel.url, {headers: self.headers(channel)}) do |rec|
+      super(channel.url, headers: self.headers(channel), logger: self.default_logger) 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|
           # Wrap the returned event in a Fact.
-          @facts << (f = Fact.new(channel: channel, event: event))
+          @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.
@@ -22,12 +22,22 @@ module Urbit
         end
 
         rec.on_error do |error|
-          self.facts += ["I received an error fact: #{error.class}"]
+          self.errors << ["I received an error fact: #{error.class}"]
         end
       end
+
+      @errors   = []
+      @facts   = []
       @is_open = true
     end
 
+    def default_logger
+      log           = ::Logger.new($stdout)
+      log.level     = ::Logger::WARN
+      log.progname  = 'ld-eventsource'
+      log
+    end
+
     def open?
       @is_open
     end

data/lib/urbit/settings.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'urbit/bucket'
+
+module Urbit
+  class Setting
+    attr_accessor :buckets
+    attr_reader :desk, :ship
+
+    def initialize(ship:, desk:, buckets:)
+      @ship    = ship
+      @desk    = desk
+      @buckets = Set.new
+      buckets.each {|k, v| @buckets << Bucket.new(setting: self, name: k, entries: v)}
+    end
+
+    def ==(another_group)
+      another_setting.desk == self.desk
+    end
+
+    def <=>(another_group)
+      self.desk <=> another_group.desk
+    end
+
+    def [](bucket:)
+      self.buckets.select {|b| bucket == b.name}.first
+    end
+
+    def add_bucket(name:, entries:)
+      msg = {
+        "put-bucket": {
+          "bucket-key": "#{name}",
+          "desk":       "#{self.desk}",
+          "bucket":     entries
+        }
+      }
+      self.ship.poke(app: 'settings-store', mark: 'settings-event', message: msg)
+      nil
+    end
+
+    def entries(bucket:)
+      self[bucket: bucket].entries
+    end
+
+    def remove_bucket(name:)
+      msg = {
+        "del-bucket": {
+          "bucket-key": "#{name}",
+          "desk":       "#{self.desk}"
+        }
+      }
+      self.ship.poke(app: 'settings-store', mark: 'settings-event', message: msg)
+      nil
+    end
+
+    def to_h
+      {
+        desk:    @desk,
+        buckets: self.buckets,
+      }
+    end
+
+    def to_s
+      "a Setting(#{self.to_h})"
+    end
+
+    def to_string
+      "desk: #{self.desk}\n  buckets: #{self.buckets.collect {|b| b.to_string}}"
+    end
+  end
+
+  class Settings < Set
+    class << self
+      def load(ship:)
+        ship.subscribe(app: 'settings-store', path: '/all')
+        scry = ship.scry(app: "settings-store", path: "/all", mark: "json")
+        # scry = self.scry(app: "settings-store", path: "/desk/#{desk}", mark: "json")
+        s = Settings.new
+        if scry[:body]
+          body = JSON.parse scry[:body]
+          body["all"].each do |k, v|  # At this level the keys are the desks and the values are the buckets
+            s << Setting.new(ship: ship, desk: k, buckets: v)
+          end
+        end
+        s
+      end
+    end
+
+    def initialize
+      @hash    = {}
+    end
+
+    def [](desk:)
+      self.select {|s| desk == s.desk}.first
+    end
+
+    def list
+      self.each {|s| puts s.to_string}
+      nil
+    end
+  end
+
+end