bskyrb 0.4 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3ebcdf8ed7dabe9c22cf650ffecec5c8883d72b32c29baae4a44f40f94365bd
-  data.tar.gz: d3ad042fa4d4a1b2e62e53ca2aae552078b7aa3f78f1c612b1a6fc568f3b0c61
+  metadata.gz: 3ae64c99f896f5ec3366f9c4e028d61c9006563351c34be989881ccb4fac52d9
+  data.tar.gz: 57903df97da314a87e257fad02d8536ad783ea88511c2f5b7efbf774ad36b4b4
 SHA512:
-  metadata.gz: 8e6ab71de741b377398c4a651d3b34406b0f1c0fa3d5c1d9c3721976dacec12146ecf8900a9a33a38feaf75f2db45320723e5f1967587456d1200b16d2fe7130
-  data.tar.gz: a022a0f04a37a4c4be4dab37fa9a9d2e348f3ff0c541ae02a8422ec3149d466d900465c90f834c0811163b12f43fde4789288607ce7d1a2faf0b4b2fc7efcaed
+  metadata.gz: 447074d457ecb73774ce6e355f3cd18820b13e508c58f144361105b8bb1bf6fe7547ac994d62c5a2fbdec49b3d56b96fd8fdcadfeb6d967cc521e983c7a84f26
+  data.tar.gz: f3440ccc3800260c21481da110ea68aa40e4d48ca70ab1e6292d80435820f389f0f59f3f02c31029812d2d9335d42cbddcefc3f40c1e667d0a21e139642e5d7c

data/lib/bskyrb/codegen.rb

