bskyrb 0.4 → 0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3ebcdf8ed7dabe9c22cf650ffecec5c8883d72b32c29baae4a44f40f94365bd
-  data.tar.gz: d3ad042fa4d4a1b2e62e53ca2aae552078b7aa3f78f1c612b1a6fc568f3b0c61
+  metadata.gz: 0446dc11827c6a05fef76c05c2e6a8352c0d22aca38596b38829a992905f3724
+  data.tar.gz: bb1388b216c99ec84219439b087b74f43d39bb27bc7b6a8bb40c2cc73791c11e
 SHA512:
-  metadata.gz: 8e6ab71de741b377398c4a651d3b34406b0f1c0fa3d5c1d9c3721976dacec12146ecf8900a9a33a38feaf75f2db45320723e5f1967587456d1200b16d2fe7130
-  data.tar.gz: a022a0f04a37a4c4be4dab37fa9a9d2e348f3ff0c541ae02a8422ec3149d466d900465c90f834c0811163b12f43fde4789288607ce7d1a2faf0b4b2fc7efcaed
+  metadata.gz: f0c77673776705697470560d6142ba51f0f88d0cfd81d536af44cba856bd82ad271c9a7ab5446af463dd1f930e1f54b0a49354bd9f8fae208a8df65a71b2adb3
+  data.tar.gz: 38939c101cc5f0eee20f9ddf52ef1da5ded8bef79654ef7a6f04f45f311c7771c27322e2c2137869c2202f3899ba22fc52ec64e0524d896821394e2e34dd102d

data/lib/bskyrb/codegen.rb

@@ -0,0 +1,211 @@
+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/firehose.rb

@@ -0,0 +1,39 @@
+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
+
+    begin
+      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
+} 
+# end