urbit-api 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ffd645b7c5236244e5c081587835863586b11d035d3197e7e286fa223bc3c0f
-  data.tar.gz: 19e8360fbdf96a1149a99dc7218bd835ac3af5338f5ff0b0cfc0c907ea383f27
+  metadata.gz: 0a3c9e5915684d444baa066c316ebeafd2cddc0aa731d323b15fec95be932b05
+  data.tar.gz: 951ddb43e002c92c0490b549de64a2311b42124c09cb499833d58d7c717b088d
 SHA512:
-  metadata.gz: 84a0d8b5144e08a43080f3d4b0caaecba73e9fd5a74f2d5f1c04f66f1577dc64ebdf44e2fb91716c2ce746b4c96062e0615a24c5a54d760fd1a0ae9ec8b9af36
-  data.tar.gz: 41e5ffab8a9b67bce7c1373ee932ab17834e5684da3de41bb6bc19fa44b115e0fea4472e78e672b4ddd7c74c4e970ba0a20cf9123f27db1d5b763d67ca1f2185
+  metadata.gz: a677021940189cf5e52a969b01d4f77b418dc544d823b47d1dfaf83832c44f00dbe926692d9957f3a01809a8fdda15ba65177b5a57ecb01f310ec800e09d6e75
+  data.tar.gz: d10188333e23d83a6abee0a44250bdce9641694264fc81970b5de285a973156f00b7b5a342b88e3b4d476d8a363e350012aabcf727cc940b9a2f0fc50ce59918

data/README.md

@@ -29,85 +29,44 @@ Or install it yourself as:
 # This will instantiate a ship that connects to the fake `~zod` dev server by default
 # See Urbit docs for more info: https://urbit.org/using/develop/
 [1] pry(main)> ship = Urbit.new
-# => #<Urbit::Ship:0x00007fa74b87f920 ...
+=> #<Urbit::Ship:0x00007fa74b87f920 ...
 
 OR... with config file...
 > ship = Urbit.connect(config_file: '_config-barsyr-latreb.yml')
 
 > ship.logged_in?
-# => false
+=> false
 
 > ship.login
-# => #<Urbit::Ship:0x00007fa74b87f920 ...
+=> #<Urbit::Ship:0x00007fa74b87f920 ...
 
 > ship.logged_in?
-# => true
+=> true
 
 > ship.to_s
-# => "a Ship(name: '~barsyr-latreb', host: 'http://localhost', port: '8080')"
+=> "a Ship(name: '~barsyr-latreb', host: 'http://localhost', port: '8080')"
 
-> receiver = ship.subscribe('graph-store', '/updates')
-# => #<Urbit::Receiver:0x00007fd3928eba58
+> channel = ship.subscribe(app: 'graph-store', path: '/updates')
+=> a Channel (Open) on ~barsyr-latreb(name: 'Channel-0', key: '1622836437b540b4')
 
 # Subscribing works by opening a Channel. Your ships has a collection of all it's open Channels.
 > channel = ship.open_channels.first
-# => #<Urbit::Channel:0x00007fa74b291e50 ...
+=> a Channel (Open) on ~barsyr-latreb(name: 'Channel-0', key: '1622836437b540b4')
+
+# Notice that it's the same one.
 
 # Every Channel has a unique key to identify it.
 > channel.key
-# => "16142890875c348d"
+=> "16142890875c348d"
 
-# The receiver will now be listening on the app and path you specified. Each time an event is sent in it will be stored in the receiver's facts collection.
-> receiver.facts.count
+# The Channel has a Receiver that will now be listening on the app and path you specified. Each time an event is sent in it will be stored in the receiver's facts collection.
+> channel.receiver.facts.count
 => 12
 
