urbit-api 0.3.0 → 0.4.0

data/lib/urbit/fact.rb

@@ -1,206 +1,50 @@
-require 'urbit/graph'
-require 'urbit/node'
-require 'urbit/parser'
+# frozen_string_literal: true
 
-module Urbit
-  class Fact
-    attr_reader :ack
-
-    def initialize(channel:, event:)
-      @channel = channel
-      @data = event.data
-      @type = event.type
-      puts "Received a Fact for [#{channel}] -- [#{@type}] -- [#{@data}]"
-    end
-
-    #
-    # This is a Facotry method to make the proper Fact subclass from
-    # a Channel Event.
-    #
-    def self.collect(channel:, event:)
-      contents = JSON.parse(event.data)
-      return Fact.new(channel: channel, event: event)              if contents["json"].nil?
-      return SettingsEventFact.new(channel: channel, event: event) if contents["json"]["settings-event"]
-
-      return Fact.new(channel: channel, event: event)              if contents["json"]["graph-update"].nil?
-      return AddGraphFact.new(channel: channel, event: event)      if contents["json"]["graph-update"]["add-graph"]
-      return AddNodesFact.new(channel: channel, event: event)      if contents["json"]["graph-update"]["add-nodes"]
-      return RemoveGraphFact.new(channel: channel, event: event)   if contents["json"]["graph-update"]["remove-graph"]
-
-      return Fact.new(channel: channel, event: event)
-    end
-
-    def add_ack(ack:)
-      @ack = :ack
-    end
-
-    def contents
-      JSON.parse(@data)
-    end
-
-    def for_this_ship?
-      self.ship == @channel.ship
-    end
-
-    def graph_update?
-      false
-    end
-
-    def is_acknowledged?
-      !@ack.nil?
-    end
-
-    def raw_json
-      nil
-    end
-
-    def ship
-      @channel.ship
-    end
-
-    def to_h
-      {
-        ship:            self.ship.to_h,
-        acknowleged:     self.is_acknowledged?,
-        is_graph_update: self.graph_update?
-      }
-    end
-
-    def to_s
-      "a #{self.class.name}(#{self.to_h})"
-    end
-  end
-
-  class GraphUpdateFact < Fact
-    def initialize(channel:, event:)
-      super channel: channel, event: event
-    end
-
-    #
-    # Attach this new fact as a node to its Graph.
-    #
-    def attach_parser
-      # puts "Received a graph update for [#{self.ship.graph(resource: self.resource)}]"
-      if self.incoming_graph
-        # puts "Received an add_graph event: #{self.raw_json} on #{self.resource}"
-        self.create_parser
-      end
-    end
-
-    def create_parser
-      nil
-    end
-
-    def graph_update?
-      true
-    end
-
-    def incoming_graph
-      self.ship.graph(resource: self.resource)
-    end
-
-    def resource
-      return "~#{self.resource_h["ship"]}/#{self.resource_h["name"]}" unless self.resource_h.nil?
-    end
-
-    def resource_h
-      self.raw_json["resource"]
-    end
-
-    def root_h
-      self.contents["json"]["graph-update"]
-    end
-
-    def to_h
-      super.merge!(resource: self.resource)
-    end
-  end
-
-  class AddGraphFact < GraphUpdateFact
-    def initialize(channel:, event:)
-      super channel: channel, event: event
-    end
-
-    def create_parser
-      Urbit::AddGraphParser.new(for_graph: incoming_graph,  with_json: self.raw_json).add_nodes
-    end
-
-    def raw_json
-      self.root_h["add-graph"]
-    end
-  end
-
-  class AddNodesFact < GraphUpdateFact
-    def initialize(channel:, event:)
-      super channel: channel, event: event
-    end
-
-    def create_parser
-      Urbit::AddNodesParser.new(for_graph: incoming_graph,  with_json: self.raw_json).add_nodes
-    end
-
-    def raw_json
-      self.root_h["add-nodes"]
-    end
-  end
-
-  class RemoveGraphFact < GraphUpdateFact
-    def initialize(channel:, event:)
-      super channel: channel, event: event
-    end
-
-    def create_parser
-      Urbit::RemoveGraphParser.new(for_graph: incoming_graph,  with_json: self.raw_json)
-    end
-
-    def raw_json
-      self.root_h["remove-graph"]
-    end
-
-    def resource_h
-      self.raw_json
-    end
-  end
+require_relative 'fact/base_fact'
+require_relative 'fact/graph_fact'
+require_relative 'fact/group_fact'
+require_relative 'fact/settings_fact'
 
