nonacat 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 64443b38f33c777d82e6348617f50ec2df383c2132f56fdc5ace21f913d8f0b4
+  data.tar.gz: 28918752d3adac56bf5858d16be3b0e8723d440aa6c218ccf7136abdc5c52e65
+SHA512:
+  metadata.gz: afd3f0c68d1a65d9a5aeb80d9d01fc46ab18034e57df08ed2c8325e5030afc2a1c18ef88741ee45085c6fb8f378e344015d234240bbb89545d5e865dddf89afb
+  data.tar.gz: 1af24f360628d1e8512e771c41b2263126a69be7ba8de658ecf6b8df1b97031d99c583a33d5efac9048086b81557fafce10d470338896d54142dfd8837943af2

data/.yardopts

@@ -0,0 +1,5 @@
+--main README.md
+--markup=markdown
+--markup-provider=redcarpet
+--no-private
+lib/**/*.rb

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Ethan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,197 @@
+# Nonacat
+
+A Github API client - unofficial, unaffiliated
+
+Nonacat uses [Scorpio](https://github.com/notEthan/scorpio) with [Github's OpenAPI description](https://github.com/github/rest-api-description) to be a client to the service. Nonacat builds a small amount of infrastructure to simplify things like authentication and pagination, but otherwise relies wholly on the OpenAPI document for implementation of the client.
+
+## Usage
+
+Nonacat is built on [Scorpio](https://github.com/notEthan/scorpio), which adds functionality to an OpenAPI document, letting the document be used as a client to the service it describes. Scorpio is in turn built on [JSI](https://github.com/notEthan/jsi). Some familiarity with both is useful in using Nonacat. Nonacat's own codebase is very small - Github's [octokit.rb](https://github.com/octokit/octokit.rb) is currently about 22,000 lines of code; Nonacat is about 100.
+
+### Caveats
+
+Github's OpenAPI description is quite large - 11 MB as of this writing, and the whole thing is loaded and instantiated as the client. This can be unwieldy if you do things that iterate the whole document. For example, on my machine inspecting the document (`Nonacat::GITHUB_API.inspect`) takes a full 3 minutes (though only the first time; subsequent calls are much faster as computations are cached). This is a problem if, for example, you call a method that does not exist on a node in the document; when a `NoMethodError` is raised, the receiver is inspected, resulting in an error message that is very large and slow to generate.
+
+### Authentication
+
+Github authentication credentials, which are documented at <https://docs.github.com/en/rest/authentication>, are passed to [Faraday::Request::Authorization](https://rubydoc.info/gems/faraday/Faraday/Request/Authorization) from {Nonacat.authorization}.
+
+Authentication typically looks like:
+
+```ruby
+Nonacat.authorization = ['Bearer', 'github_pat_2kxqIkfByCRkCGT2...']
+# or
+Nonacat.authorization = [:basic, 'notEthan', 'p4$$w0rd']
+```
+
+### Operations
+
+Requests to the API are made using an OpenAPI Operation (a [`Scorpio::OpenAPI::Operation`](https://rubydoc.info/gems/scorpio/Scorpio/OpenAPI/Operation)), a part of the OpenAPI description that describes the form of the request and response. An operation can be identified by a templated path and HTTP method, or by id (the `operationId` property of the operation).
+
+For example, the operation to [get a repository](https://docs.github.com/en/rest/repos/repos?apiVersion=2022-11-28#get-a-repository) is a HTTP get request to `/repos/{owner}/{repo}`, accessed in the OpenAPI document like so:
+
+```ruby
+get_repo_operation = Nonacat::GITHUB_API.paths['/repos/{owner}/{repo}'].get
+```
+
+Its id is `repos/get` (from `get_repo_operation.operationId`). You can use such an id to retrieve an operation, e.g. `Nonacat::GITHUB_API.operations['repos/get']`. Finding the id of an operation can be slightly inconvenient as it is not included on Github's HTML pages of API documentation. Available `operationId`s can be iterated with e.g. `Nonacat::GITHUB_API.operations.map(&:operationId)` or `Nonacat::GITHUB_API.operations.tagged("gists").map(&:operationId)`.
+
+### `nonacat` executable
+
+Nonacat includes an executable `nonacat`, which is just IRB with nonacat loaded and some additions for convenience:
+
+- Authentication is loaded from the same source as the github [`gh` CLI](https://cli.github.com/), if available.
+- Tab-completable references to operations are defined. Github's operations are categorized, e.g. the `repos/get` operation with category `repos`. The `nonacat` executable defines constants like `Nonacat::REPOS` for each category, which in turn contain constants for each operation. With these, `Nonacat::REPOS::GET` refers to the same operation as `Nonacat::GITHUB_API.operations['repos/get']`.
+
+### Links
+
+Many Github resources link to other resources with inline URLs, e.g. a repo resource has a `forks_url` property linking to the `repos/list-forks` operation's path. Nonacat extends these URLs with {Nonacat::Link} and the linked resource can be retrieved with `#get`, e.g. `forks = my_repo.forks_url.get`. (See the example "Get linked repository forks" below.)
+
+### Pagination
+
+Many Github API operations paginate results. {Nonacat.paginate_items} abstracts pagination - see its method doc, and examples below.
+
+### Examples
+
+- Get Zen (no auth required)
+
+```ruby
+Nonacat::GITHUB_API.operations["meta/get-zen"].run
+# => "Non-blocking is better than blocking."
+```
+
+- Get repository
+
+```
+repo = Nonacat::GITHUB_API.operations["repos/get"].run(owner: 'notEthan', repo: 'scorpio')
+```
+
+Returns (trimmed)
+
+```
+#{<JSI (Nonacat::Github::FullRepository)>
+  "id" => 69611598,
+  "name" => "scorpio",
+  "full_name" => "notEthan/scorpio",
+  "owner" => #{<JSI (Nonacat::Github::SimpleUser)>
+    "login" => "notEthan",
+  },
+  "url" => #<JSI (Nonacat::Github::FullRepository.properties["url"]) "https://api.github.com/repos/notEthan/scorpio">,
+  "forks_url" => #<JSI (Nonacat::Github::FullRepository.properties["forks_url"]) "https://api.github.com/repos/notEthan/scorpio/forks">,
+  "language" => "Ruby",
+}
+```
+
+- Get linked repository forks (using `repo` from previous example)
+
+```
+forks = repo.forks_url.get
+```
+
+That connects the `forks_url` to the `repos/list-forks` operation, essentially running `forks = Nonacat.operations["repos/list-forks"].run(owner: 'notEthan', repo: 'scorpio')`
+
+Returns (trimmed)
+
+```
+#[<JSI (Nonacat::Github.paths["/repos/{owner}/{repo}/forks"].get.responses["200"].content["application/json"].schema)>
+  #{<JSI (Nonacat::Github::MinimalRepository)>
+    "id" => 86715358,
+    "name" => "scorpio",
+    "full_name" => "mathieujobin/scorpio",
+    "owner" => #{<JSI (Nonacat::Github::SimpleUser)>
+      "login" => "mathieujobin",
+    },
+    "fork" => true,
+    "url" => #<JSI (Nonacat::Github::MinimalRepository.properties["url"]) "https://api.github.com/repos/mathieujobin/scorpio">,
+    "forks_url" => #<JSI (Nonacat::Github::MinimalRepository.properties["forks_url"]) "https://api.github.com/repos/mathieujobin/scorpio/forks">,
+    "language" => "Ruby",
+  }
+]
+```
+
+- Search code, paginated (requires auth) - this pauses between each item; press enter to continue or `q` + enter to quit.
+
+```ruby
+Nonacat.paginate_items('search/code', q: 'nonacat', per_page: 4) do |item|
+  pp(item)
+  break if gets.chomp == 'q'
+end
+```
+
+Output (trimmed):
+
+```
+#{<JSI (Nonacat::Github::CodeSearchResultItem)>
+  "name" => "nonacat.rb",
+  "path" => "lib/nonacat.rb",
+  "url" => #<JSI (Nonacat::Github::CodeSearchResultItem.properties["url"])
+    "https://api.github.com/repositories/898892904/contents/lib/nonacat.rb?ref=a253ff2a2c9b1229f2feea63f22a6ba7b21d1dd3"
+  >,
+  "repository" => #{<JSI (Nonacat::Github::MinimalRepository)>
+    "name" => "nonacat",
+    "full_name" => "notEthan/nonacat",
+    "owner" => #{<JSI (Nonacat::Github::SimpleUser)>
+      "login" => "notEthan",
+    },
+    "html_url" => #<JSI (Nonacat::Github::MinimalRepository.properties["html_url"])
+      "https://github.com/notEthan/nonacat"
+    >,
+  },
+  "score" => 1.0
+}
+```
+
+- Create a gist
+
+```ruby
+gist = Nonacat::GITHUB_API.operations['gists/create'].run(
+  body_object: {
+    description: "test #{rand(1000)}",
+    files: {
+      'foo.rb' => {content: 'require "nonacat"'}
+    },
+    public: true,
+  }
+)
+```
+
+Returns (trimmed)
+
+```
+#{<JSI (Nonacat::Github::GistSimple)>
+  "url" => "https://api.github.com/gists/729cbe8c58e7698702af6a5c51d45725",
+  "html_url" => "https://gist.github.com/notEthan/729cbe8c58e7698702af6a5c51d45725",
+  "files" => #{<JSI (Nonacat::Github::GistSimple.properties["files"])>
+    "foo.rb" => #{<JSI (Nonacat::Github::GistSimple.properties["files"].additionalProperties)>
+      "filename" => "foo.rb",
+      "language" => "Ruby",
+      "content" => "require \"nonacat\"",
+    }
+  },
+  "description" => "test 3",
+  "owner" => #{<JSI (Nonacat::Github::SimpleUser)>
+    "login" => "notEthan",
+  },
+}
+```
+
+- Get the date when each tag in a repo was committed - this uses pagination, and nests API calls; getting rate limited is possible on a repository with many tags.
+
+```ruby
+Nonacat.paginate_items("repos/list-tags", owner: 'notEthan', repo: 'nonacat').map do |tag|
+  {
+    name: tag.name,
+    # tag.commit includes very little; its `url` links to get the full commit resource
+    date: tag.commit.url.get.commit.committer.date,
+  }
+end
+```
+
+## Development
+
+- git clone
+- `bin/nonacat_update` to fetch the latest Github OpenAPI document, if needed
+
+## License
+
+The gem is available under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/nonacat

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require('nonacat')
+
+
+# name Nonacat::<CATEGORY NAME>, Nonacat::<CATEGORY NAME>::<OPERATION NAME>, and Nonacat::<CATEGORY NAME>.<operation name> for irb tab-completable operation access
+
+category_namespaces = Hash.new do |h, category|
+  category_namespace = Module.new { define_singleton_method(:category) { category } }
+  Nonacat.define_singleton_method(category.tr('-', '_')) { category_namespace }
+  Nonacat.const_set(category.tr('-', '_').upcase, category_namespace)
+  h[category] = category_namespace
+end
+
+Nonacat::GITHUB_API.operations.each do |operation|
+  category, name = operation.operationId.match(%r(\A([\w-]+)/([\w-]+)\z)).captures
+  category_namespaces[category].const_set(name.tr('-', '_').upcase, operation)
+  category_namespaces[category].define_singleton_method(name.tr('-', '_')) { operation }
+end
+
+
+proc do
+  # authorization from ~/.config/gh/hosts.yml, as used by gh-cli
+  gh_hosts_path = Pathname.new('~').expand_path.join('.config/gh/hosts.yml')
+  next unless gh_hosts_path.exist?
+  hosts = YAML.safe_load_file(gh_hosts_path)
+
+  # TODO not great
+  gh = hosts['github.com'] || next
+  token = gh['oauth_token'] || gh['users']&.values&.first&.[]('oauth_token') || next
+
+  Nonacat.authorization = ['Bearer', token]
+end[]
+
+
+require('irb')
+IRB.start(__FILE__)

data/bin/nonacat_update

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+# Fetch Github's OpenAPI document from git ref ARGV[0] or the current `main` branch of https://github.com/github/rest-api-description
+# For the gem, store the JSON compressed with zlib since, at 11 MB, it is rather excessive.
+# For development, store the YAML for readability.
+
+require('pathname')
+require('fileutils')
+require('net/http')
+require('zlib')
+require('json')
+require('yaml')
+
+api_dir = Pathname.new(__dir__).join('../github-rest-api-description')
+
+def get_body(url)
+  response = Net::HTTP.get_response(URI(url))
+  raise("#{url} responded status: #{response.code}, body: #{response.body}") if !response.is_a?(Net::HTTPSuccess)
+  response.body
+end
+
+ref = ARGV[0] || 'main'
+commit = JSON.parse(get_body("https://api.github.com/repos/github/rest-api-description/commits/#{ref}"))
+
+at_latest = (api_dir / 'updated.yml').exist? && YAML.safe_load_file(api_dir / 'updated.yml')['sha'] == commit['sha']
+
+# copy from github
+ghcp = proc do |local_path, github_path, zz: false|
+  if at_latest && (api_dir / local_path).exist?
+    STDERR.puts("#{api_dir / local_path} already up to date at commit #{commit['sha']}; skipping")
+    next
+  end
+  STDERR.puts("fetching #{local_path}")
+  # getting this from the API is another option but it doesn't gzip so much slower
+  # at: "https://api.github.com/repos/github/rest-api-description/contents/#{github_path}?ref=#{commit['sha']}"
+  # with accept: 'application/vnd.github.raw'
+  url = "https://raw.githubusercontent.com/github/rest-api-description/#{commit['sha']}/#{github_path}"
+  FileUtils.mkdir_p((api_dir / local_path).dirname)
+  content = get_body(url)
+  content = Zlib.deflate(content) if zz
+  (api_dir / local_path).write(content)
+end
+
+ghcp['LICENSE.md', 'LICENSE.md']
+ghcp['api.github.com.oas-3-0.json.zz', 'descriptions/api.github.com/api.github.com.json', zz: true]
+ghcp['api.github.com.oas-3-1.json.zz', 'descriptions-next/api.github.com/api.github.com.json', zz: true]
+# the YAML can be useful to browse for development but is excluded from the gem and git repo due to size
+ghcp['api.github.com.oas-3-0.yaml', 'descriptions/api.github.com/api.github.com.yaml']
+ghcp['api.github.com.oas-3-1.yaml', 'descriptions-next/api.github.com/api.github.com.yaml']
+
+(api_dir / 'updated.yml').write(YAML.dump({
+  'comment' => "The commit from which other files in this directory were updated (using bin/nonacat_update)",
+  'sha' => commit['sha'],
+  'date' => commit['commit']['committer']['date'],
+}))
+
+STDERR.puts("updated!")

data/github-rest-api-description/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 GitHub
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/github-rest-api-description/updated.yml

@@ -0,0 +1,4 @@
+---
+comment: The commit from which other files in this directory were updated (using bin/nonacat_update)
+sha: 4ab8513682637010cd3bb5d8ee3227cc5ce739d1
+date: '2024-12-06T13:11:37Z'

data/lib/nonacat/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Nonacat
+  VERSION = "0.0.1"
+end

data/lib/nonacat.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require("nonacat/version")
+require("scorpio")
+require("pathname")
+require("zlib")
+require("faraday/follow_redirects")
+
+module Nonacat
+  # a module for JSI instances whose content is a URL corresponding to an operation of the OpenAPI description
+  module Link
+    # see [JSI::Base](https://rubydoc.info/gems/jsi/JSI/Base#jsi_as_child_default_as_jsi-instance_method)
+    def jsi_as_child_default_as_jsi
+      !jsi_node_content.nil?
+    end
+
+    def get(**conf, &b)
+      get_request(**conf, &b).run
+    end
+
+    # @return [Scorpio::Request]
+    def get_request(**conf, &b)
+      uri = JSI::URI[self]
+      conf[:query_params] = [uri.query_values, conf.delete(:query_params), conf.delete('query_params')].inject(nil) { |c, p| c ? p ? c.merge(p) : c : p }
+      GITHUB_API.operations.each do |operation|
+        next if !operation.get?
+        path_params = operation.uri_template.extract(operation.base_url.join(uri.merge(query: nil))) || next
+        conf[:path_params] = [conf.delete(:path_params), conf.delete('path_params')].inject(path_params) { |c, p| p ? c.merge(p) : c }
+        return operation.build_request(**conf, &b)
+      end
+      raise("no operation matched url: #{jsi_node_content}")
+    end
+  end
+
+  oass = ['3-0', '3-1']
+  oas = !ENV['NC_OAS'] ? oass.first : oass.include?(ENV['NC_OAS']) ? ENV['NC_OAS'] : abort("expected env NC_OAS in #{oass.join(', ')}")
+  GITHUB_API_PATH = Pathname.new(__dir__).join(-"../github-rest-api-description/api.github.com.oas-#{oas}.json.zz")
+
+  # A [Scorpio::OpenAPI::Document](https://rubydoc.info/gems/scorpio/Scorpio/OpenAPI/Document) for Github's API
+  GITHUB_API = Scorpio.new_document(
+    JSON.parse(Zlib.inflate(GITHUB_API_PATH.read)),
+    after_initialize: proc do |node|
+      # Name schema components like Github::CodeSearchResultItem, Github::Repository, etc.
+      if node.jsi_is_schema? && !node.jsi_schema_module_name
+        if node.jsi_ptr.parent == JSI::Ptr['components', 'schemas']
+          const_name = JSI::Util::Private.const_name_from_parts(node.jsi_ptr.tokens.last.to_s.split(/[_-]/)) # TODO shouldn't use JSI privates
+          Github.const_set(const_name, node.jsi_schema_module) if const_name && !Github.constants.include?(const_name.to_sym)
+        end
+      end
+
+      node_describes_url = node.jsi_is_schema? && (
+        node.keyword_value?('format', 'uri') ||
+        (node.keyword_value?('type', 'string') && (
+          (node.jsi_ptr.tokens.last.respond_to?(:to_str) && node.jsi_ptr.tokens.last =~ /_url\z/) ||
+          (node.example.respond_to?(:to_str) && node.example['://']))))
+      if node_describes_url
+        node.jsi_schema_module.include(Nonacat::Link)
+      end
+    end,
+  )
+
+  Github = GITHUB_API.jsi_schema_module_connection
+  module Github end
+
+  GITHUB_API.faraday_builder = proc do |conn|
+    conn.request(:authorization, *Nonacat.authorization) if Nonacat.authorization
+    conn.use(Faraday::FollowRedirects::Middleware)
+  end
+
+  class << self
+    # Authorization params passed to [Faraday::Request::Authorization](https://rubydoc.info/gems/faraday/Faraday/Request/Authorization).
+    #
+    #     Nonacat.authorization = ['Bearer', 'github_pat_2kxqIkfByCRkCGT2...']
+    #     Nonacat.authorization = [:basic, 'notEthan', 'p4$$w0rd']
+    attr_accessor(:authorization)
+
+    # Yields each item in each page of results from the indicated operation.
+    #
+    # @param operation [String, Scorpio::OpenAPI::Operation] an operationId or an Operation
+    # @param ratelimit [Boolean] {.ratelimit} each response
+    # @yield [JSI::Base] each item in each page of results
+    # @return [nil, Enumerator]
+    def paginate_items(operation, ratelimit: true, **conf, &block)
+      return to_enum(__method__, operation, **conf) unless block_given?
+      operation = operation.is_a?(Scorpio::OpenAPI::Operation) ? operation : GITHUB_API.operations[operation]
+      operation.each_link_page(**conf) do |page_ur|
+        if page_ur.response.body_object.respond_to?(:to_ary)
+          page_ur.response.body_object.each(&block)
+        elsif page_ur.response.body_object.respond_to?(:to_hash) && page_ur.response.body_object.key?('items') && page_ur.response.body_object['items'].respond_to?(:to_ary)
+          page_ur.response.body_object['items'].each(&block)
+        else
+          raise("pagination not detected in operation response.\noperation: #{operation.pretty_inspect.chomp}\nresponse ur: #{page_ur.pretty_inspect.chomp}")
+        end
+        Nonacat.ratelimit(page_ur) if ratelimit
+      end
+    end
+
+    # If the given ur's response indicates insufficent remaining ratelimit, sleep until limit will reset
+    def ratelimit(ur)
+      if ur.response.headers['x-ratelimit-remaining'] && Float(ur.response.headers['x-ratelimit-remaining']) <= 1 && ur.response.headers['x-ratelimit-reset']
+        sleep(1 + (Time.at(Float(ur.response.headers['x-ratelimit-reset'])) - Time.now))
+      end
+      ur
+    end
+  end
+end

data/nonacat.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "lib/nonacat/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "nonacat"
+  spec.version = Nonacat::VERSION
+  spec.authors = ["Ethan"]
+  spec.email = ["ethan@unth.net"]
+
+  spec.summary = "A Github API client - unofficial, unaffiliated"
+  spec.description = "Nonacat builds from Github's OpenAPI description using the gem `scorpio` to offer an alternative client to Github's REST API."
+  spec.homepage = "https://github.com/notEthan/nonacat"
+  spec.license = "MIT"
+
+  spec.files = [
+    'LICENSE.txt',
+    'README.md',
+    '.yardopts',
+    'nonacat.gemspec',
+    *Dir['lib/**/*'],
+    'github-rest-api-description/LICENSE.md',
+    *Dir['github-rest-api-description/api.github.com.*.json.zz'],
+    'github-rest-api-description/updated.yml',
+  ].reject { |f| File.lstat(f).ftype == 'directory' }
+
+  spec.require_paths = ["lib"]
+  spec.bindir        = 'bin'
+  spec.executables   = ['nonacat', 'nonacat_update']
+
+  spec.add_dependency('scorpio', '~> 0.7')
+  spec.add_dependency('faraday-follow_redirects')
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: nonacat
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ethan
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-06-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: scorpio
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: faraday-follow_redirects
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Nonacat builds from Github's OpenAPI description using the gem `scorpio`
+  to offer an alternative client to Github's REST API.
+email:
+- ethan@unth.net
+executables:
+- nonacat
+- nonacat_update
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- LICENSE.txt
+- README.md
+- bin/nonacat
+- bin/nonacat_update
+- github-rest-api-description/LICENSE.md
+- github-rest-api-description/api.github.com.oas-3-0.json.zz
+- github-rest-api-description/api.github.com.oas-3-1.json.zz
+- github-rest-api-description/updated.yml
+- lib/nonacat.rb
+- lib/nonacat/version.rb
+- nonacat.gemspec
+homepage: https://github.com/notEthan/nonacat
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: A Github API client - unofficial, unaffiliated
+test_files: []