-> receiver.facts.last
-=> {:message=>
-     {"json"=>
-       {"graph-update"=>
-         {"add-nodes"=>
-           {"resource"=>{"name"=>"test0-996", "ship"=>"barsyr-latreb"},
-            "nodes"=>
-             {"/170141184504954066298369929365830487769"=>
-               {"post"=>
-                 {"index"=>"/170141184504954066298369929365830487769",
-                  "author"=>"barsyr-latreb",
-                  "time-sent"=>1615564146267,
-                  "signatures"=>[],
-                  "contents"=>[],
-                  "hash"=>"0x92b0.c976.58f0.3035.c126.64a0.3043.b962"},
-                "children"=>
-                 {"2"=>
-                   {"post"=>
-                     {"index"=>"/170141184504954066298369929365830487769/2",
-                      "author"=>"barsyr-latreb",
-                      "time-sent"=>1615564146267,
-                      "signatures"=>[],
-                      "contents"=>[],
-                      "hash"=>"0x2ffe.3ca7.20eb.11af.51f8.fbab.2b88.9f48"},
-                    "children"=>nil},
-                  "1"=>
-                   {"post"=>
-                     {"index"=>"/170141184504954066298369929365830487769/1",
-                      "author"=>"barsyr-latreb",
-                      "time-sent"=>1615564146267,
-                      "signatures"=>[],
-                      "contents"=>[],
-                      "hash"=>"0x2ffe.3ca7.20eb.11af.51f8.fbab.2b88.9f48"},
-                    "children"=>
-                     {"1"=>
-                       {"post"=>
-                         {"index"=>"/170141184504954066298369929365830487769/1/1",
-                          "author"=>"barsyr-latreb",
-                          "time-sent"=>1615564146267,
-                          "signatures"=>[],
-                          "contents"=>[{"text"=>"Test 0.8"}, {"text"=>"Test 0.8"}],
-                          "hash"=>"0x9516.25fc.ca7a.5bb9.356b.2fce.b29a.f372"},
-                        "children"=>nil}}}}}}}}},
-      "id"=>2,
-      "response"=>"diff"
-    }
-  }
+# Perform any action through landscape that would initiate an update into %graph-store...
+# In this case I have added a comment to a local notebook.
+> channel.receiver.facts.last
+=> a Fact({:ship=>{:name=>"~barsyr-latreb", :host=>"http://localhost", :port=>"8080"}, :resource=>"~barsyr-latreb/test0-996", :acknowleged=>true, :is_graph_update=>true})
 
 #  Your ship keeps a collection of all the messages sent to urbit:
 > channel.sent_messages.collect {|m| m.to_s}
@@ -119,10 +78,112 @@ OR... with config file...
     "a Message({"id"=>5, "action"=>"ack", "event-id"=>"2"})"
    ]
 
+#
+# --------------------------------------------------------------------
+# Poke
+# --------------------------------------------------------------------
+#
+> ship.poke(app: 'hood', mark: 'helm-hi', message: 'Opening Airlock')
+=> a Channel (Open) on ~barsyr-latreb(name: 'Channel-0', key: '1630355920a717e1')
+
+#
+# --------------------------------------------------------------------
+# Scry
+# --------------------------------------------------------------------
+#
 # Retrieving your ship's base hash using scry....
-> ship.scry('file-server', '/clay/base/hash', 'json')
+> ship.scry(app: 'file-server', path: '/clay/base/hash')
+# => {:status=>200, :code=>"ok", :body=>"\"e75k5\""}
+
+#
+# --------------------------------------------------------------------
+# Spider
+# --------------------------------------------------------------------
+#
+# Creating a new Notebook in "My Channels" using %spider....
+> create_json = %Q(
+        {"create": {"resource": { "ship": "~zod", "name": "random_name"},
+        "title": "Testing",
+        "description": "Testing Un-Managed Graph Creation",
+        "associated" : {"policy": {"invite": {"pending": []}}},
+        "module": "publish", "mark": "graph-validator-publish"}}
+  )
+> ship.spider(mark_in: 'graph-view-action', mark_out: 'json', thread: 'graph-create', data: create_json)
 # => {:status=>200, :code=>"ok", :body=>"\"e75k5\""}
 
