tsumanne 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cebc96065c92a00109bc21cce1738bbe6d0d9576abeca0b7ee1915cce48da1c4
+  data.tar.gz: ceab470a37553e4a9811047a4c29deaa048deffb621ae592c4976199067fb306
+SHA512:
+  metadata.gz: 288fc7f85c1999d509dea4c74797aaaa968caf340fbc657de50ab69b6708c9d30a7b3bc2f2a6e86ac5a19b40ac5ea4b9f5d4dc2bdcc93849856a0d5e0c827a32
+  data.tar.gz: aca354d1cef58425efc27c76d0bb839a12441cb8f93b345de0ee5e6c725f6f1a642cf2a16986a6fca18055117d8360ab5112df0538a95088c0745f5091dfbce4

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,32 @@
+inherit_gem:
+  rubocop-sorbet: config/rbi.yml
+
+require:
+ - rubocop-rake
+ - rubocop-rspec
+ - rubocop-performance
+
+AllCops:
+  TargetRubyVersion: 3.2
+  NewCops: enable
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120
+
+Metrics/MethodLength:
+  Max: 15
+
+Lint/EmptyFile:
+  Exclude:
+    - 'sorbet/rbi/gems/*.rbi'
+
+Gemspec:
+  Enabled: true

data/.ruby-version