@@ -0,0 +1,212 @@
+# typed: false
+require "json"
+require "erb"
+
+module Bskyrb
+  module LexiconParser
+    @@active_namespace = ""
+
+    def self.def_is_query(defn)
+      defn["defs"].has_key?("main") &&
+        defn["defs"]["main"].has_key?("type") &&
+        defn["defs"]["main"]["type"] == "query"
+    end
+
+    def self.def_is_subscription(defn)
+      defn["defs"].has_key?("main") &&
+        defn["defs"]["main"].has_key?("type") &&
+        defn["defs"]["main"]["type"] == "subscription"
+    end
+
+    def self.def_is_procedure(defn)
+      defn["defs"].has_key?("main") &&
+        defn["defs"]["main"].has_key?("type") &&
+        defn["defs"]["main"]["type"] == "procedure"
+    end
+
+    def self.build_classes_hash_from_lexicon_defs(lexicon_file)
+      parsed = File.open(lexicon_file) { |f| JSON.parse(f.read) }
+      output = {}
+      # return if def_is_query(parsed) || def_is_procedure(parsed) || def_is_subscription(parsed)
+      parsed["defs"].each do |k, v| # map {|v| build_class_hash_from_schema(v)}
+        next if v["type"] == "main" # skip queries, procedures, etc.
+        @@active_namespace = parsed["id"].split(".").map(&:capitalize).join("")
+        next if k == "main"
+        output[ref_to_class_str(k)] = if v["type"] == "record"
+          build_class_hash_from_schema(v["record"]["properties"])
+        else
+          build_class_hash_from_schema(v)
+        end
+      end
+      output
+    end
+
+    def self.build_queries_and_procedures_from_lexicon(lexicon_file)
+      parsed = File.open(lexicon_file) { |f| JSON.parse(f.read) }
+      output = {}
+      return unless def_is_query(parsed) || def_is_procedure(parsed)
+      parsed["defs"].each do |k, v| # map {|v| build_class_hash_from_schema(v)}
+        next if k != "main" || v["type"] == "record" # skip basic defs
+        next if v["type"] == "subscription" # some day
+        @@active_namespace = parsed["id"].split(".").map(&:capitalize).join("")
+        class_name = ref_to_class_str(parsed["id"].split(".").last)
+        built_def = {}
+        output[class_name] = {}
+        if v["type"] == "query"
+          built_def["input"] = build_class_hash_from_schema(v["parameters"])
+          if v["output"] && v["output"]["schema"]
+            built_def["output"] = build_class_hash_from_schema(v["output"]["schema"])
+          end
+        end
+        if v["type"] == "procedure"
+          if v["input"]
+            built_def["input"] = build_class_hash_from_schema(v["input"]["schema"])
+          end
+          if v["output"] && v["output"]["schema"]
+            built_def["output"] = build_class_hash_from_schema(v["output"]["schema"])
+          end
+        end
+        output[class_name] = built_def unless built_def.empty?
+      end
+      output
+    end
+
+    def self.build_class_hash_from_schema(json_schema, output = {})
+      return if json_schema.nil?
+      return if json_schema.has_key? "main"
+      to_process = json_schema["properties"] || json_schema
+      to_process.each_pair do |key, value|
+        if key == "type" || !value.is_a?(Hash) # || value["type"] == "query" || key == "main"
+          next
+        end
+
+        output[key] = if value["type"] == "object"
+          build_class_hash_from_schema(value, {})
+        elsif value["type"] == "array"
+          [build_class_hash_from_schema(value, {}).values.first]
+        elsif value["type"] == "ref"
+          ref_to_class_str(value["ref"])
+        else
+          -1
+        end
+      end
+      output
+    end
+
+    def self.ref_to_class_str(ref, ns = @@active_namespace)
+      klass_str_lower = ref.split("#")[-1]
+      klass_str = klass_str_lower[0].capitalize + klass_str_lower.slice(1..)
+      ns += "::" if ns
+      "#{ns}#{klass_str}"
+    end
+
+    def self.basic_template
+      %(
+module <%= klass_str.split("::").first %>
+class <%= klass_str.split("::").last %>
+  <% properties.each do |key, value| %>
+  attr_accessor :<%= key %>
+  <% end %>
+
+  def self.from_hash(hash)
+    # httparty-returned string-keyed hash
+    instance = new
+    <% properties.each do |key, value| %>
+    instance.send("<%= key %>=", hash["<%= key %>"])
+    <% end %>
+    instance
+  end
+end
+end
+)
+    end
+
+    def self.basic_class_definitions(classes_hash)
+      classes_hash.map do |klass_str, properties|
+        ERB.new(basic_template).result_with_hash({klass_str: klass_str, properties: properties})
+      end
+    end
+
+    def self.input_output_template
+      %(
+module <%= klass_str.split("::").first %>
+  module <%= klass_str.split("::").last %>
+    <% ["input", "output"].each do |top_level_key| %>
+    <% next unless properties.has_key?(top_level_key) && !properties[top_level_key].nil? %>
+    class <%= top_level_key.capitalize %>
+      <% properties[top_level_key].each do |key, value| %>
+      attr_accessor :<%= key %>
+      <% end %>
+
+      def self.from_hash(hash)
+        # httparty-returned string-keyed hash
+        instance = new
+          <% properties[top_level_key].each do |key, value| %>
+        instance.send("<%= key %>=", hash["<%= key %>"])
+          <% end %>
+        instance
+      end
+
+      def to_h
+        {
+          <% properties[top_level_key].each do |key, value| %>
+            "<%= key %>" => <%= key %>,
+          <% end %>
+        }
+      end
+    end
+    <% end %>
+  end
+end
+)
+    end
+
+    def self.input_output_class_definitions(classes_hash)
+      classes_hash.map do |klass_str, properties|
+        ERB.new(input_output_template).result_with_hash({klass_str: klass_str, properties: properties})
+      end
+    end
+  end
+
+  class DynamicClassFromHash
+    def self.from_hash(hash)
+      hash.each do |klass_sym, properties|
+        Object.const_set(klass_sym, Class.new do
+          attr_accessor(*properties.keys.map(&:to_sym))
+
+          def self.from_hash(properties)
+            # httparty-returned string-keyed hash body
+            instance = new
+            properties.each do |key, value|
+              instance.send("#{key}=", value)
+            end
+            instance
+          end
+        end)
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  basic_defs = {}
+  Dir["atproto/lexicons/**/*.json"].each do |file|
+    hashes = Bskyrb::LexiconParser.build_classes_hash_from_lexicon_defs(file)
+    basic_defs = basic_defs.merge(hashes) unless hashes.empty?
+  end
+
+  input_output_defs = {}
+  Dir["atproto/lexicons/**/*.json"].each do |file|
+    hashes = Bskyrb::LexiconParser.build_queries_and_procedures_from_lexicon(file)
+    input_output_defs = input_output_defs.merge(hashes) unless hashes.nil? || hashes.empty?
+  end
+
+  File.open("lib/bskyrb/generated_classes.rb", "w") do |f|
+    f.puts "module Bskyrb"
+    f.puts Bskyrb::LexiconParser.basic_class_definitions(basic_defs)
+    f.puts Bskyrb::LexiconParser.input_output_class_definitions(input_output_defs)
+    f.puts "end"
+  end
+  `bin/format`
+  `bundle exec rbs prototype rb lib/bskyrb/generated_classes.rb > sig/generated_classes.rbs`
+end

data/lib/bskyrb/error.rb

@@ -0,0 +1,10 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bskyrb
+  class Error < StandardError; end
+
+  class HTTPError < Error; end
+
+  class UnauthorizedError < HTTPError; end
+end

data/lib/bskyrb/firehose.rb

@@ -0,0 +1,37 @@
+# typed: false
+require "faye/websocket"
+require "eventmachine"
+require "cbor"
+require "json"
+
+EM.run {
+  ws = Faye::WebSocket::Client.new("wss://bsky.social/xrpc/com.atproto.sync.subscribeRepos")
+
+  ws.on :open do |event|
+    p [:open]
+    ws.send("Hello, world!")
+  end
+
+  ws.on :message do |event|
+    msg_bytes = event.data
+    unpacker = CBOR::Unpacker.new(StringIO.new(msg_bytes.pack("C*")))
+    header, payload = unpacker.each.to_a
+
+    # decoder = CBOR::Decoding.new(StringIO.new(msg_bytes.pack('C*')))
+    # while item = decoder.read
+    #     puts item
+    # end
+
+    if payload["ops"].first["path"].include? "app.bsky.feed.post"
+      # payload#["blocks"].length
+      decoded = CBOR.decode(payload)
+
+      # Convert the decoded object to JSON
+      json = decoded.to_json
+
+      # Print the JSON object
+      puts json
+    end
+  end
+}
+# end