+#
+# --------------------------------------------------------------------
+# %graph-store
+# --------------------------------------------------------------------
+#
+> puts ship.graph_names
+~barsyr-latreb/dm-inbox
+~darlur/announce
+~bitbet-bolbel/urbit-community-5.963
+~winter-paches/top-shelf-6391
+~winter-paches/the-great-north-7.579
+~barsyr-latreb/test0-996
+~fabled-faster/test-chat-a-5919
+~barsyr-latreb/test1-4287
+~darrux-landes/welcome-to-urbit-community
+~millyt-dorsen/finance-2.962
+~fabled-faster/interface-testing-facility-683
+~darlur/help-desk-4556
+=>
+
+# Reference a graph by name and return a single node.
+> puts ship.graph(resource: '~winter-paches/top-shelf-6391').node(index: "170.141.184.505.207.751.870.046.689.877.378.990.080")
+a Node({:index=>"170.141.184.505.207.751.870.046.689.877.378.990.080", :author=>"witfyl-ravped", :contents=>[{"text"=>"the patches don't really bother me though tbh"}], :time_sent=>1629316468195, :is_parent=>false, :child_count=>0})
+=>
+
+# You can also reference a graph by its index in the graphs collection.
+> puts ship.graphs[3].node(index: "170.141.184.505.207.751.870.046.689.877.378.990.080")
+a Node({:index=>"170.141.184.505.207.751.870.046.689.877.378.990.080", :author=>"witfyl-ravped", :contents=>[{"text"=>"the patches don't really bother me though tbh"}], :time_sent=>1629316468195, :is_parent=>false, :child_count=>0})
+=>
+
+# Return the contents of the 5 oldest nodes of a graph
+> graph = ship.graph(resource: '~winter-paches/top-shelf-6391')
+> graph.oldest_nodes(count: 5).sort.each {|n| p n.contents};nil
+[{"text"=>"watching the 2020 stanley cup finals (tampa (sigh) just went up 2-0 in game 3) and i thought: \"the great north has to have a hockey chat, eh?\""}]
+[{"text"=>"we'll see if this has legs. ;)"}]
+[{"text"=>"shortie! now 2-1 tampa."}]
+[{"text"=>"looks like tampa's going to go up 2-1. as a canadian this geographically depresses me. :/"}]
+[{"text"=>"anyone in the stands?"}]
+=>
+
+# A single Node. In this case, the 3rd oldest node in the graph.
+> puts graph.nodes[2].contents
+{"text"=>"shortie! now 2-1 tampa."}
+=>
+
+# Getting the next newer Node. Remember that it always returns an Array, hence the '#first'.
+> puts graph.nodes[2].next.first.contents
+{"text"=>"looks like tampa's going to go up 2-1. as a canadian this geographically depresses me. :/"}
+=>
+
+# Return the indexes of the newest 5 nodes of a graph
+> ship.graph(resource: '~winter-paches/top-shelf-6391').newest_nodes(count: 5).sort.each {|n| p n.index};nil
+"170.141.184.505.209.257.330.601.508.862.548.770.816"
+"170.141.184.505.209.375.247.350.471.711.992.578.048"
+"170.141.184.505.209.545.972.004.310.065.795.301.376"
+"170.141.184.505.209.627.337.970.761.265.544.429.568"
+"170.141.184.505.209.644.102.846.398.558.514.446.336"
+=>
+
+# Fetching nodes older relative to another node. (See indexes above)
+> puts (node = ship.graph(resource: '~winter-paches/top-shelf-6391').node(index: "170.141.184.505.209.644.102.846.398.558.514.446.336"))
+a Node({:index=>"170.141.184.505.209.644.102.846.398.558.514.446.336", :author=>"winter-paches", :contents=>[{"text"=>"yep. that's how i did it as a kid. harry caray was the white sox announcer before he turned traitor and went to the cubs."}], :time_sent=>1629419046028, :is_parent=>false, :child_count=>0})
+=>
+
+> puts node.previous
+a Node({:index=>"170.141.184.505.209.627.337.970.761.265.544.429.568", :author=>"pathus-hiddyn", :contents=>[{"text"=>"Lol oh man I haven’t listened to a baseball game on the radio in forever. It is great isn’t it. "}], :time_sent=>1629418137668, :is_parent=>false, :child_count=>0})
+=>
+
+> node.previous(count: 4).each {|n| p n.index};nil
+"170.141.184.505.209.257.330.601.508.862.548.770.816"
+"170.141.184.505.209.375.247.350.471.711.992.578.048"
+"170.141.184.505.209.545.972.004.310.065.795.301.376"
+"170.141.184.505.209.627.337.970.761.265.544.429.568"
 ```
 ### Configuration
 
@@ -153,11 +214,10 @@ ship = Urbit.new(host: '127.0.0.1', port: '8080')
 ```sh
 bin/test
 ```
-### ~zod
-
 Tests assume that an instance of a ["fake" development Urbit ship](https://urbit.org/using/develop/) (one not connected to the live network) will be running, available at `http://localhost:8080`.