@@ -0,0 +1 @@
+3.2.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 eggplants
+
+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,31 @@
+# Tsumanne
+
+API Wrapper for tsumanne.net
+
+## Installation
+
+```bash
+gem install tsumanne
+```
+
+## Usage
+
+See: [`spec/tsumanne_spec.rb`](spec/tsumanne_spec.rb)
+
+## Development
+
+```bash
+# install dependencies
+bundle
+
+# check code with linter / formatter && run tests
+rake
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/eggplants/tsumanne.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://github.com/eggplants/tsumanne/blob/master/LICENSE.txt).

data/Rakefile

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new do |task|
+  task.requires << 'rubocop-sorbet'
+end
+
+namespace :sorbet do
+  desc 'Type-checking with sorbet'
+  task :check do
+    system("bundle exec srb tc -v")
+  end
+
+  desc 'Type-checking and auto-fix correctable errors with sorbet'
+  task :autocorrect do
+    system("bundle exec srb tc --autocorrect -v")
+  end
+end
+
+namespace :tapioca do
+  desc 'Generate RBI from gems with tapioca'
+  task :gen do
+    system("bundle exec tapioca gem --all")
+  end
+
+  desc 'Check duplicated definitions exists in shim RBIs with tapioca'
+  task :check_shims do
+    system("bundle exec tapioca check-shims")
+  end
+end
+
+task :default do
+   %i[spec rubocop:autocorrect_all sorbet:autocorrect tapioca:check_shims].each do
+     puts ".｡*ﾟ+.*.｡　　#{?\s * _1.size}　　ﾟ+..｡*ﾟ+"
+     puts ".｡*ﾟ+.*.｡　　#{_1}　　ﾟ+..｡*ﾟ+"
+     puts ".｡*ﾟ+.*.｡　　#{?\s * _1.size}　　ﾟ+..｡*ﾟ+"
+     Rake::Task[_1].execute
+   end
+end

data/lib/tsumanne/version.rb

@@ -0,0 +1,7 @@
+# typed: strict
+
+# frozen_string_literal: true
+
+module Tsumanne
+  VERSION = "0.0.0"
+end

data/lib/tsumanne.rb

@@ -0,0 +1,128 @@
+# typed: strict
+
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require "zlib"
+
+require "mhtml"
+require "sorbet-runtime"
+
+require_relative "tsumanne/version"
+
+# API module for tsumanne.net includes knowledge as const.
+module Tsumanne
+  extend T::Sig
+
+  # API endpoint of tsumanne.net.
+  BASE_URL = "https://tsumanne.net/"
+
+  # Valid Board Identifiers.
+  BOARD_IDS = T.let({ img: "si", may: "my", jun: "tj", dat: "sa", special: "sp" }.freeze, T::Hash[Symbol, String])
+  # Corresponing orders to list indexes. (`index` is same as `category`)
+  INDEXES_ORDERS = T.let({ hira: "↓あ", newer: "↓新" }.freeze, T::Hash[Symbol, String])
+
+  class Error < StandardError; end
+
+  # API to get information fron tsumanne.net
+  class API
+    extend T::Sig
+
+    sig{ returns(String) }
+    attr_reader :board_id
+
+    sig { params(board_id: Symbol).void }
+    def initialize(board_id:)
+      @board_id = T.let(T.must(BOARD_IDS[board_id]), String)
+    end
+
+    sig { params(index: String, page: Integer).returns(T::Hash[String, T.untyped]) }
+    def get_threads(index: "all", page: 1)
+      # https://tsumanne.net/si/all/1
+      # https://tsumanne.net/si/hoge/1
+      fetch_json(paths: [index, page.to_s])
+    end
+
+    sig { params(thread_id: String).returns(Mhtml::RootDocument) }
+    def get_thread_mht(thread_id)
+      # https://tsumanne.net/si/mht.php?id=129691
+      res = fetch_json(paths: ["mht.php"], query: { id: thread_id }, method: :get_response)
+      mht_gz = fetch(paths: [T.let(res["path"], String)])
+      # https://ksef-3go.hatenadiary.org/entry/20070924/1190563143
+      # https://docs.ruby-lang.org/ja/latest/method/Zlib=3a=3aInflate/s/new.html
+      zstream = Zlib::Inflate.new(Zlib::MAX_WBITS + 32)
+      buf = zstream.inflate(mht_gz)
+      zstream.finish
+      zstream.close
+      Mhtml::RootDocument.new(buf)
+    end
+
+    sig { params(thread_path: String).returns(T.nilable(Mhtml::RootDocument)) }
+    def get_thread_from_path(thread_path)
+      # https://tsumanne.net/si/data/2023/08/30/8883354/
+      match_data = %r{^\d{4}/\d{2}/\d{2}/(?<thread_id>\d+)$}.match(thread_path)
+      return if match_data.nil?
+      get_thread_mht(T.must(match_data[:thread_id]))
+    end
+
+    sig { params(uri: URI).returns(T::Hash[String, T.untyped]) }
+    def search_thread_from_uri(uri)
+      # https://tsumanne.net/si/indexes.php?format=json&w=&sbmt=URL
+      fetch_json(paths: ["indexes.php"], query: { w: uri, sbmt: :URL })
+    end
+
+    sig { params(keyword: T.nilable(String), order: Symbol, page: Integer).returns(T::Hash[String, T.untyped]) }
+    def search_indexes(keyword: nil, order: :newer, page: 1)
+      # https://tsumanne.net/si/indexes.php?format=json&w=&sbmt=URL
+      # https://tsumanne.net/si/indexes.php?format=json&w=&sbmt=%E2%86%93%E6%96%B0
+      fetch_json(paths: ["indexes.php"], query: { w: keyword, sbmt: INDEXES_ORDERS[order], p: page })
+    end
+
+    sig { params(uri: URI, indexes: T.nilable(T::Array[String])).returns(T::Hash[String, T.untyped]) }
+    def register_thread(uri, indexes: nil)
+      # post, https://tsumanne.net/si/input.php?format=json&url=...&category=...
+      fetch_json(paths: ["input.php?format=json"], query: { url: uri, category: (indexes || []).join(",") }, method: :post)
+    end
+
+    private
+
+    sig do
+      params(paths: T.nilable(T::Array[String]),
+             query: T.nilable(T::Hash[Symbol, T.any(Integer, String, Symbol)]),
+             method: Symbol).returns(T.nilable(String))
+    end
+    def fetch(paths: nil, query: nil, method: :get)
+      uri = join_paths(BASE_URL, [@board_id] + (paths || []))
+      query = URI.encode_www_form(query || {})
+
+      case method
+      when :get
+        uri.query = query
+        Net::HTTP.get(uri)
+      when :get_response
+        uri.query = query
+        Net::HTTP.get_response(uri).body
+      when :post
+        Net::HTTP.post(uri, query).body
+      end
+    end
+
+    sig do
+      params(paths: T.nilable(T::Array[String]),
+             query: T.nilable(T::Hash[Symbol, T.any(Integer, String, Symbol)]),
+             method: Symbol).returns(T::Hash[String, T.untyped])
+    end
+    def fetch_json(paths: nil, query: nil, method: :get)
+      query ||= {}
+      json = fetch(paths:, query: query.merge({ format: :json }), method:)
+      JSON.parse(T.must(json))
+    end
+
+    sig { params(base: String, paths: T::Array[String]).returns(URI::Generic) }
+    def join_paths(base, *paths)
+      URI.parse(T.must(([base] + paths).reduce { File.join(_1, _2) }))
+    end
+  end
+end

data/sorbet/config

@@ -0,0 +1,4 @@
+--dir
+.
+--ignore=tmp/
+--ignore=vendor/

data/sorbet/rbi/annotations/rainbow.rbi

@@ -0,0 +1,269 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Rainbow
+  # @shim: https://github.com/sickill/rainbow/blob/master/lib/rainbow.rb#L10-L12
+  sig { returns(T::Boolean) }
+  attr_accessor :enabled
+
+  class Color
+    sig { returns(Symbol) }
+    attr_reader :ground
+
+    sig { params(ground: Symbol, values: T.any([Integer], [Integer, Integer, Integer])).returns(Color) }
+    def self.build(ground, values); end
+
+    sig { params(hex: String).returns([Integer, Integer, Integer]) }
+    def self.parse_hex_color(hex); end
+
+    class Indexed < Rainbow::Color
+      sig { returns(Integer) }
+      attr_reader :num
+
+      sig { params(ground: Symbol, num: Integer).void }
+      def initialize(ground, num); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+    end
+
+    class Named < Rainbow::Color::Indexed
+      NAMES = T.let(nil, T::Hash[Symbol, Integer])
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+
+    class RGB < Rainbow::Color::Indexed
+      sig { returns(Integer) }
+      attr_reader :r, :g, :b
+
+      sig { params(ground: Symbol, values: Integer).void }
+      def initialize(ground, *values); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+
+      sig { params(value: Numeric).returns(Integer) }
+      def self.to_ansi_domain(value); end
+    end
+
+    class X11Named < Rainbow::Color::RGB
+      include Rainbow::X11ColorNames
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(String) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+  end
+
+  sig { returns(Wrapper) }
+  def self.global; end
+
+  sig { returns(T::Boolean) }
+  def self.enabled; end
+
+  sig { params(value: T::Boolean).returns(T::Boolean) }
+  def self.enabled=(value); end
+
+  sig { params(string: String).returns(String) }
+  def self.uncolor(string); end
+
+  class NullPresenter < String
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def bg(*values); end
+
+    sig { returns(NullPresenter) }
+    def reset; end
+
+    sig { returns(NullPresenter) }
+    def bright; end
+
+    sig { returns(NullPresenter) }
+    def faint; end
+
+    sig { returns(NullPresenter) }
+    def italic; end
+
+    sig { returns(NullPresenter) }
+    def underline; end
+
+    sig { returns(NullPresenter) }
+    def blink; end
+
+    sig { returns(NullPresenter) }
+    def inverse; end
+
+    sig { returns(NullPresenter) }
+    def hide; end
+
+    sig { returns(NullPresenter) }
+    def cross_out; end
+
+    sig { returns(NullPresenter) }
+    def black; end
+
+    sig { returns(NullPresenter) }
+    def red; end
+
+    sig { returns(NullPresenter) }
+    def green; end
+
+    sig { returns(NullPresenter) }
+    def yellow; end
+
+    sig { returns(NullPresenter) }
+    def blue; end
+
+    sig { returns(NullPresenter) }
+    def magenta; end
+
+    sig { returns(NullPresenter) }
+    def cyan; end
+
+    sig { returns(NullPresenter) }
+    def white; end
+
+    sig { returns(NullPresenter) }
+    def bold; end
+
+    sig { returns(NullPresenter) }
+    def dark; end
+
+    sig { returns(NullPresenter) }
+    def strike; end
+  end
+
+  class Presenter < String
+    TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer])
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def bg(*values); end
+
+    sig { returns(Presenter) }
+    def reset; end
+
+    sig { returns(Presenter) }
+    def bright; end
+
+    sig { returns(Presenter) }
+    def faint; end
+
+    sig { returns(Presenter) }
+    def italic; end
+
+    sig { returns(Presenter) }
+    def underline; end
+
+    sig { returns(Presenter) }
+    def blink; end
+
+    sig { returns(Presenter) }
+    def inverse; end
+
+    sig { returns(Presenter) }
+    def hide; end
+
+    sig { returns(Presenter) }
+    def cross_out; end
+
+    sig { returns(Presenter) }
+    def black; end
+
+    sig { returns(Presenter) }
+    def red; end
+
+    sig { returns(Presenter) }
+    def green; end
+
+    sig { returns(Presenter) }
+    def yellow; end
+
+    sig { returns(Presenter) }
+    def blue; end
+
+    sig { returns(Presenter) }
+    def magenta; end
+
+    sig { returns(Presenter) }
+    def cyan; end
+
+    sig { returns(Presenter) }
+    def white; end
+
+    sig { returns(Presenter) }
+    def bold; end
+
+    sig { returns(Presenter) }
+    def dark; end
+
+    sig { returns(Presenter) }
+    def strike; end
+  end
+
+  class StringUtils
+    sig { params(string: String, codes: T::Array[Integer]).returns(String) }
+    def self.wrap_with_sgr(string, codes); end
+
+    sig { params(string: String).returns(String) }
+    def self.uncolor(string); end
+  end
+
+  VERSION = T.let(nil, String)
+
+  class Wrapper
+    sig { returns(T::Boolean) }
+    attr_accessor :enabled
+
+    sig { params(enabled: T::Boolean).void }
+    def initialize(enabled = true); end
+
+    sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) }
+    def wrap(string); end
+  end
+
+  module X11ColorNames
+    NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]])
+  end
+end
+
+sig { params(string: String).returns(Rainbow::Presenter) }
+def Rainbow(string); end