-  class SettingsEventFact < Fact
-    def initialize(channel:, event:)
-      super channel: channel, event: event
-
-      if self.for_this_ship?
-        # See if we already have this setting, if no add it, if yes update it.
-        if (entries = channel.ship.setting(bucket: self.bucket))
-          entries[self.entry] = self.value
+module Urbit
+  module Fact
+    class << self
+      #
+      # This is a Factory method to make the proper Fact subclass from a Channel Event.
+      #
+      def collect(channel:, event:)
+        contents = JSON.parse(event.data)
+
+        if contents["json"].nil?
+          return SuccessFact.new(channel: channel, event: event) if contents["ok"]
+          return ErrorFact.new(channel: channel, event: event)   if contents["err"]
+          return EmptyFact.new(channel: channel, event: event)
         end
-      end
-    end
 
-    def bucket
-      self.contents["bucket-key"]
-    end
-
-    def contents
-      JSON.parse(@data)["json"]["settings-event"]["put-entry"]
-    end
-
-    def desk
-      self.contents["desk"]
-    end
+        if contents["json"]["graph-update"]
+          return AddGraphFact.new(channel: channel, event: event)      if contents["json"]["graph-update"]["add-graph"]
+          return AddNodesFact.new(channel: channel, event: event)      if contents["json"]["graph-update"]["add-nodes"]
+          return RemoveGraphFact.new(channel: channel, event: event)   if contents["json"]["graph-update"]["remove-graph"]
+        end
 
-    def entry
-      self.contents["entry-key"]
-    end
+        if (c = contents["json"]["groupUpdate"])
+          return AddGroupFact.new(channel: channel, event: event)          if c["addGroup"]
+          return AddGroupMemberFact.new(channel: channel, event: event)    if c["addMembers"]
+          return AddTagFact.new(channel: channel, event: event)            if c["addTag"]
+          return InitialGroupFact.new(channel: channel, event: event)      if c["initial"]
+          return InitialGroupGroupFact.new(channel: channel, event: event) if c["initialGroup"]
+          return RemoveGroupMemberFact.new(channel: channel, event: event) if c["removeMembers"]
+          return RemoveTagFact.new(channel: channel, event: event)         if c["removeTag"]
+        end
 
-    def to_h
-      super.merge!({
-        bucket: self.bucket,
-        desk:   self.desk,
-        entry:  self.entry,
-        value:  self.value
-      })
-    end
+        if (c = contents["json"]["settings-event"])
+          return SettingsEventDelBucketFact.new(channel: channel, event: event) if c["del-bucket"]
+          return SettingsEventDelEntryFact.new(channel: channel, event: event)  if c["del-entry"]
+          return SettingsEventPutBucketFact.new(channel: channel, event: event) if c["put-bucket"]
+          return SettingsEventPutEntryFact.new(channel: channel, event: event)  if c["put-entry"]
+        end
 
-    def value
-      self.contents["value"]
+        return BaseFact.new(channel: channel, event: event)
+      end
     end
   end
 end

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/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,7 +39,7 @@ module Urbit
     end
   end
 
-  class AddGraphParser < Parser
+  class AddGraphParser < GraphParser
     def nodes_hash
       @j["graph"]
     end
@@ -43,13 +49,13 @@ module Urbit
     end
   end
 
-  class AddNodesParser < Parser
+  class AddNodesParser < GraphParser
     def nodes_hash
       @j["nodes"]
     end
   end
 
-  class RemoveGraphParser < Parser
+  class RemoveGraphParser < GraphParser
     def nodes_hash
       nil
     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,15 +1,15 @@
 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.
@@ -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