+### "fake" ~zod
 
-To create a development ship:
+To create this development ship:
 ```sh
 ./urbit -F zod
 ```
@@ -165,7 +225,7 @@ To create a development ship:
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`.
 
 ## Contributing
 

data/bin/console

@@ -4,8 +4,11 @@ require "bundler/setup"
 require "pry"
 require "urbit/urbit"
 
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
+puts "Welcome! This is an interactive environment to explore your Urbit ship."
+puts "You create a config file with connection details for your ship and off you go."
+puts ""
 puts "e.g., ship = Urbit.new(config_file: 'my_config.yml')"
+puts "=> a Ship(name: '~barsyr-latreb', host: 'http://localhost', port: '8080')"
+
+Pry.config.print = proc { |output, value| output.puts "=> #{value}" }
 Pry.start

data/lib/urbit/ack_message.rb

@@ -2,14 +2,22 @@ module Urbit
   class AckMessage < Message
     attr_reader :ack_id
 
-    def initialize(channel, sse_message_id)
-      super(channel, 'ack')
+    def initialize(channel:, sse_message_id:)
+      super(channel: channel)
       @ack_id  = sse_message_id
     end
 
+    def action
+      "ack"
+    end
+
     def to_h
       # Need to use the older hash style due to the key having a dash.
       {'id' => self.id, 'action' => self.action, 'event-id' => self.ack_id}
     end
+
+    def to_s
+      "an AckMessage(#{self.to_h})"
+    end
   end
 end

data/lib/urbit/api/version.rb

@@ -1,5 +1,5 @@
 module Urbit
   module Api
-    VERSION = "0.1.2"
+    VERSION = "0.2.0"
   end
 end

data/lib/urbit/channel.rb

@@ -9,48 +9,50 @@ require 'urbit/subscribe_message'
 module Urbit
   class Channel
     attr_accessor :messages
-    attr_reader :key, :name, :ship
+    attr_reader :key, :name, :receiver, :ship
 
-    def initialize(ship, name)
+    def initialize(ship:, name:)
       @ship          = ship
       @key           = "#{Time.now.to_i}#{SecureRandom.hex(3)}"
       @messages      = []
       @name          = name
+      @receiver      = nil
       @is_open       = false
-      @is_subscribed = false
     end
 
     def close
       # puts "closing #{name}"
-      m = Urbit::CloseMessage.new(self)
-      @is_open = !self.send_message(m)
+      m = Urbit::CloseMessage.new(channel: self)
+      @is_open = !self.send(message: m)
     end
 
     def closed?
       !@is_open
     end
 
-    #
-    # We open a channel by "poking" the urbit app 'hood' using the mark 'helm-hi'
-    #
-    def open(a_message_string)
-      m = Urbit::PokeMessage.new(self, "hood", "helm-hi", a_message_string)
-      @is_open = self.send_message(m)
-    end
-
     def open?
       @is_open
     end
 
-    def queue_message(a_message)
-      a_message.id = self.sent_messages.size + 1
-      @messages << a_message
+    #
+    # One way to open a channel by "poking" an urbit app with a mark and a (json) message.
+    # A typical example of this is poking the 'hood' app using the mark 'helm-hi' to start a DM chat.
+    #
+    def poke(app:, mark:, message:)
+      @is_open = self.send(message: (Urbit::PokeMessage.new(channel: self, app: app, mark: mark, a_string: message)))
+      @receiver = Urbit::Receiver.new(channel: self)
+      self
+    end
+
+    def queue(message:)
+      message.id = self.sent_messages.size + 1
+      @messages << message
     end
 
     # Answers true if message was successfully sent.
-    def send_message(a_message)
-      self.queue_message(a_message)
-      resp = a_message.transmit
+    def send(message:)
+      self.queue(message: message)
+      resp = message.transmit
       resp.reason_phrase == "ok"
     end
 
@@ -66,14 +68,15 @@ 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)
-      m = Urbit::SubscribeMessage.new(self, app, path)
-      @is_subscribed = self.send_message(m)
-      receiver = Urbit::Receiver.new(self)
+    def subscribe(app:, path:)
+      m = Urbit::SubscribeMessage.new(channel: self, app: app, path: path)
+      @is_open = self.send(message: m)
+      @receiver = Urbit::Receiver.new(channel: self)
+      self
     end
 
     def subscribed?
-      @is_subscribed
+      @is_open
     end
 
     def to_s

data/lib/urbit/chat_channel.rb

@@ -0,0 +1,22 @@
+require 'securerandom'
+
+require 'urbit/message'
+require 'urbit/receiver'
+require 'urbit/close_message'
+require 'urbit/poke_message'
+require 'urbit/subscribe_message'
+
+module Urbit
+  class ChatChannel < Channel
+    # def messages
+    #   self.fetch_all_nodes if @nodes.empty?
+    #   @nodes
+    # end
+
+    # def newest_messages(count = 100)
+    #   self.fetch_newest_nodes(count) if @nodes.empty?
+    #   self.nodes
+    # end
+
+  end
+end

data/lib/urbit/close_message.rb

@@ -1,7 +1,11 @@
 module Urbit
   class CloseMessage < Message
-    def initialize(channel)
-      super(channel, 'delete')
+    def initialize(channel:)
+      super(channel: channel)
+    end
+
+    def action
+      "delete"
     end
 
     def to_h

data/lib/urbit/fact.rb

@@ -0,0 +1,66 @@
+require 'urbit/graph'
+require 'urbit/node'
+require 'urbit/parser'
+
+module Urbit
+  class Fact
+    attr_reader :ack
+
+    def initialize(channel:, event:)
+      @channel = channel
+      @data = event.data
+      @type = event.type
+
+      # Attach this new fact as a node to its Graph.
+      if self.graph_update?
+        puts self.add_nodes_json
+        Urbit::AddNodesParser.new(for_graph: (self.ship.graph(resource: self.resource)),  with_json: self.add_nodes_json).add_nodes
+      end
+    end
+
+    def add_ack(ack:)
+      @ack = :ack
+    end
+
+    def add_nodes_json
+      return nil unless self.graph_update?
+      self.contents["json"]["graph-update"]["add-nodes"]
+    end
+
+    def contents
+      JSON.parse(@data)
+    end
+
+    def graph_update?
+      !self.contents["json"].nil? && !self.contents["json"]["graph-update"].nil?
+    end
+
+    def is_acknowledged?
+      !@ack.nil?
+    end
+
+    def resource
+      return nil unless self.graph_update?
+      r = self.contents["json"]["graph-update"]["add-nodes"]["resource"]
+      "~#{r["ship"]}/#{r["name"]}"
+    end
+
+    def ship
+      @channel.ship
+    end
+
+    def to_h
+      {
+        ship:            self.ship.to_h,
+        resource:        self.resource,
+        acknowleged:     self.is_acknowledged?,
+        is_graph_update: self.graph_update?
+        # contents:        self.contents
+      }
+    end
+
+    def to_s
+      "a Fact(#{self.to_h})"
+    end
+  end
+end