urbit-api 0.2.1 → 0.5.0

data/lib/urbit/graph.rb

@@ -4,12 +4,13 @@ require 'urbit/parser'
 
 module Urbit
   class Graph
-    attr_reader :host_ship_name, :name, :ship
+    attr_reader   :host_ship_name, :name, :ship
 
     def initialize(ship:, graph_name:, host_ship_name:)
       @ship           = ship
-      @name           = graph_name
+      @group          = nil
       @host_ship_name = host_ship_name
+      @name           = graph_name
       @nodes          = SortedSet.new
     end
 
@@ -17,6 +18,28 @@ module Urbit
       @nodes << node unless node.deleted?
     end
 
+    def creator
+      self.fetch_link if @creator.nil?
+      @creator
+    end
+
+    def description
+      self.fetch_link if @description.nil?
+      @description
+    end
+
+    def group
+      if @group.nil?
+        @link = self.fetch_link
+        @group = @link.group unless @link.nil?
+      end
+      @group
+    end
+
+    def group=(a_group)
+      @group = a_group
+    end
+
     def host_ship
       "~#{@host_ship_name}"
     end
@@ -84,6 +107,16 @@ module Urbit
       self.fetch_sibling_nodes(node, :older, count)[0..(count - 1)]
     end
 
+    def title
+      self.fetch_link if @title.nil?
+      @title
+    end
+
+    def type
+      self.fetch_link if @type.nil?
+      @type
+    end
+
     #
     # the canonical printed representation of a Graph
     def to_s
@@ -98,6 +131,15 @@ module Urbit
                        "add-graph")
     end
 
+    def fetch_link
+      @link  = self.ship.links.find_graph(resource: self.resource)
+      @creator     = @link.metadata['creator']
+      @description = @link.metadata['description']
+      @title       = @link.metadata['title']
+      @type        = @link.metadata['config']['graph']
+      @link
+    end
+
     def fetch_newest_nodes(count)
       self.fetch_nodes("#{self.graph_resource}/node/siblings/newest/kith/#{count}/",
                        AddNodesParser,

data/lib/urbit/group.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Urbit
+  class Group
+     attr_accessor :graphs, :manager, :members, :tags, :title
+     attr_reader :hidden, :path, :policy
+
+    def initialize(path:, members:, policy:, tags:, hidden:)
+      @graphs  = Set.new
+      @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
+
+    def creator
+      self.fetch_link if @creator.nil?
+      @creator
+    end
+
+    def description
+      self.fetch_link if @description.nil?
+      @description
+    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 graphs
+      if @graphs.empty?
+        self.graph_links.each {|gl| @graphs << gl.graph}
+      end
+      @graphs
+    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 picture
+      self.fetch_link if @picture.nil?
+      @picture
+    end
+
+    def title
+      self.fetch_link if @title.nil?
+      @title
+    end
+
+    def to_h
+    {
+        title:           self.title,
+        description:     self.description,
+        host:            self.host,
+        key:             self.key,
+        member_count:    self.members.count,
+        pending_invites: self.pending_invites,
+        hidden:          self.hidden
+      }
+    end
+
+    def to_list
+      self.title || "Untitled - #{self.path}"
+    end
+
+    def to_s
+      "a Group(#{self.to_h})"
+    end
+
+    private
+
+    def fetch_link
+      @group_link = self.manager.ship.links.find_group(path: self.path)
+      unless @group_link.nil?
+        @creator     = @group_link.metadata['creator']
+        @description = @group_link.metadata['description']
+        @picture     = @group_link.metadata['picture']
+        @title       = @group_link.metadata['title']
+      end
+    end
+
+    def graph_links
+      self.group_link.graph_links
+    end
+
+    def group_link
+      if @group_link.nil?
+        self.fetch_link
+      end
+      @group_link
+    end
+
+    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_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/groups.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Urbit
+  class Groups < Set
+    attr_accessor :ship
+
+    def initialize(ship:)
+      @ship   = ship
+      @hash = {}
+    end
+
+    def [](path: nil, title: nil)
+      if title.nil?
+        if (g = self.select {|g| g.path == path}.first)
+          g.manager = self
+          return g
+        end
+      else
+        if (g = self.select {|g| g.title == title}.first)
+          g.manager = self
+          return g
+        end
+      end
+      nil
+    end
+
+    #
+    # Adds a Group to this Manager's groups collection
+    #
+    def add(a_group)
+      a_group.manager = self
+      self << a_group
+    end
+
+    def add_members(group_path:, ships:)
+      if (group = self[path: group_path])
+        group.members += ships
+      end
+    end
+
+    def add_tag(group_path:, ships:, tag:)
+      if (group = self[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.empty?
+    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.map {|g| g.to_list}.join("\n")
+    end
+
+    def remove(group)
+      self.delete(group)
+    end
+
+    def remove_members(group_path:, ships:)
+      if (group = self[path: group_path])
+        group.members -= ships
+      end
+    end
+
+    def remove_tag(group_path:, ships:, tag:)
+      if (group = self[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.sort.each {|g| puts g}
+    end
+  end
+end

data/lib/urbit/link.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Urbit
+  class Link
+    attr_reader :path, :data
+
+    def initialize(chain:, path:, data:)
+      @chain = chain
+      @graph = nil
+      @group = nil
+      @path  = path
+      @data  = data
+    end
+
+    def ==(another)
+      another.path == self.path
+    end
+
+    def <=>(another)
+      self.path <=> another.path
+    end
+
+    def eql?(another)
+      another.path == self.path
+    end
+
+    def graph
+      if @graph.nil?
+        @graph = self.ship.graph(resource: self.graph_resource)
+      end
+      @graph
+    end
+
+    def graph_links
+      @chain.find_graph_links_for_group(path: self.group_path)
+    end
+
+    def graph_resource
+      @data['resource'].sub('/ship/', '')
+    end
+
+    def group
+      if @group.nil?
+        @group = self.ship.groups[path: self.group_path]
+      end
+      @group
+    end
+
+    def group_path
+      @data['group'].sub('/ship/', '')
+    end
+
+    def metadata
+      @data['metadata']
+    end
+
+    def ship
+      @chain.ship
+    end
+
+    def to_list
+      @path
+    end
+
+    def type
+      @data['app-name']
+    end
+  end
+end

data/lib/urbit/links.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Urbit
+  class Links < Set
+    attr_reader :ship
+
+    def initialize
+      @hash = {}
+      @ship = nil
+    end
+
+    def [](path:)
+      self.select {|l| path == l.path}.first
+    end
+
+    def find_graph(resource:)
+      self.select{|l| l.type == 'graph' && resource == l.graph_resource}.first
+    end
+
+    def find_graph_links_for_group(path:)
+      self.select{|l| l.type == 'graph' && path == l.group_path}
+    end
+
+    def find_group(path:)
+      self.select{|l| l.type == 'groups' && path == l.group_path}.first
+    end
+
+    def list
+      self.sort.each {|l| puts l.to_list}
+      nil
+    end
+
+    def load(ship:)
+      ship.subscribe(app: 'metadata-store', path: '/all')
+      @ship = ship
+      nil
+    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/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/setting.rb

@@ -0,0 +1,71 @@
+# 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
+end