From 11b6e7ff395f6767336cd74054c0ccb22585c00f Mon Sep 17 00:00:00 2001 From: HASUMI Hitoshi Date: Mon, 8 Jan 2024 15:49:14 +0900 Subject: [PATCH] update --- Rakefile | 10 +- _data/sidebars/picoruby_sidebar.yml | 111 +++++++++--------- lib/rbs_doc/generator.rb | 6 +- pages/rbs_doc/ADC.md | 18 +-- pages/rbs_doc/AHT25.md | 8 +- pages/rbs_doc/AQM0802A.md | 14 +-- pages/rbs_doc/Array.md | 118 +++++++++---------- pages/rbs_doc/BLE.md | 30 ++--- pages/rbs_doc/BLE_AdvertisingData.md | 4 +- pages/rbs_doc/BLE_AdvertisingReport.md | 18 +-- pages/rbs_doc/BLE_Broadcaster.md | 2 +- pages/rbs_doc/BLE_Central.md | 28 ++--- pages/rbs_doc/BLE_GattDatabase.md | 28 ++--- pages/rbs_doc/BLE_Observer.md | 2 +- pages/rbs_doc/BLE_Peripheral.md | 6 +- pages/rbs_doc/CYW43.md | 5 - pages/rbs_doc/CYW43_GPIO.md | 4 +- pages/rbs_doc/DebounceBase.md | 6 +- pages/rbs_doc/DebounceNone.md | 2 +- pages/rbs_doc/DebouncePerKey.md | 2 +- pages/rbs_doc/DebouncePerRow.md | 2 +- pages/rbs_doc/DipSwitch.md | 4 +- pages/rbs_doc/Dir.md | 19 ++- pages/rbs_doc/EC21.md | 10 +- pages/rbs_doc/EC21_SoracomBeamUDP.md | 4 +- pages/rbs_doc/Exception.md | 4 +- pages/rbs_doc/FAT.md | 119 ++++--------------- pages/rbs_doc/FAT_Dir.md | 12 +- pages/rbs_doc/FAT_File.md | 24 ++-- pages/rbs_doc/FAT_Stat.md | 16 +-- pages/rbs_doc/FalseClass.md | 18 +-- pages/rbs_doc/File.md | 38 +++--- pages/rbs_doc/{Stat.md => File_Stat.md} | 25 ++-- pages/rbs_doc/Float.md | 40 +++---- pages/rbs_doc/GPIO.md | 79 +++---------- pages/rbs_doc/Hash.md | 50 ++++---- pages/rbs_doc/I2C.md | 39 +----- pages/rbs_doc/IIRFilter.md | 4 +- pages/rbs_doc/IO.md | 14 +-- pages/rbs_doc/InstructionSequence.md | 12 -- pages/rbs_doc/Integer.md | 150 ++++++++++++------------ pages/rbs_doc/Joystick.md | 21 +--- pages/rbs_doc/Keyboard.md | 126 ++++++++++---------- pages/rbs_doc/MCP3208.md | 4 +- pages/rbs_doc/MCP3424.md | 22 ++-- pages/rbs_doc/MML.md | 16 +-- pages/rbs_doc/MbedTLS_CMAC.md | 18 +-- pages/rbs_doc/Mouse.md | 16 +-- pages/rbs_doc/NilClass.md | 28 ++--- pages/rbs_doc/Object.md | 83 +++++-------- pages/rbs_doc/PCF8523.md | 13 +- pages/rbs_doc/PWM.md | 15 +-- pages/rbs_doc/Proc.md | 2 +- pages/rbs_doc/RGB.md | 72 ++++++------ pages/rbs_doc/RTD.md | 10 +- pages/rbs_doc/Range.md | 20 ++-- pages/rbs_doc/RotaryEncoder.md | 30 ++--- pages/rbs_doc/RubyVM.md | 6 - pages/rbs_doc/SPI.md | 52 +++----- pages/rbs_doc/SQLite3.md | 2 +- pages/rbs_doc/SQLite3_Database.md | 25 ++-- pages/rbs_doc/SQLite3_ResultSet.md | 8 +- pages/rbs_doc/SQLite3_Statement.md | 36 +++--- pages/rbs_doc/Sandbox.md | 24 ++-- pages/rbs_doc/Shell.md | 14 +-- pages/rbs_doc/Shell_Command.md | 16 +-- pages/rbs_doc/Sounder.md | 30 ++--- pages/rbs_doc/String.md | 130 ++++++++++---------- pages/rbs_doc/Symbol.md | 14 +-- pages/rbs_doc/Task.md | 21 ++-- pages/rbs_doc/Terminal_Base.md | 18 +-- pages/rbs_doc/Terminal_Buffer.md | 38 +++--- pages/rbs_doc/Terminal_Editor.md | 20 ++-- pages/rbs_doc/Terminal_Line.md | 14 +-- pages/rbs_doc/Time.md | 56 ++++----- pages/rbs_doc/TimeMethods.md | 6 - pages/rbs_doc/Time_TimeMethods.md | 6 + pages/rbs_doc/TrueClass.md | 18 +-- pages/rbs_doc/UART.md | 32 ++--- pages/rbs_doc/VFS_Dir.md | 2 +- pages/rbs_doc/VIA.md | 60 +++++----- pages/rbs_doc/Vim.md | 13 +- pages/rbs_doc/Watchdog.md | 2 +- 83 files changed, 979 insertions(+), 1285 deletions(-) rename pages/rbs_doc/{Stat.md => File_Stat.md} (50%) delete mode 100644 pages/rbs_doc/InstructionSequence.md delete mode 100644 pages/rbs_doc/RubyVM.md delete mode 100644 pages/rbs_doc/TimeMethods.md create mode 100644 pages/rbs_doc/Time_TimeMethods.md diff --git a/Rakefile b/Rakefile index dd2e329..991284f 100644 --- a/Rakefile +++ b/Rakefile @@ -3,7 +3,7 @@ require "fileutils" task :default => :all desc "Run all tasks" -task :all => ["rbs_doc:generate"] +task :all => ["steep_check", "rbs_doc:generate"] desc "Setup" task :setup => [:install_steep, :install_picoruby] @@ -35,12 +35,16 @@ task :s do sh "bundle exec jekyll serve" end +desc "Run steep check" +task :steep_check do + FileUtils.cd PICORUBY_DIR do + sh "rake steep" + end +end require_relative "lib/rbs_doc" namespace :rbs_doc do - task :default => :generate - desc "Generate documentation" task :generate do |t, args| FileUtils.cd File.expand_path("../picoruby", __FILE__) do diff --git a/_data/sidebars/picoruby_sidebar.yml b/_data/sidebars/picoruby_sidebar.yml index d94dcd0..bc1a855 100644 --- a/_data/sidebars/picoruby_sidebar.yml +++ b/_data/sidebars/picoruby_sidebar.yml @@ -30,18 +30,10 @@ entries: - title: Builtin class output: web pdf folderitems: - - title: ArgumentError - url: "/ArgumentError.html" - output: web pdf - type: homepage - title: Array url: "/Array.html" output: web pdf type: homepage - - title: Exception - url: "/Exception.html" - output: web pdf - type: homepage - title: FalseClass url: "/FalseClass.html" output: web pdf @@ -62,18 +54,10 @@ entries: url: "/Math.html" output: web pdf type: homepage - - title: NameError - url: "/NameError.html" - output: web pdf - type: homepage - title: NilClass url: "/NilClass.html" output: web pdf type: homepage - - title: NoMethodError - url: "/NoMethodError.html" - output: web pdf - type: homepage - title: Object url: "/Object.html" output: web pdf @@ -86,6 +70,45 @@ entries: url: "/Range.html" output: web pdf type: homepage + - title: String + url: "/String.html" + output: web pdf + type: homepage + - title: Symbol + url: "/Symbol.html" + output: web pdf + type: homepage + - title: TrueClass + url: "/TrueClass.html" + output: web pdf + type: homepage + - title: Error class + output: web pdf + folderitems: + - title: ArgumentError + url: "/ArgumentError.html" + output: web pdf + type: homepage + - title: Exception + url: "/Exception.html" + output: web pdf + type: homepage + - title: IOError + url: "/IOError.html" + output: web pdf + type: homepage + - title: LoadError + url: "/LoadError.html" + output: web pdf + type: homepage + - title: NameError + url: "/NameError.html" + output: web pdf + type: homepage + - title: NoMethodError + url: "/NoMethodError.html" + output: web pdf + type: homepage - title: RangeError url: "/RangeError.html" output: web pdf @@ -94,26 +117,18 @@ entries: url: "/RuntimeError.html" output: web pdf type: homepage - - title: StandardError - url: "/StandardError.html" - output: web pdf - type: homepage - - title: String - url: "/String.html" + - title: SQLite3::Exception + url: "/SQLite3_Exception.html" output: web pdf type: homepage - - title: Symbol - url: "/Symbol.html" + - title: StandardError + url: "/StandardError.html" output: web pdf type: homepage - title: SyntaxError url: "/SyntaxError.html" output: web pdf type: homepage - - title: TrueClass - url: "/TrueClass.html" - output: web pdf - type: homepage - title: TypeError url: "/TypeError.html" output: web pdf @@ -169,6 +184,10 @@ entries: url: "/PCF8523.html" output: web pdf type: homepage + - title: UART::RxBuffer + url: "/UART_RxBuffer.html" + output: web pdf + type: homepage - title: IO Peripheral class output: web pdf folderitems: @@ -267,6 +286,10 @@ entries: url: "/File.html" output: web pdf type: homepage + - title: File::Stat + url: "/File_Stat.html" + output: web pdf + type: homepage - title: IIRFilter url: "/IIRFilter.html" output: web pdf @@ -275,18 +298,6 @@ entries: url: "/IO.html" output: web pdf type: homepage - - title: IOError - url: "/IOError.html" - output: web pdf - type: homepage - - title: InstructionSequence - url: "/InstructionSequence.html" - output: web pdf - type: homepage - - title: LoadError - url: "/LoadError.html" - output: web pdf - type: homepage - title: MML url: "/MML.html" output: web pdf @@ -315,10 +326,6 @@ entries: url: "/RTD_PT100.html" output: web pdf type: homepage - - title: RubyVM - url: "/RubyVM.html" - output: web pdf - type: homepage - title: SQLite3 url: "/SQLite3.html" output: web pdf @@ -327,10 +334,6 @@ entries: url: "/SQLite3_Database.html" output: web pdf type: homepage - - title: SQLite3::Exception - url: "/SQLite3_Exception.html" - output: web pdf - type: homepage - title: SQLite3::ResultSet url: "/SQLite3_ResultSet.html" output: web pdf @@ -355,10 +358,6 @@ entries: url: "/Shell_Command.html" output: web pdf type: homepage - - title: Stat - url: "/Stat.html" - output: web pdf - type: homepage - title: Task url: "/Task.html" output: web pdf @@ -387,12 +386,8 @@ entries: url: "/Time.html" output: web pdf type: homepage - - title: TimeMethods - url: "/TimeMethods.html" - output: web pdf - type: homepage - - title: UART::RxBuffer - url: "/UART_RxBuffer.html" + - title: Time::TimeMethods + url: "/Time_TimeMethods.html" output: web pdf type: homepage - title: VFS diff --git a/lib/rbs_doc/generator.rb b/lib/rbs_doc/generator.rb index a5678ea..7f78f15 100644 --- a/lib/rbs_doc/generator.rb +++ b/lib/rbs_doc/generator.rb @@ -40,6 +40,8 @@ def generate_sidebar(path) "PRK Firmware class" when "hardware_device" "Hardware Device class" + when "error" + "Error class" else "General class" end @@ -130,7 +132,7 @@ def generate_pages f.puts f.puts "```ruby" method[:overloads].each do |overload| - f.print classname + "." if kind == :singleton + f.print(kind == :singleton ? classname + "." : "instance.") f.print name f.puts overload[:source] end @@ -141,7 +143,7 @@ def generate_pages klass[:attr_accessors].each do |attr_accessor| f.puts "### #{attr_accessor[:name]} (#{attr_accessor[:accessor_type]})\n" f.puts "```ruby" - f.puts attr_accessor[:source] + f.puts "instance.#{attr_accessor[:name]} -> #{attr_accessor[:source]}" f.puts "```\n" end end diff --git a/pages/rbs_doc/ADC.md b/pages/rbs_doc/ADC.md index dbb36fe..74aa255 100644 --- a/pages/rbs_doc/ADC.md +++ b/pages/rbs_doc/ADC.md @@ -14,34 +14,24 @@ Integer|String|Symbol Hash[untyped, untyped] ``` ## Singleton methods -### _init - -```ruby -ADC._init(pin_t pin) -> 0 -``` ### new ```ruby -ADC.new(pin_t pin, ?additional_params_t additional_params) -> void +ADC.new(pin_t pin, ?additional_params_t additional_params) -> instance ``` ## Instance methods -### init_additional_params - -```ruby -init_additional_params() -> self -``` ### read ```ruby -read() -> Float +instance.read() -> Float ``` ### read_raw ```ruby -read_raw() -> Integer +instance.read_raw() -> Integer ``` ### read_voltage ```ruby -read_voltage() -> Float +instance.read_voltage() -> Float ``` diff --git a/pages/rbs_doc/AHT25.md b/pages/rbs_doc/AHT25.md index b4fadea..272b69c 100644 --- a/pages/rbs_doc/AHT25.md +++ b/pages/rbs_doc/AHT25.md @@ -8,21 +8,21 @@ folder: rbs_doc ### new ```ruby -AHT25.new(i2c: I2C) -> void +AHT25.new(i2c: I2C) -> instance ``` ## Instance methods ### check ```ruby -check() -> bool +instance.check() -> bool ``` ### read ```ruby -read() -> {temperature: Float, humidity: Float} +instance.read() -> { temperature: Float, humidity: Float } ``` ### reset ```ruby -reset() -> void +instance.reset() -> void ``` diff --git a/pages/rbs_doc/AQM0802A.md b/pages/rbs_doc/AQM0802A.md index 3e645f1..97df469 100644 --- a/pages/rbs_doc/AQM0802A.md +++ b/pages/rbs_doc/AQM0802A.md @@ -14,35 +14,35 @@ AQM0802A.new(i2c: I2C, ?init: bool) -> void ### break_line ```ruby -break_line() -> self +instance.break_line() -> self ``` ### clear ```ruby -clear() -> self +instance.clear() -> self ``` ### home ```ruby -home() -> self +instance.home() -> self ``` ### print ```ruby -print(String line) -> nil +instance.print(String line) -> nil ``` ### putc ```ruby -putc(Integer c) -> Integer +instance.putc(Integer c) -> Integer ``` ### reset ```ruby -reset() -> self +instance.reset() -> self ``` ### write_instruction ```ruby -write_instruction(Integer inst) -> self +instance.write_instruction(Integer inst) -> self ``` diff --git a/pages/rbs_doc/Array.md b/pages/rbs_doc/Array.md index e17d05a..d58f0b4 100644 --- a/pages/rbs_doc/Array.md +++ b/pages/rbs_doc/Array.md @@ -17,212 +17,212 @@ Array.new(int size) { (::Integer index) -> Elem } -> void ### & ```ruby -&(::Array[untyped]) -> ::Array[Elem] +instance.&(::Array[untyped]) -> ::Array[Elem] ``` ### * ```ruby -*(string str) -> ::String -*(int int) -> ::Array[Elem] +instance.*(string str) -> ::String +instance.*(int int) -> ::Array[Elem] ``` ### + ```ruby -+[U] (Array[U]) -> ::Array[Elem | U] +instance.+[U] (Array[U]) -> ::Array[Elem | U] ``` ### - ```ruby --[U] (Array[U]) -> ::Array[Elem] +instance.-[U] (Array[U]) -> ::Array[Elem] ``` ### << ```ruby -<<(Elem) -> self +instance.<<(Elem) -> self ``` ### <=> ```ruby -<=>(untyped) -> ::Integer? +instance.<=>(untyped) -> ::Integer? ``` ### == ```ruby -==(untyped other) -> bool +instance.==(untyped other) -> bool ``` ### [] ```ruby -[](int index) -> Elem -[](int start, int length) -> ::Array[Elem]? +instance.[](int index) -> Elem +instance.[](int start, int length) -> ::Array[Elem]? ``` ### []= ```ruby -[]=(int index, Elem obj) -> Elem -[]=(int start, int length, Elem obj) -> Elem -[]=(int start, int length, ::Array[Elem]) -> ::Array[Elem] -[]=(int start, int length, nil) -> nil -[]=(::Range[::Integer?], Elem obj) -> Elem -[]=(::Range[::Integer?], ::Array[Elem]) -> ::Array[Elem] -[]=(::Range[::Integer?], nil) -> nil +instance.[]=(int index, Elem obj) -> Elem +instance.[]=(int start, int length, Elem obj) -> Elem +instance.[]=(int start, int length, ::Array[Elem]) -> ::Array[Elem] +instance.[]=(int start, int length, nil) -> nil +instance.[]=(::Range[::Integer?], Elem obj) -> Elem +instance.[]=(::Range[::Integer?], ::Array[Elem]) -> ::Array[Elem] +instance.[]=(::Range[::Integer?], nil) -> nil ``` ### all? ```ruby -all?() -> bool -all?() { (Elem obj) -> boolish } -> bool +instance.all?() -> bool +instance.all?() { (Elem obj) -> boolish } -> bool ``` ### at ```ruby -at(int index) -> Elem? +instance.at(int index) -> Elem? ``` ### clear ```ruby -clear() -> self +instance.clear() -> self ``` ### collect ```ruby -collect[U] () { (Elem item) -> U } -> ::Array[U] +instance.collect[U] () { (Elem item) -> U } -> ::Array[U] ``` ### collect! ```ruby -collect!() { (Elem item) -> Elem } -> self +instance.collect!() { (Elem item) -> Elem } -> self ``` ### count ```ruby -count() -> ::Integer -count(Elem obj) -> ::Integer -count() { (Elem) -> boolish } -> ::Integer +instance.count() -> ::Integer +instance.count(Elem obj) -> ::Integer +instance.count() { (Elem) -> boolish } -> ::Integer ``` ### delete_at ```ruby -delete_at(int index) -> Elem? +instance.delete_at(int index) -> Elem? ``` ### delete_if ```ruby -delete_if() { (Elem item) -> boolish } -> self +instance.delete_if() { (Elem item) -> boolish } -> self ``` ### each ```ruby -each() { (Elem item) -> void } -> self +instance.each() { (Elem item) -> void } -> self ``` ### each_index ```ruby -each_index() { (::Integer index) -> void } -> self +instance.each_index() { (::Integer index) -> void } -> self ``` ### each_with_index ```ruby -each_with_index() { (Elem item, ::Integer index) -> void } -> self +instance.each_with_index() { (Elem item, ::Integer index) -> void } -> self ``` ### empty? ```ruby -empty?() -> bool +instance.empty?() -> bool ``` ### find_index ```ruby -find_index(untyped obj) -> ::Integer? -find_index() { (Elem item) -> boolish } -> ::Integer? +instance.find_index(untyped obj) -> ::Integer? +instance.find_index() { (Elem item) -> boolish } -> ::Integer? ``` ### first ```ruby -first() -> Elem? -first(int n) -> ::Array[Elem] +instance.first() -> Elem? +instance.first(int n) -> ::Array[Elem] ``` ### flatten ```ruby -flatten() -> ::Array[Elem] +instance.flatten() -> ::Array[Elem] ``` ### include? ```ruby -include?(Elem object) -> bool +instance.include?(Elem object) -> bool ``` ### inspect ```ruby -inspect() -> String +instance.inspect() -> String ``` ### join ```ruby -join(?string separator) -> String +instance.join(?string separator) -> String ``` ### last ```ruby -last() -> Elem? -last(int n) -> ::Array[Elem] +instance.last() -> Elem? +instance.last(int n) -> ::Array[Elem] ``` ### length ```ruby -length() -> ::Integer +instance.length() -> ::Integer ``` ### max ```ruby -max() -> Elem? -max() { (Elem a, Elem b) -> ::Integer? } -> Elem? -max(int n) -> ::Array[Elem] -max(int n) { (Elem a, Elem b) -> ::Integer? } -> ::Array[Elem] +instance.max() -> Elem? +instance.max() { (Elem a, Elem b) -> ::Integer? } -> Elem? +instance.max(int n) -> ::Array[Elem] +instance.max(int n) { (Elem a, Elem b) -> ::Integer? } -> ::Array[Elem] ``` ### pop ```ruby -pop() -> Elem? -pop(int n) -> ::Array[Elem] +instance.pop() -> Elem? +instance.pop(int n) -> ::Array[Elem] ``` ### push ```ruby -push(*Elem obj) -> self +instance.push(*Elem obj) -> self ``` ### shift ```ruby -shift() -> Elem? -shift(int n) -> ::Array[Elem] +instance.shift() -> Elem? +instance.shift(int n) -> ::Array[Elem] ``` ### sort ```ruby -sort() -> ::Array[Elem] -sort() { (Elem a, Elem b) -> ::Integer } -> ::Array[Elem] +instance.sort() -> ::Array[Elem] +instance.sort() { (Elem a, Elem b) -> ::Integer } -> ::Array[Elem] ``` ### sort! ```ruby -sort!() -> self -sort!() { (Elem a, Elem b) -> ::Integer } -> self +instance.sort!() -> self +instance.sort!() { (Elem a, Elem b) -> ::Integer } -> self ``` ### unshift ```ruby -unshift(*Elem obj) -> self +instance.unshift(*Elem obj) -> self ``` ### | ```ruby -|[T] (::Array[T] other_ary) -> ::Array[Elem | T] +instance.|[T] (::Array[T] other_ary) -> ::Array[Elem | T] ``` ## Instance methods (picoruby-terminal) ### insert ```ruby -insert(Integer index, *Elem) -> void +instance.insert(Integer index, *Elem) -> void ``` diff --git a/pages/rbs_doc/BLE.md b/pages/rbs_doc/BLE.md index 0f1994f..6a33962 100644 --- a/pages/rbs_doc/BLE.md +++ b/pages/rbs_doc/BLE.md @@ -8,75 +8,75 @@ folder: rbs_doc ### new ```ruby -BLE.new(?(String|nil)) -> void +BLE.new(?(String|nil)) -> instance ``` ## Instance methods ### _init ```ruby -_init(String | nil) -> void +instance._init(String | nil) -> void ``` ### blink_led ```ruby -blink_led() -> void +instance.blink_led() -> void ``` ### debug_puts ```ruby -debug_puts(*untyped) -> nil +instance.debug_puts(*untyped) -> nil ``` ### ensure ```ruby -ensure() { () -> void }-> void +instance.ensure() { () -> void }-> void ``` ### gap_connect ```ruby -gap_connect(String, Integer) -> Integer +instance.gap_connect(String, Integer) -> Integer ``` ### gap_local_bd_addr ```ruby -gap_local_bd_addr() -> String +instance.gap_local_bd_addr() -> String ``` ### get_write_value ```ruby -get_write_value(Integer) -> (String|nil) +instance.get_write_value(Integer) -> (String|nil) ``` ### hci_power_control ```ruby -hci_power_control(Integer) -> 0 +instance.hci_power_control(Integer) -> 0 ``` ### heartbeat_callback ```ruby -heartbeat_callback() -> void +instance.heartbeat_callback() -> void ``` ### packet_callback ```ruby -packet_callback(String) -> void +instance.packet_callback(String) -> void ``` ### set_read_value ```ruby -set_read_value(Integer, String) -> void +instance.set_read_value(Integer, String) -> void ``` ### start ```ruby -start(?(Integer | nil) timeout_ms, ?(Symbol | nil)) -> Integer +instance.start(?(Integer | nil) timeout_ms, ?(Symbol | nil)) -> Integer ``` ## Attr accessors ### debug (accessor) ```ruby -bool +instance.debug -> bool ``` ### role (reader) ```ruby -:central | :peripheral | :observer | :broadcaster +instance.role -> :central | :peripheral | :observer | :broadcaster ``` diff --git a/pages/rbs_doc/BLE_AdvertisingData.md b/pages/rbs_doc/BLE_AdvertisingData.md index c8b42c6..a63b6a3 100644 --- a/pages/rbs_doc/BLE_AdvertisingData.md +++ b/pages/rbs_doc/BLE_AdvertisingData.md @@ -14,10 +14,10 @@ BLE::AdvertisingData.build() { (AdvertisingData) -> void } -> String ### add ```ruby -add(Integer, *untyped) -> void +instance.add(Integer, *untyped) -> void ``` ## Attr accessors ### data (reader) ```ruby -String +instance.data -> String ``` diff --git a/pages/rbs_doc/BLE_AdvertisingReport.md b/pages/rbs_doc/BLE_AdvertisingReport.md index 1a5cafb..6806ba3 100644 --- a/pages/rbs_doc/BLE_AdvertisingReport.md +++ b/pages/rbs_doc/BLE_AdvertisingReport.md @@ -13,42 +13,42 @@ Hash[(Symbol|Integer), String] ### new ```ruby -BLE::AdvertisingReport.new(String) -> void +BLE::AdvertisingReport.new(String) -> instance ``` ## Instance methods ### format ```ruby -format() -> String +instance.format() -> String ``` ### inspect_reports ```ruby -inspect_reports(String) -> report_t +instance.inspect_reports(String) -> report_t ``` ### name_include? ```ruby -name_include?(String) -> (bool | nil) +instance.name_include?(String) -> (bool | nil) ``` ## Attr accessors ### event_type (reader) ```ruby -Symbol|String +instance.event_type -> Symbol|String ``` ### address_type_code (reader) ```ruby -Integer +instance.address_type_code -> Integer ``` ### address (reader) ```ruby -String +instance.address -> String ``` ### rssi (reader) ```ruby -Integer | nil +instance.rssi -> Integer | nil ``` ### reports (reader) ```ruby -report_t +instance.reports -> report_t ``` diff --git a/pages/rbs_doc/BLE_Broadcaster.md b/pages/rbs_doc/BLE_Broadcaster.md index 4315e72..d020125 100644 --- a/pages/rbs_doc/BLE_Broadcaster.md +++ b/pages/rbs_doc/BLE_Broadcaster.md @@ -8,5 +8,5 @@ folder: rbs_doc ### advertise ```ruby -advertise(String) -> 0 +instance.advertise(String) -> 0 ``` diff --git a/pages/rbs_doc/BLE_Central.md b/pages/rbs_doc/BLE_Central.md index a783d8c..632d50f 100644 --- a/pages/rbs_doc/BLE_Central.md +++ b/pages/rbs_doc/BLE_Central.md @@ -45,47 +45,47 @@ folder: rbs_doc ### advertising_report_callback ```ruby -advertising_report_callback(BLE::AdvertisingReport) -> void +instance.advertising_report_callback(BLE::AdvertisingReport) -> void ``` ### connect ```ruby -connect(BLE::AdvertisingReport) -> bool +instance.connect(BLE::AdvertisingReport) -> bool ``` ### discover_characteristic_descriptors ```ruby -discover_characteristic_descriptors(Integer, Integer, Integer) -> Integer +instance.discover_characteristic_descriptors(Integer, Integer, Integer) -> Integer ``` ### discover_characteristics_for_service ```ruby -discover_characteristics_for_service(Integer, Integer, Integer) -> Integer +instance.discover_characteristics_for_service(Integer, Integer, Integer) -> Integer ``` ### discover_primary_services ```ruby -discover_primary_services(Integer) -> Integer +instance.discover_primary_services(Integer) -> Integer ``` ### get_packet ```ruby -get_packet() -> String +instance.get_packet() -> String ``` ### read_value_of_characteristic_using_value_handle ```ruby -read_value_of_characteristic_using_value_handle(Integer, Integer) -> Integer +instance.read_value_of_characteristic_using_value_handle(Integer, Integer) -> Integer ``` ### reset_state ```ruby -reset_state() -> Symbol +instance.reset_state() -> Symbol ``` ### scan ```ruby -scan( +instance.scan( ?scan_type: scan_type_t, ?scan_interval: Integer, ?scan_window: Integer, @@ -97,24 +97,24 @@ scan( ### set_scan_params ```ruby -set_scan_params(scan_type_t scan_type, Integer scan_interval, Integer scan_window) -> 0 +instance.set_scan_params(scan_type_t scan_type, Integer scan_interval, Integer scan_window) -> 0 ``` ### start_scan ```ruby -start_scan() -> 0 +instance.start_scan() -> 0 ``` ### stop_scan ```ruby -stop_scan() -> 0 +instance.stop_scan() -> 0 ``` ## Attr accessors ### state (reader) ```ruby -Symbol +instance.state -> Symbol ``` ### services (reader) ```ruby -Array[service_t] +instance.services -> Array[service_t] ``` diff --git a/pages/rbs_doc/BLE_GattDatabase.md b/pages/rbs_doc/BLE_GattDatabase.md index 845f3d2..d1c6900 100644 --- a/pages/rbs_doc/BLE_GattDatabase.md +++ b/pages/rbs_doc/BLE_GattDatabase.md @@ -17,70 +17,70 @@ Integer ### new ```ruby -BLE::GattDatabase.new() { (GattDatabase) -> void } -> void +BLE::GattDatabase.new() ?{ (GattDatabase) -> void } -> instance ``` ## Instance methods ### add_characteristic ```ruby -add_characteristic(properties_t, uuid_t, properties_t, String) ?{ (GattDatabase) -> void } -> void +instance.add_characteristic(properties_t, uuid_t, properties_t, String) ?{ (GattDatabase) -> void } -> void ``` ### add_descriptor ```ruby -add_descriptor(properties_t, uuid_t, ?(String)) -> void +instance.add_descriptor(properties_t, uuid_t, ?(String)) -> void ``` ### add_line ```ruby -add_line(String) -> void +instance.add_line(String) -> void ``` ### add_service ```ruby -add_service(uuid_t, uuid_t) ?{ (GattDatabase) -> void } -> void +instance.add_service(uuid_t, uuid_t) ?{ (GattDatabase) -> void } -> void ``` ### att_flags ```ruby -att_flags(Integer) -> Integer +instance.att_flags(Integer) -> Integer ``` ### flag_by_uuid ```ruby -flag_by_uuid(uuid_t, Integer) -> String +instance.flag_by_uuid(uuid_t, Integer) -> String ``` ### insert_database_hash ```ruby -insert_database_hash() -> void +instance.insert_database_hash() -> void ``` ### push_handle ```ruby -push_handle() -> String +instance.push_handle() -> String ``` ### seek_handle ```ruby -seek_handle() -> String +instance.seek_handle() -> String ``` ### uuid2str ```ruby -uuid2str(uuid_t) -> String +instance.uuid2str(uuid_t) -> String ``` ### write_permissions_and_key_size_flags_from_properties ```ruby -write_permissions_and_key_size_flags_from_properties(Integer) -> Integer +instance.write_permissions_and_key_size_flags_from_properties(Integer) -> Integer ``` ## Attr accessors ### handle_table (reader) ```ruby -Hash[uuid_t|nil, untyped] +instance.handle_table -> Hash[uuid_t|nil, untyped] ``` ### profile_data (reader) ```ruby -String +instance.profile_data -> String ``` diff --git a/pages/rbs_doc/BLE_Observer.md b/pages/rbs_doc/BLE_Observer.md index 7438c3a..95f22d7 100644 --- a/pages/rbs_doc/BLE_Observer.md +++ b/pages/rbs_doc/BLE_Observer.md @@ -8,5 +8,5 @@ folder: rbs_doc ### new ```ruby -BLE::Observer.new() -> void +BLE::Observer.new() -> instance ``` diff --git a/pages/rbs_doc/BLE_Peripheral.md b/pages/rbs_doc/BLE_Peripheral.md index 4ef3b64..2b002b7 100644 --- a/pages/rbs_doc/BLE_Peripheral.md +++ b/pages/rbs_doc/BLE_Peripheral.md @@ -8,15 +8,15 @@ folder: rbs_doc ### advertise ```ruby -advertise(String) -> void +instance.advertise(String) -> void ``` ### notify ```ruby -notify(Integer) -> void +instance.notify(Integer) -> void ``` ### request_can_send_now_event ```ruby -request_can_send_now_event() -> void +instance.request_can_send_now_event() -> void ``` diff --git a/pages/rbs_doc/CYW43.md b/pages/rbs_doc/CYW43.md index 06c51a8..446c298 100644 --- a/pages/rbs_doc/CYW43.md +++ b/pages/rbs_doc/CYW43.md @@ -5,11 +5,6 @@ permalink: CYW43.html folder: rbs_doc --- ## Singleton methods -### _init - -```ruby -CYW43._init(String, bool) -> bool -``` ### check_initialized ```ruby diff --git a/pages/rbs_doc/CYW43_GPIO.md b/pages/rbs_doc/CYW43_GPIO.md index 36fbf9d..b3e1f63 100644 --- a/pages/rbs_doc/CYW43_GPIO.md +++ b/pages/rbs_doc/CYW43_GPIO.md @@ -14,10 +14,10 @@ CYW43::GPIO.new(Integer) -> void ### read ```ruby -read() -> Integer +instance.read() -> GPIO::gpio_logic_t ``` ### write ```ruby -write(Integer) -> 0 +instance.write(Integer) -> 0 ``` diff --git a/pages/rbs_doc/DebounceBase.md b/pages/rbs_doc/DebounceBase.md index 72a413d..c10f745 100644 --- a/pages/rbs_doc/DebounceBase.md +++ b/pages/rbs_doc/DebounceBase.md @@ -8,16 +8,16 @@ folder: rbs_doc ### new ```ruby -DebounceBase.new() -> void +DebounceBase.new() -> instance ``` ## Instance methods ### set_time ```ruby -set_time() -> void +instance.set_time() -> void ``` ### threshold= ```ruby -threshold=(Integer) -> void +instance.threshold=(Integer) -> void ``` diff --git a/pages/rbs_doc/DebounceNone.md b/pages/rbs_doc/DebounceNone.md index 65b4a59..68e6558 100644 --- a/pages/rbs_doc/DebounceNone.md +++ b/pages/rbs_doc/DebounceNone.md @@ -8,5 +8,5 @@ folder: rbs_doc ### resolve ```ruby -resolve(Integer in_pin, Integer out_pin) -> bool +instance.resolve(Integer in_pin, Integer out_pin) -> bool ``` diff --git a/pages/rbs_doc/DebouncePerKey.md b/pages/rbs_doc/DebouncePerKey.md index d7ca309..d0f4a47 100644 --- a/pages/rbs_doc/DebouncePerKey.md +++ b/pages/rbs_doc/DebouncePerKey.md @@ -8,5 +8,5 @@ folder: rbs_doc ### resolve ```ruby -resolve(Integer in_pin, Integer out_pin) -> bool +instance.resolve(Integer in_pin, Integer out_pin) -> bool ``` diff --git a/pages/rbs_doc/DebouncePerRow.md b/pages/rbs_doc/DebouncePerRow.md index 7348e75..607f684 100644 --- a/pages/rbs_doc/DebouncePerRow.md +++ b/pages/rbs_doc/DebouncePerRow.md @@ -8,5 +8,5 @@ folder: rbs_doc ### resolve ```ruby -resolve(Integer in_pin, Integer out_pin) -> bool +instance.resolve(Integer in_pin, Integer out_pin) -> bool ``` diff --git a/pages/rbs_doc/DipSwitch.md b/pages/rbs_doc/DipSwitch.md index 4637920..f28e6be 100644 --- a/pages/rbs_doc/DipSwitch.md +++ b/pages/rbs_doc/DipSwitch.md @@ -8,11 +8,11 @@ folder: rbs_doc ### new ```ruby -DipSwitch.new(GPIO|nil c_pin, Array[Integer] pin_nums) -> void +DipSwitch.new(GPIO|nil c_pin, Array[Integer] pin_nums) -> instance ``` ## Instance methods ### read ```ruby -read() -> Integer +instance.read() -> Integer ``` diff --git a/pages/rbs_doc/Dir.md b/pages/rbs_doc/Dir.md index 132fe70..1900eac 100644 --- a/pages/rbs_doc/Dir.md +++ b/pages/rbs_doc/Dir.md @@ -37,11 +37,6 @@ Dir.getwd() -> String Dir.glob(path pattern, ?int flags, ?base: path?) -> Array[String] Dir.glob(path pattern, ?int flags, ?base: path?) { (String pathname) -> void } -> nil ``` -### new - -```ruby -Dir.new(path dir) -> void -``` ### mkdir ```ruby @@ -62,35 +57,35 @@ Dir.open[U] (path dirname) { (VFS::dir_t) -> U } -> VFS::dir_t ### close ```ruby -close() -> nil +instance.close() -> nil ``` ### each ```ruby -each() { (String) -> void } -> self +instance.each() { (String) -> void } -> self ``` ### findnext ```ruby -findnext() -> String? +instance.findnext() -> String? ``` ### pat= ```ruby -pat=(path) -> path +instance.pat=(path) -> path ``` ### path ```ruby -path() -> String? +instance.path() -> String? ``` ### read ```ruby -read() -> String? +instance.read() -> String? ``` ### rewind ```ruby -rewind() -> self +instance.rewind() -> self ``` diff --git a/pages/rbs_doc/EC21.md b/pages/rbs_doc/EC21.md index 80571d8..f79b06a 100644 --- a/pages/rbs_doc/EC21.md +++ b/pages/rbs_doc/EC21.md @@ -5,7 +5,7 @@ permalink: EC21.html folder: rbs_doc --- ## Type aliases -### log_t +### ec21_log_t ```ruby Hash[Symbol, String] ``` @@ -13,21 +13,21 @@ Hash[Symbol, String] ### new ```ruby -EC21.new(unit: (Symbol|String), txd_pin: Integer, rxd_pin: Integer, baudrate: Integer, log_size: Integer) -> void +EC21.new(unit: (Symbol|String), txd_pin: Integer, rxd_pin: Integer, baudrate: Integer, log_size: Integer) -> instance ``` ## Instance methods ### addlog ```ruby -addlog(String cmd, String res) -> nil +instance.addlog(String cmd, String res) -> nil ``` ### call_and_response ```ruby -call_and_response(String cmd, String expected_response, ?String? error_response, ?Integer timeout) -> bool +instance.call_and_response(String cmd, String expected_response, ?String? error_response, ?Integer timeout) -> bool ``` ### check_sim_status ```ruby -check_sim_status() -> bool +instance.check_sim_status() -> bool ``` diff --git a/pages/rbs_doc/EC21_SoracomBeamUDP.md b/pages/rbs_doc/EC21_SoracomBeamUDP.md index 510767b..4efeddd 100644 --- a/pages/rbs_doc/EC21_SoracomBeamUDP.md +++ b/pages/rbs_doc/EC21_SoracomBeamUDP.md @@ -8,10 +8,10 @@ folder: rbs_doc ### configure_and_activate_context ```ruby -configure_and_activate_context() -> bool +instance.configure_and_activate_context() -> bool ``` ### connect_and_send ```ruby -connect_and_send(String data) -> bool +instance.connect_and_send(String data) -> bool ``` diff --git a/pages/rbs_doc/Exception.md b/pages/rbs_doc/Exception.md index f8c7f4e..a96e174 100644 --- a/pages/rbs_doc/Exception.md +++ b/pages/rbs_doc/Exception.md @@ -19,10 +19,10 @@ Exception.new(?string | _ToS message) -> self ### == ```ruby -==(untyped obj) -> bool +instance.==(untyped obj) -> bool ``` ### message ```ruby -message() -> String +instance.message() -> String ``` diff --git a/pages/rbs_doc/FAT.md b/pages/rbs_doc/FAT.md index a16b1e4..b19bb6e 100644 --- a/pages/rbs_doc/FAT.md +++ b/pages/rbs_doc/FAT.md @@ -14,56 +14,6 @@ folder: rbs_doc nil|SPI ``` ## Singleton methods -### _chdir - -```ruby -FAT._chdir(String path) -> 0 -``` -### _chmod - -```ruby -FAT._chmod(Integer mode, String path) -> 0 -``` -### _directory? - -```ruby -FAT._directory?(String path) -> bool -``` -### _erase - -```ruby -FAT._erase(String path) -> 0 -``` -### _exist? - -```ruby -FAT._exist?(String path) -> bool -``` -### _mkdir - -```ruby -FAT._mkdir(String path, Integer mode) -> 0 -``` -### _rename - -```ruby -FAT._rename(String from, String to) -> 0 -``` -### _stat - -```ruby -FAT._stat(String path) -> stat_t -``` -### _unlink - -```ruby -FAT._unlink(String path) -> 0 -``` -### _utime - -```ruby -FAT._utime(Integer unixtime, String path) -> Integer -``` ### init_spi ```ruby @@ -72,7 +22,7 @@ FAT.init_spi(String unit, Integer sck_pin, Integer cipo_pin, Integer copi_pin, I ### new ```ruby -FAT.new(Symbol|String device, ?label: String?, ?driver: driver_t) -> void +FAT.new(Symbol|String device, ?label: String?, ?driver: driver_t) -> FAT ``` ### unixtime_offset= @@ -85,132 +35,107 @@ FAT.unixtime_offset=(Integer) -> Integer FAT.vfs_methods-> FAT::VFSMethods ``` ## Instance methods -### _getlabel - -```ruby -_getlabel(String) -> String -``` -### _mkfs - -```ruby -_mkfs(String path) -> self -``` -### _mount - -```ruby -_mount(String path) -> 0 -``` -### _setlabel - -```ruby -_setlabel(String) -> 0 -``` -### _unmount - -```ruby -_unmount(String path) -> 0 -``` ### chdir ```ruby -chdir(String path) -> 0 +instance.chdir(String path) -> 0 ``` ### chmod ```ruby -chmod(Integer mode, String path) -> 0 +instance.chmod(Integer mode, String path) -> 0 ``` ### directory? ```ruby -directory?(String path) -> bool +instance.directory?(String path) -> bool ``` ### erase ```ruby -erase-> 0 +instance.erase-> 0 ``` ### exist? ```ruby -exist?(String path) -> bool +instance.exist?(String path) -> bool ``` ### getfree ```ruby -getfree(String path) -> Integer +instance.getfree(String path) -> Integer ``` ### getlabel ```ruby -getlabel-> String +instance.getlabel-> String ``` ### mkdir ```ruby -mkdir(String path, ?Integer mode) -> 0 +instance.mkdir(String path, ?Integer mode) -> 0 ``` ### mkfs ```ruby -mkfs-> FAT +instance.mkfs-> FAT ``` ### mount ```ruby -mount(String mountpoint) -> 0 +instance.mount(String mountpoint) -> 0 ``` ### open_dir ```ruby -open_dir(String path) -> FAT::Dir +instance.open_dir(String path) -> FAT::Dir ``` ### open_file ```ruby -open_file(String path, String mode) -> FAT::File +instance.open_file(String path, String mode) -> FAT::File ``` ### rename ```ruby -rename(String from, String to) -> 0 +instance.rename(String from, String to) -> 0 ``` ### sector_count ```ruby -sector_count-> {total: Integer, free: Integer} +instance.sector_count-> {total: Integer, free: Integer} ``` ### setlabel ```ruby -setlabel-> 0 +instance.setlabel-> 0 ``` ### stat ```ruby -stat(String path) -> Stat +instance.stat(String path) -> Stat ``` ### unlink ```ruby -unlink(String path) -> 0 +instance.unlink(String path) -> 0 ``` ### unmount ```ruby -unmount-> nil +instance.unmount-> nil ``` ### utime ```ruby -utime(Time atime, Time mtime, String path) -> Integer +instance.utime(Time atime, Time mtime, String path) -> Integer ``` ## Attr accessors ### mountpoint (reader) ```ruby -String +instance.mountpoint -> String ``` ### prefix (reader) ```ruby -String +instance.prefix -> String ``` diff --git a/pages/rbs_doc/FAT_Dir.md b/pages/rbs_doc/FAT_Dir.md index 74c4f8b..f8461ba 100644 --- a/pages/rbs_doc/FAT_Dir.md +++ b/pages/rbs_doc/FAT_Dir.md @@ -14,30 +14,30 @@ FAT::Dir.new(String path) -> void ### close ```ruby -close-> nil +instance.close-> nil ``` ### findnext ```ruby -findnext-> String? +instance.findnext-> String? ``` ### fullpath ```ruby -fullpath-> String +instance.fullpath-> String ``` ### read ```ruby -read-> String? +instance.read-> String? ``` ### rewind ```ruby -rewind-> self +instance.rewind-> self ``` ## Attr accessors ### pat (accessor) ```ruby -String +instance.pat -> String ``` diff --git a/pages/rbs_doc/FAT_File.md b/pages/rbs_doc/FAT_File.md index dbe54d0..c81966a 100644 --- a/pages/rbs_doc/FAT_File.md +++ b/pages/rbs_doc/FAT_File.md @@ -14,60 +14,60 @@ FAT::File.new(String path, String mode) -> void ### close ```ruby -close() -> nil +instance.close() -> nil ``` ### each_line ```ruby -each_line() { (String) -> void } -> nil +instance.each_line() { (String) -> void } -> nil ``` ### eof? ```ruby -eof?() -> bool +instance.eof?() -> bool ``` ### expand ```ruby -expand(Integer size) -> Integer +instance.expand(Integer size) -> Integer ``` ### fsync ```ruby -fsync() -> 0 +instance.fsync() -> 0 ``` ### gets ```ruby -gets() -> String? +instance.gets() -> String? ``` ### puts ```ruby -puts(*String) -> nil +instance.puts(*String) -> nil ``` ### read ```ruby -read(?Integer size) -> String +instance.read(?Integer size) -> String ``` ### seek ```ruby -seek(Integer offset, ?Integer whence) -> 0 +instance.seek(Integer offset, ?Integer whence) -> 0 ``` ### size ```ruby -size() -> Integer +instance.size() -> Integer ``` ### tell ```ruby -tell() -> Integer +instance.tell() -> Integer ``` ### write ```ruby -write(String data) -> Integer +instance.write(String data) -> Integer ``` diff --git a/pages/rbs_doc/FAT_Stat.md b/pages/rbs_doc/FAT_Stat.md index d3d3d01..62224fc 100644 --- a/pages/rbs_doc/FAT_Stat.md +++ b/pages/rbs_doc/FAT_Stat.md @@ -8,41 +8,41 @@ folder: rbs_doc ### new ```ruby -FAT::Stat.new(String device, String path) -> void +FAT::Stat.new(String device, String path) -> instance ``` ## Instance methods ### birthtime ```ruby -birthtime() -> untyped +instance.birthtime() -> untyped ``` ### directory? ```ruby -directory?() -> bool +instance.directory?() -> bool ``` ### mode ```ruby -mode() -> Integer +instance.mode() -> Integer ``` ### mode_str ```ruby -mode_str() -> String +instance.mode_str() -> String ``` ### mtime ```ruby -mtime() -> Time +instance.mtime() -> Time ``` ### size ```ruby -size() -> Integer +instance.size() -> Integer ``` ### writable? ```ruby -writable?() -> bool +instance.writable?() -> bool ``` diff --git a/pages/rbs_doc/FalseClass.md b/pages/rbs_doc/FalseClass.md index d283809..4012b5e 100644 --- a/pages/rbs_doc/FalseClass.md +++ b/pages/rbs_doc/FalseClass.md @@ -8,33 +8,33 @@ folder: rbs_doc ### ! ```ruby -!() -> true +instance.!() -> true ``` ### & ```ruby -&(untyped obj) -> false +instance.&(untyped obj) -> false ``` ### === ```ruby -===(false) -> true -===(untyped obj) -> bool +instance.===(false) -> true +instance.===(untyped obj) -> bool ``` ### ^ ```ruby -^(false | nil) -> false -^(untyped obj) -> bool +instance.^(false | nil) -> false +instance.^(untyped obj) -> bool ``` ### to_s ```ruby -to_s() -> "false" +instance.to_s() -> "false" ``` ### | ```ruby -|(nil | false) -> false -|(untyped obj) -> bool +instance.|(nil | false) -> false +instance.|(untyped obj) -> bool ``` diff --git a/pages/rbs_doc/File.md b/pages/rbs_doc/File.md index 6409661..660994c 100644 --- a/pages/rbs_doc/File.md +++ b/pages/rbs_doc/File.md @@ -33,13 +33,13 @@ File.file?(string) -> bool ### new ```ruby -File.new(string, ?string mode) -> void +File.new(string, ?string mode) -> VFS::file_t ``` ### open ```ruby -File.open(string, ?string | int mode) -> VFS::file_t -File.open[T] (string, ?string | int mode) { (VFS::file_t) -> T } -> VFS::file_t +File.open(string, ?string) -> VFS::file_t +File.open[T] (string, ?string) { (VFS::file_t) -> T } -> nil ``` ### rename @@ -60,80 +60,80 @@ File.utime(Time atime, Time mtime, *string) -> Integer ### close ```ruby -close() -> nil +instance.close() -> nil ``` ### each_line ```ruby -each_line() { (String) -> void } -> nil +instance.each_line() { (String) -> void } -> nil ``` ### eof? ```ruby -eof?() -> bool +instance.eof?() -> bool ``` ### expand ```ruby -expand(Integer size) -> Integer +instance.expand(Integer size) -> Integer ``` ### fsync ```ruby -fsync() -> Integer +instance.fsync() -> Integer ``` ### gets ```ruby -gets(*(Integer|String) args, ?chomp: bool) -> String? +instance.gets(*(Integer|String) args, ?chomp: bool) -> String? ``` ### path ```ruby -path() -> String +instance.path() -> String ``` ### printf ```ruby -printf(String format, *String string) -> nil +instance.printf(String format, *String string) -> nil ``` ### putc ```ruby -putc(String | Integer ch) -> (String | Integer) +instance.putc(String | Integer ch) -> (String | Integer) ``` ### puts ```ruby -puts(*String string) -> nil +instance.puts(*String string) -> nil ``` ### read ```ruby -read(?Integer length, ?String outbuf) -> String? +instance.read(?Integer length, ?String outbuf) -> String? ``` ### rewind ```ruby -rewind() -> Integer +instance.rewind() -> Integer ``` ### seek ```ruby -seek(Integer offset, ?Integer whence) -> Integer +instance.seek(Integer offset, ?Integer whence) -> Integer ``` ### size ```ruby -size() -> Integer +instance.size() -> Integer ``` ### tell ```ruby -tell() -> Integer +instance.tell() -> Integer ``` ### write ```ruby -write(*String string) -> Integer +instance.write(*String string) -> Integer ``` diff --git a/pages/rbs_doc/Stat.md b/pages/rbs_doc/File_Stat.md similarity index 50% rename from pages/rbs_doc/Stat.md rename to pages/rbs_doc/File_Stat.md index d0dfdac..1504fc4 100644 --- a/pages/rbs_doc/Stat.md +++ b/pages/rbs_doc/File_Stat.md @@ -1,53 +1,48 @@ --- -title: Stat +title: File::Stat sidebar: picoruby_sidebar -permalink: Stat.html +permalink: File_Stat.html folder: rbs_doc --- ## Singleton methods ### new ```ruby -Stat.new(String file) -> void -``` -### new - -```ruby -Stat.new(String file) -> instance +File::Stat.new(String file) -> instance ``` ## Instance methods ### birthtime ```ruby -birthtime() -> Time +instance.birthtime() -> Time ``` ### directory? ```ruby -directory?() -> bool +instance.directory?() -> bool ``` ### mode ```ruby -mode() -> Integer +instance.mode() -> Integer ``` ### mode_str ```ruby -mode_str() -> String +instance.mode_str() -> String ``` ### mtime ```ruby -mtime() -> Time +instance.mtime() -> Time ``` ### size ```ruby -size() -> Integer +instance.size() -> Integer ``` ### writable? ```ruby -writable?() -> bool +instance.writable?() -> bool ``` diff --git a/pages/rbs_doc/Float.md b/pages/rbs_doc/Float.md index a7e781c..c0f5d6a 100644 --- a/pages/rbs_doc/Float.md +++ b/pages/rbs_doc/Float.md @@ -8,101 +8,101 @@ folder: rbs_doc ### ceil_to_i ```ruby -ceil_to_i() -> Integer +instance.ceil_to_i() -> Integer ``` ## Instance methods ### % ```ruby -%(Integer | Float) -> Float +instance.%(Integer | Float) -> Float ``` ### * ```ruby -*(Integer | Float) -> Float +instance.*(Integer | Float) -> Float ``` ### ** ```ruby -**(Integer | Float) -> Float +instance.**(Integer | Float) -> Float ``` ### + ```ruby -+(Integer | Float) -> Float +instance.+(Integer | Float) -> Float ``` ### +@ ```ruby -+@() -> Float +instance.+@() -> Float ``` ### - ```ruby --(Integer | Float) -> Float +instance.-(Integer | Float) -> Float ``` ### -@ ```ruby --@() -> Float +instance.-@() -> Float ``` ### / ```ruby -/(Integer | Float) -> Float +instance./(Integer | Float) -> Float ``` ### < ```ruby -<(Integer | Float) -> bool +instance.<(Integer | Float) -> bool ``` ### <= ```ruby -<=(Integer | Float) -> bool +instance.<=(Integer | Float) -> bool ``` ### <=> ```ruby -<=>(Integer | Float) -> Integer? +instance.<=>(Integer | Float) -> Integer? ``` ### == ```ruby -==(untyped) -> bool +instance.==(untyped) -> bool ``` ### === ```ruby -===(untyped) -> bool +instance.===(untyped) -> bool ``` ### > ```ruby ->(Integer | Float) -> bool +instance.>(Integer | Float) -> bool ``` ### >= ```ruby ->=(Integer | Float) -> bool +instance.>=(Integer | Float) -> bool ``` ### abs ```ruby -abs() -> Float +instance.abs() -> Float ``` ### to_f ```ruby -to_f() -> Float +instance.to_f() -> Float ``` ### to_i ```ruby -to_i() -> Integer +instance.to_i() -> Integer ``` ### to_s ```ruby -to_s() -> String +instance.to_s() -> String ``` diff --git a/pages/rbs_doc/GPIO.md b/pages/rbs_doc/GPIO.md index 90f7b9c..e85ce17 100644 --- a/pages/rbs_doc/GPIO.md +++ b/pages/rbs_doc/GPIO.md @@ -5,114 +5,63 @@ permalink: GPIO.html folder: rbs_doc --- ## Type aliases -### pin_t +### gpio_pin_t ```ruby Integer|String|Symbol ``` -## Singleton methods -### _init - +### gpio_logic_t ```ruby -GPIO._init(pin_t) -> 0 +0 | 1 ``` +## Singleton methods ### high_at? ```ruby -GPIO.high_at?(pin_t) -> bool -``` -### new - -```ruby -GPIO.new(pin_t pin, Integer flags, ?Integer alt_function) -> void +GPIO.high_at?(gpio_pin_t) -> bool ``` ### low_at? ```ruby GPIO.low_at?(Integer) -> bool ``` -### open_drain_at - -```ruby -GPIO.open_drain_at(pin_t) -> 0 -``` -### pull_down_at - -```ruby -GPIO.pull_down_at(pin_t) -> 0 -``` -### pull_up_at +### new ```ruby -GPIO.pull_up_at(pin_t) -> 0 +GPIO.new(gpio_pin_t pin, Integer flags, ?Integer alt_function) -> instance ``` ### read_at ```ruby -GPIO.read_at(pin_t) -> Integer -``` -### set_dir_at - -```ruby -GPIO.set_dir_at(pin_t, Integer) -> 0 -``` -### set_function_at - -```ruby -GPIO.set_function_at(pin_t, Integer) -> 0 +GPIO.read_at(gpio_pin_t) -> gpio_logic_t ``` ### write_at ```ruby -GPIO.write_at(pin_t, Integer) -> 0 +GPIO.write_at(gpio_pin_t, Integer) -> 0 ``` ## Instance methods ### high? ```ruby -high?() -> bool +instance.high?() -> bool ``` ### low? ```ruby -low?() -> bool -``` -### on_initialize? - -```ruby -on_initialize?() -> bool -``` -### open_drain - -```ruby -open_drain(Integer) -> 0 +instance.low?() -> bool ``` ### read ```ruby -read() -> Integer -``` -### set_dir - -```ruby -set_dir(Integer) -> 0 -``` -### set_function - -```ruby -set_function(Integer, Integer) -> 0 -``` -### set_pull - -```ruby -set_pull(Integer) -> 0 +instance.read() -> gpio_logic_t ``` ### setmode ```ruby -setmode(Integer flags, ?Integer alt_function) -> 0 +instance.setmode(Integer flags, ?Integer alt_function) -> 0 ``` ### write ```ruby -write(Integer) -> 0 +instance.write(Integer) -> 0 ``` diff --git a/pages/rbs_doc/Hash.md b/pages/rbs_doc/Hash.md index 650cd9b..4959140 100644 --- a/pages/rbs_doc/Hash.md +++ b/pages/rbs_doc/Hash.md @@ -16,113 +16,113 @@ Hash.new[A, B] () { (Hash[A, B] hash, A key) -> B } -> void ### < ```ruby -<[A, B] (::Hash[A, B]) -> bool +instance.<[A, B] (::Hash[A, B]) -> bool ``` ### <= ```ruby -<=[A, B] (::Hash[A, B]) -> bool +instance.<=[A, B] (::Hash[A, B]) -> bool ``` ### == ```ruby -==(untyped other) -> bool +instance.==(untyped other) -> bool ``` ### > ```ruby ->[A, B] (::Hash[A, B]) -> bool +instance.>[A, B] (::Hash[A, B]) -> bool ``` ### >= ```ruby ->=[A, B] (::Hash[A, B]) -> bool +instance.>=[A, B] (::Hash[A, B]) -> bool ``` ### [] ```ruby -[](K arg0) -> V +instance.[](K arg0) -> V ``` ### []= ```ruby -[]=(K arg0, V arg1) -> V +instance.[]=(K arg0, V arg1) -> V ``` ### clear ```ruby -clear() -> self +instance.clear() -> self ``` ### delete ```ruby -delete(K arg0) -> V? +instance.delete(K arg0) -> V? ``` ### each ```ruby -each() { (K key, V val) -> untyped } -> self +instance.each() { (K key, V val) -> untyped } -> self ``` ### empty? ```ruby -empty?() -> bool +instance.empty?() -> bool ``` ### has_key? ```ruby -has_key?(K arg0) -> bool +instance.has_key?(K arg0) -> bool ``` ### has_value? ```ruby -has_value?(V arg0) -> bool +instance.has_value?(V arg0) -> bool ``` ### inspect ```ruby -inspect() -> String +instance.inspect() -> String ``` ### key ```ruby -key(V) -> K? +instance.key(V) -> K? ``` ### keys ```ruby -keys() -> ::Array[K] +instance.keys() -> ::Array[K] ``` ### length ```ruby -length() -> Integer +instance.length() -> Integer ``` ### merge ```ruby -merge[A, B] (*::Hash[A, B] other_hashes) -> ::Hash[A | K, B | V] -merge[A, B, C] (*::Hash[A, B] other_hashes) { (K key, V oldval, B newval) -> C } -> ::Hash[A | K, B | V | C] +instance.merge[A, B] (*::Hash[A, B] other_hashes) -> ::Hash[A | K, B | V] +instance.merge[A, B, C] (*::Hash[A, B] other_hashes) { (K key, V oldval, B newval) -> C } -> ::Hash[A | K, B | V | C] ``` ### merge! ```ruby -merge!(*::Hash[K, V] other_hashes) -> self -merge!(*::Hash[K, V] other_hashes) { (K key, V oldval, V newval) -> V } -> self +instance.merge!(*::Hash[K, V] other_hashes) -> self +instance.merge!(*::Hash[K, V] other_hashes) { (K key, V oldval, V newval) -> V } -> self ``` ### shift ```ruby -shift() -> [ K, V ]? +instance.shift() -> [ K, V ]? ``` ### to_h ```ruby -to_h() -> Hash[K, V] -to_h[A, B] () { (K, V) -> [ A, B ] } -> Hash[A, B] +instance.to_h() -> Hash[K, V] +instance.to_h[A, B] () { (K, V) -> [ A, B ] } -> Hash[A, B] ``` ### values ```ruby -values() -> ::Array[V] +instance.values() -> ::Array[V] ``` diff --git a/pages/rbs_doc/I2C.md b/pages/rbs_doc/I2C.md index 374e461..ea3683c 100644 --- a/pages/rbs_doc/I2C.md +++ b/pages/rbs_doc/I2C.md @@ -18,49 +18,20 @@ I2C.new( ?frequency: Integer, ?sda_pin: Integer, ?scl_pin: Integer - ) -> void + ) -> instance ``` ## Instance methods -### _init - -```ruby -_init( - String unit, - Integer frequency, - Integer sda_pin, - Integer scl_pin - ) -> Integer -``` -### _read - -```ruby -_read( - Integer unit_num, - Integer i2c_adrs_7, - Integer len - ) -> (String | Integer) -``` -### _write - -```ruby -_write( - Integer unit_num, - Integer i2c_adrs_7, - Array[Integer] output_array, - bool nostop - ) -> Integer -``` ### outputs_array ```ruby -outputs_array( +instance.outputs_array( Array[outputs_t] outputs ) -> Array[Integer] ``` ### read ```ruby -read( +instance.read( Integer i2c_adrs_7, Integer len, *outputs_t outputs @@ -69,12 +40,12 @@ read( ### scan ```ruby -scan() -> nil +instance.scan() -> nil ``` ### write ```ruby -write( +instance.write( Integer i2c_adrs_7, *outputs_t outputs ) -> Integer diff --git a/pages/rbs_doc/IIRFilter.md b/pages/rbs_doc/IIRFilter.md index 4e84848..3862799 100644 --- a/pages/rbs_doc/IIRFilter.md +++ b/pages/rbs_doc/IIRFilter.md @@ -8,11 +8,11 @@ folder: rbs_doc ### new ```ruby -IIRFilter.new() -> void +IIRFilter.new() -> instance ``` ## Instance methods ### filter ```ruby -filter(Integer raw_value) -> Integer +instance.filter(Integer raw_value) -> Integer ``` diff --git a/pages/rbs_doc/IO.md b/pages/rbs_doc/IO.md index ea0a2cb..7e36df4 100644 --- a/pages/rbs_doc/IO.md +++ b/pages/rbs_doc/IO.md @@ -59,36 +59,36 @@ IO.wait_terminal(?timeout: Integer|Float|nil) -> bool ### << ```ruby -<<(untyped) -> self +instance.<<(untyped) -> self ``` ### flush ```ruby -flush-> self +instance.flush-> self ``` ### getch ```ruby -getch-> String +instance.getch-> String ``` ### iflush ```ruby -iflush-> self +instance.iflush-> self ``` ### noecho ```ruby -noecho() { (untyped) -> untyped } -> untyped +instance.noecho() { (untyped) -> untyped } -> untyped ``` ### raw ```ruby -raw() { (untyped) -> untyped } -> untyped +instance.raw() { (untyped) -> untyped } -> untyped ``` ## Instance methods ### read_nonblock ```ruby -read_nonblock(Integer maxlen) -> String +instance.read_nonblock(Integer maxlen) -> String ``` diff --git a/pages/rbs_doc/InstructionSequence.md b/pages/rbs_doc/InstructionSequence.md deleted file mode 100644 index 021b77b..0000000 --- a/pages/rbs_doc/InstructionSequence.md +++ /dev/null @@ -1,12 +0,0 @@ ---- -title: InstructionSequence -sidebar: picoruby_sidebar -permalink: InstructionSequence.html -folder: rbs_doc ---- -## Singleton methods -### compile - -```ruby -InstructionSequence.compile(String) -> self -``` diff --git a/pages/rbs_doc/Integer.md b/pages/rbs_doc/Integer.md index 1bd63d8..1e05ff9 100644 --- a/pages/rbs_doc/Integer.md +++ b/pages/rbs_doc/Integer.md @@ -8,195 +8,195 @@ folder: rbs_doc ### % ```ruby -%(Float) -> Float -%(Integer) -> Integer +instance.%(Float) -> Float +instance.%(Integer) -> Integer ``` ### & ```ruby -&(Integer) -> Integer +instance.&(Integer) -> Integer ``` ### * ```ruby -*(Float) -> Float -*(Integer) -> Integer +instance.*(Float) -> Float +instance.*(Integer) -> Integer ``` ### ** ```ruby -**(Integer) -> Integer -**(Float) -> Integer +instance.**(Integer) -> Integer +instance.**(Float) -> Integer ``` ### + ```ruby -+(Integer) -> Integer -+(Float) -> Float +instance.+(Integer) -> Integer +instance.+(Float) -> Float ``` ### +@ ```ruby -+@() -> Integer +instance.+@() -> Integer ``` ### - ```ruby --(Integer) -> Integer --(Float) -> Float +instance.-(Integer) -> Integer +instance.-(Float) -> Float ``` ### -@ ```ruby --@() -> Integer +instance.-@() -> Integer ``` ### / ```ruby -/(Integer) -> Integer -/(Float) -> Float +instance./(Integer) -> Integer +instance./(Float) -> Float ``` ### < ```ruby -<(Integer) -> bool +instance.<(Integer) -> bool ``` ### << ```ruby -<<(int) -> Integer +instance.<<(int) -> Integer ``` ### <= ```ruby -<=(Integer) -> bool +instance.<=(Integer) -> bool ``` ### <=> ```ruby -<=>(Integer) -> Integer -<=>(untyped) -> Integer? +instance.<=>(Integer) -> Integer +instance.<=>(untyped) -> Integer? ``` ### == ```ruby -==(untyped) -> bool +instance.==(untyped) -> bool ``` ### === ```ruby -===(untyped) -> bool +instance.===(untyped) -> bool ``` ### > ```ruby ->(Integer) -> bool +instance.>(Integer) -> bool ``` ### >= ```ruby ->=(Integer) -> bool +instance.>=(Integer) -> bool ``` ### >> ```ruby ->>(int) -> Integer +instance.>>(int) -> Integer ``` ### [] ```ruby -[](int) -> Integer -[](int i, int len) -> Integer -[](Range[int]) -> Integer +instance.[](int) -> Integer +instance.[](int i, int len) -> Integer +instance.[](Range[int]) -> Integer ``` ### ^ ```ruby -^(Integer) -> Integer +instance.^(Integer) -> Integer ``` ### abs ```ruby -abs() -> Integer +instance.abs() -> Integer ``` ### chr ```ruby -chr() -> String +instance.chr() -> String ``` ### downto ```ruby -downto(Integer limit) { (Integer) -> void } -> Integer +instance.downto(Integer limit) { (Integer) -> void } -> Integer ``` ### times ```ruby -times() { (Integer) -> void } -> self +instance.times() { (Integer) -> void } -> self ``` ### to_f ```ruby -to_f() -> Float +instance.to_f() -> Float ``` ### to_i ```ruby -to_i() -> Integer +instance.to_i() -> Integer ``` ### to_s ```ruby -to_s() -> String -to_s(2) -> String -to_s(3) -> String -to_s(4) -> String -to_s(5) -> String -to_s(6) -> String -to_s(7) -> String -to_s(8) -> String -to_s(9) -> String -to_s(10) -> String -to_s(11) -> String -to_s(12) -> String -to_s(13) -> String -to_s(14) -> String -to_s(15) -> String -to_s(16) -> String -to_s(17) -> String -to_s(18) -> String -to_s(19) -> String -to_s(20) -> String -to_s(21) -> String -to_s(22) -> String -to_s(23) -> String -to_s(24) -> String -to_s(25) -> String -to_s(26) -> String -to_s(27) -> String -to_s(28) -> String -to_s(29) -> String -to_s(30) -> String -to_s(31) -> String -to_s(32) -> String -to_s(33) -> String -to_s(34) -> String -to_s(35) -> String -to_s(36) -> String -to_s(int base) -> String +instance.to_s() -> String +instance.to_s(2) -> String +instance.to_s(3) -> String +instance.to_s(4) -> String +instance.to_s(5) -> String +instance.to_s(6) -> String +instance.to_s(7) -> String +instance.to_s(8) -> String +instance.to_s(9) -> String +instance.to_s(10) -> String +instance.to_s(11) -> String +instance.to_s(12) -> String +instance.to_s(13) -> String +instance.to_s(14) -> String +instance.to_s(15) -> String +instance.to_s(16) -> String +instance.to_s(17) -> String +instance.to_s(18) -> String +instance.to_s(19) -> String +instance.to_s(20) -> String +instance.to_s(21) -> String +instance.to_s(22) -> String +instance.to_s(23) -> String +instance.to_s(24) -> String +instance.to_s(25) -> String +instance.to_s(26) -> String +instance.to_s(27) -> String +instance.to_s(28) -> String +instance.to_s(29) -> String +instance.to_s(30) -> String +instance.to_s(31) -> String +instance.to_s(32) -> String +instance.to_s(33) -> String +instance.to_s(34) -> String +instance.to_s(35) -> String +instance.to_s(36) -> String +instance.to_s(int base) -> String ``` ### upto ```ruby -upto(Integer limit) { (Integer) -> void } -> Integer +instance.upto(Integer limit) { (Integer) -> void } -> Integer ``` ### | ```ruby -|(Integer) -> Integer +instance.|(Integer) -> Integer ``` ### ~ ```ruby -~() -> Integer +instance.~() -> Integer ``` diff --git a/pages/rbs_doc/Joystick.md b/pages/rbs_doc/Joystick.md index bae1889..d594555 100644 --- a/pages/rbs_doc/Joystick.md +++ b/pages/rbs_doc/Joystick.md @@ -25,31 +25,16 @@ folder: rbs_doc ### new ```ruby -Joystick.new(?Hash[init_axis_t, init_param_t] axes) -> void +Joystick.new(?Hash[init_axis_t, init_param_t] axes) -> instance ``` ## Instance methods ### drift_supression= ```ruby -drift_supression=(Integer) -> bool -``` -### init_axis_offset - -```ruby -init_axis_offset(String axis, Integer pin) -> bool -``` -### init_sensitivity - -```ruby -init_sensitivity(Integer, Float) -> void +instance.drift_supression=(Integer) -> bool ``` ### report_hid ```ruby -report_hid(Integer, Integer) -> nil -``` -### reset_axes - -```ruby -reset_axes() -> nil +instance.report_hid(Integer, Integer) -> nil ``` diff --git a/pages/rbs_doc/Keyboard.md b/pages/rbs_doc/Keyboard.md index aa7cd6d..c11cf08 100644 --- a/pages/rbs_doc/Keyboard.md +++ b/pages/rbs_doc/Keyboard.md @@ -76,7 +76,7 @@ Keyboard.autoreload_ready?() -> bool ### new ```ruby -Keyboard.new-> void +Keyboard.new-> instance ``` ### reload_keymap @@ -97,301 +97,301 @@ Keyboard.wait_keymap() -> void ### action_on_release ```ruby -action_on_release(Integer | Array[Integer] | Proc | nil) -> void +instance.action_on_release(Integer | Array[Integer] | Proc | nil) -> void ``` ### add_layer ```ruby -add_layer(Symbol name, Array[ Symbol | Array[Symbol] ] map) -> void +instance.add_layer(Symbol name, Array[ Symbol | Array[Symbol] ] map) -> void ``` ### anchor? ```ruby -anchor?-> bool +instance.anchor?-> bool ``` ### append ```ruby -append(append_type feature) -> void +instance.append(append_type feature) -> void ``` ### before_report ```ruby -before_report() { (Keyboard) -> void } -> void +instance.before_report() { (Keyboard) -> void } -> void ``` ### bootsel! ```ruby -bootsel!-> void +instance.bootsel!-> void ``` ### calculate_col_position ```ruby -calculate_col_position(Integer col_index) -> Integer +instance.calculate_col_position(Integer col_index) -> Integer ``` ### convert_composite_keys ```ruby -convert_composite_keys(Array[Symbol]) -> Array[Integer] +instance.convert_composite_keys(Array[Symbol]) -> Array[Integer] ``` ### define_composite_key ```ruby -define_composite_key(Symbol key_name, Array[Symbol] keys) -> void +instance.define_composite_key(Symbol key_name, Array[Symbol] keys) -> void ``` ### define_mode_key ```ruby -define_mode_key(Symbol key_name, [Symbol | Array[Symbol] | Proc | nil, Symbol | Proc | nil, Integer?, Integer?] param, ?bool from_via) -> void +instance.define_mode_key(Symbol key_name, [Symbol | Array[Symbol] | Proc | nil, Symbol | Proc | nil, Integer?, Integer?] param, ?bool from_via) -> void ``` ### delete_mode_keys ```ruby -delete_mode_keys(Symbol) -> void +instance.delete_mode_keys(Symbol) -> void ``` ### entire_cols_size ```ruby -entire_cols_size() -> Integer +instance.entire_cols_size() -> Integer ``` ### eval ```ruby -eval(String) -> void +instance.eval(String) -> void ``` ### find_keycode_index ```ruby -find_keycode_index(Symbol key) -> (Integer | Symbol) +instance.find_keycode_index(Symbol key) -> (Integer | Symbol) ``` ### get_layer ```ruby -get_layer(Symbol | nil, Integer) -> ( Array[Array[Integer | Symbol | Proc]] | nil ) +instance.get_layer(Symbol | nil, Integer) -> ( Array[Array[Integer | Symbol | Proc]] | nil ) ``` ### init_direct_pins ```ruby -init_direct_pins(Array[Integer] pins) -> void +instance.init_direct_pins(Array[Integer] pins) -> void ``` ### init_matrix_pins ```ruby -init_matrix_pins(Array[Array[Array[Integer] | nil]] matrix) -> void +instance.init_matrix_pins(Array[Array[Array[Integer] | nil]] matrix) -> void ``` ### init_pins ```ruby -init_pins(Array[Integer] rows, Array[Integer] cols) -> void +instance.init_pins(Array[Integer] rows, Array[Integer] cols) -> void ``` ### init_uart ```ruby -init_uart() -> void +instance.init_uart() -> void ``` ### inject_switch ```ruby -inject_switch(Integer col, Integer row) -> void +instance.inject_switch(Integer col, Integer row) -> void ``` ### invert_sft ```ruby -invert_sft-> void +instance.invert_sft-> void ``` ### key_pressed? ```ruby -key_pressed?() -> bool +instance.key_pressed?() -> bool ``` ### keys_include? ```ruby -keys_include?(Symbol) -> bool +instance.keys_include?(Symbol) -> bool ``` ### lock_layer ```ruby -lock_layer(Symbol layer_name) -> void +instance.lock_layer(Symbol layer_name) -> void ``` ### lower_layer ```ruby -lower_layer-> void +instance.lower_layer-> void ``` ### macro ```ruby -macro(String text, ?::Array[Symbol] opt) -> void +instance.macro(String text, ?::Array[Symbol] opt) -> void ``` ### mutual_uart_at_my_own_risk= ```ruby -mutual_uart_at_my_own_risk=(bool) -> void +instance.mutual_uart_at_my_own_risk=(bool) -> void ``` ### on_start ```ruby -on_start() { (Keyboard) -> void } -> void +instance.on_start() { (Keyboard) -> void } -> void ``` ### output_report_changed ```ruby -output_report_changed() { (Integer) -> void} -> void +instance.output_report_changed() { (Integer) -> void} -> void ``` ### raise_layer ```ruby -raise_layer-> void +instance.raise_layer-> void ``` ### resolve_key_alias ```ruby -resolve_key_alias(Symbol) -> Symbol +instance.resolve_key_alias(Symbol) -> Symbol ``` ### ruby ```ruby -ruby() -> void +instance.ruby() -> void ``` ### scan_direct! ```ruby -scan_direct!() -> void +instance.scan_direct!() -> void ``` ### scan_matrix! ```ruby -scan_matrix!() -> void +instance.scan_matrix!() -> void ``` ### send_key ```ruby -send_key(*untyped) -> void +instance.send_key(*untyped) -> void ``` ### set_anchor ```ruby -set_anchor(anchor_type val) -> void +instance.set_anchor(anchor_type val) -> void ``` ### set_debounce ```ruby -set_debounce(debounce_type) -> void +instance.set_debounce(debounce_type) -> void ``` ### set_debounce_threshold ```ruby -set_debounce_threshold(Integer) -> void +instance.set_debounce_threshold(Integer) -> void ``` ### set_scan_mode ```ruby -set_scan_mode(scan_mode_type val) -> void +instance.set_scan_mode(scan_mode_type val) -> void ``` ### signal_partner ```ruby -signal_partner(Symbol key) { (Keyboard) -> void } -> void +instance.signal_partner(Symbol key) { (Keyboard) -> void } -> void ``` ### skip_position? ```ruby -skip_position?(Integer row_index, Integer col_index) -> bool +instance.skip_position?(Integer row_index, Integer col_index) -> bool ``` ### split_style= ```ruby -split_style=(Symbol style) -> void +instance.split_style=(Symbol style) -> void ``` ### start! ```ruby -start!-> void +instance.start!-> void ``` ### start_features ```ruby -start_features-> void +instance.start_features-> void ``` ### uart_anchor ```ruby -uart_anchor(Integer) -> Integer +instance.uart_anchor(Integer) -> Integer ``` ### uart_anchor_init ```ruby -uart_anchor_init(Integer) -> void +instance.uart_anchor_init(Integer) -> void ``` ### uart_partner ```ruby -uart_partner() -> Integer +instance.uart_partner() -> Integer ``` ### uart_partner_init ```ruby -uart_partner_init(Integer) -> void +instance.uart_partner_init(Integer) -> void ``` ### uart_partner_push8 ```ruby -uart_partner_push8(Integer) -> void +instance.uart_partner_push8(Integer) -> void ``` ### unlock_layer ```ruby -unlock_layer() -> void +instance.unlock_layer() -> void ``` ### via= ```ruby -via=(bool) -> void +instance.via=(bool) -> void ``` ### via_layer_count= ```ruby -via_layer_count=(Integer) -> void +instance.via_layer_count=(Integer) -> void ``` ## Attr accessors ### split (accessor) ```ruby -bool +instance.split -> bool ``` ### uart_pin (accessor) ```ruby -Integer +instance.uart_pin -> Integer ``` ### default_layer (accessor) ```ruby -Symbol +instance.default_layer -> Symbol ``` ### sounder (accessor) ```ruby -Sounder +instance.sounder -> Sounder ``` ### modifier (accessor) ```ruby -Integer +instance.modifier -> Integer ``` ### layer (reader) ```ruby -Symbol | nil +instance.layer -> Symbol | nil ``` ### split_style (reader) ```ruby -split_style_type +instance.split_style -> split_style_type ``` ### cols_size (reader) ```ruby -Integer +instance.cols_size -> Integer ``` ### rows_size (reader) ```ruby -Integer +instance.rows_size -> Integer ``` ### keycodes (reader) ```ruby -Array[Integer] +instance.keycodes -> Array[Integer] ``` diff --git a/pages/rbs_doc/MCP3208.md b/pages/rbs_doc/MCP3208.md index 0bc8308..3c9016f 100644 --- a/pages/rbs_doc/MCP3208.md +++ b/pages/rbs_doc/MCP3208.md @@ -15,11 +15,11 @@ MCP3208.new( ?cipo_pin: Integer, ?copi_pin: Integer, ?cs_pin: Integer - ) -> void + ) -> instance ``` ## Instance methods ### read ```ruby -read(Integer channel, ?differential: bool) -> Integer +instance.read(Integer channel, ?differential: bool) -> Integer ``` diff --git a/pages/rbs_doc/MCP3424.md b/pages/rbs_doc/MCP3424.md index 8a62cbd..5dc4f2e 100644 --- a/pages/rbs_doc/MCP3424.md +++ b/pages/rbs_doc/MCP3424.md @@ -8,56 +8,56 @@ folder: rbs_doc ### new ```ruby -MCP3424.new(i2c: I2C, address_selector: Integer) -> void +MCP3424.new(i2c: I2C, address_selector: Integer) -> instance ``` ## Instance methods ### assert_channel ```ruby -assert_channel(Integer channel) -> void +instance.assert_channel(Integer channel) -> void ``` ### bit_resolution ```ruby -bit_resolution() -> Integer +instance.bit_resolution() -> Integer ``` ### bit_resolution= ```ruby -bit_resolution=(Integer bit_resolution) -> Integer +instance.bit_resolution=(Integer bit_resolution) -> Integer ``` ### one_shot_read ```ruby -one_shot_read(Integer channel, ?(Integer|nil) timeout_ms) -> (Integer|nil) +instance.one_shot_read(Integer channel, ?(Integer|nil) timeout_ms) -> (Integer|nil) ``` ### pga_gain ```ruby -pga_gain() -> Integer +instance.pga_gain() -> Integer ``` ### pga_gain= ```ruby -pga_gain=(Integer pga_gain) -> Integer +instance.pga_gain=(Integer pga_gain) -> Integer ``` ### read ```ruby -read(?(Integer|nil) timeout_ms) -> (Integer|nil) +instance.read(?(Integer|nil) timeout_ms) -> (Integer|nil) ``` ### set_address ```ruby -set_address(Integer address_selector) -> void +instance.set_address(Integer address_selector) -> void ``` ### start_continuous_conversion ```ruby -start_continuous_conversion(Integer channel) -> void +instance.start_continuous_conversion(Integer channel) -> void ``` ## Attr accessors ### address (reader) ```ruby -Integer +instance.address -> Integer ``` diff --git a/pages/rbs_doc/MML.md b/pages/rbs_doc/MML.md index b4c43a0..d8c73f6 100644 --- a/pages/rbs_doc/MML.md +++ b/pages/rbs_doc/MML.md @@ -5,24 +5,14 @@ permalink: MML.html folder: rbs_doc --- ## Singleton methods -### coef +### new ```ruby -MML.coef(Integer) -> Float -``` -### count_punto - -```ruby -MML.count_punto(String, Integer) -> [Integer, Integer] -``` -### number_str - -```ruby -MML.number_str(String, Integer) -> [String, Integer] +MML.new() -> instance ``` ## Instance methods ### compile ```ruby -compile(String) { (Float, Integer) -> bool } -> Integer +instance.compile(String) { (Float, Integer) -> bool } -> Integer ``` diff --git a/pages/rbs_doc/MbedTLS_CMAC.md b/pages/rbs_doc/MbedTLS_CMAC.md index 2356fca..a30bebd 100644 --- a/pages/rbs_doc/MbedTLS_CMAC.md +++ b/pages/rbs_doc/MbedTLS_CMAC.md @@ -5,16 +5,6 @@ permalink: MbedTLS_CMAC.html folder: rbs_doc --- ## Singleton methods -### __init_aes - -```ruby -MbedTLS::CMAC.__init_aes(String) -> MbedTLS::CMAC -``` -### _init_aes - -```ruby -MbedTLS::CMAC._init_aes(String) -> MbedTLS::CMAC -``` ### new ```ruby @@ -24,20 +14,20 @@ MbedTLS::CMAC.new(untyped key, String digest) -> MbedTLS::CMAC ### digest ```ruby -digest-> String +instance.digest-> String ``` ### reset ```ruby -reset-> MbedTLS::CMAC +instance.reset-> MbedTLS::CMAC ``` ### update ```ruby -update(String) -> MbedTLS::CMAC +instance.update(String) -> MbedTLS::CMAC ``` ## Attr accessors ### _digest (accessor) ```ruby -String +instance._digest -> String ``` diff --git a/pages/rbs_doc/Mouse.md b/pages/rbs_doc/Mouse.md index e6e220e..e8a6649 100644 --- a/pages/rbs_doc/Mouse.md +++ b/pages/rbs_doc/Mouse.md @@ -13,37 +13,37 @@ I2C | SPI | Array[ADC] ### new ```ruby -Mouse.new(driver: driver_t) -> void +Mouse.new(driver: driver_t) -> instance ``` ## Instance methods ### button_pressed? ```ruby -button_pressed?() -> bool +instance.button_pressed?() -> bool ``` ### task ```ruby -task() { (Mouse, Keyboard) -> void } -> Proc +instance.task() { (Mouse, Keyboard) -> void } -> Proc ``` ## Attr accessors ### driver (reader) ```ruby -driver_t +instance.driver -> driver_t ``` ### task_proc (accessor) ```ruby -^(Mouse, Keyboard) -> void +instance.task_proc -> ^(Mouse, Keyboard) -> void ``` ### cursor_speed (accessor) ```ruby -Integer +instance.cursor_speed -> Integer ``` ### wheel_speed (accessor) ```ruby -Integer +instance.wheel_speed -> Integer ``` ### buttons (accessor) ```ruby -Integer +instance.buttons -> Integer ``` diff --git a/pages/rbs_doc/NilClass.md b/pages/rbs_doc/NilClass.md index 1fd00e2..2c85e72 100644 --- a/pages/rbs_doc/NilClass.md +++ b/pages/rbs_doc/NilClass.md @@ -8,58 +8,58 @@ folder: rbs_doc ### ! ```ruby -!() -> true +instance.!() -> true ``` ### & ```ruby -&(untyped obj) -> false +instance.&(untyped obj) -> false ``` ### === ```ruby -===(nil) -> true -===(untyped obj) -> bool +instance.===(nil) -> true +instance.===(untyped obj) -> bool ``` ### ^ ```ruby -^(false | nil) -> false -^(untyped obj) -> bool +instance.^(false | nil) -> false +instance.^(untyped obj) -> bool ``` ### inspect ```ruby -inspect() -> "nil" +instance.inspect() -> "nil" ``` ### nil? ```ruby -nil?() -> true +instance.nil?() -> true ``` ### to_f ```ruby -to_f() -> Float +instance.to_f() -> Float ``` ### to_h ```ruby -to_h() -> {} +instance.to_h() -> {} ``` ### to_i ```ruby -to_i() -> 0 +instance.to_i() -> 0 ``` ### to_s ```ruby -to_s() -> "" +instance.to_s() -> "" ``` ### | ```ruby -|(nil | false) -> false -|(untyped obj) -> bool +instance.|(nil | false) -> false +instance.|(untyped obj) -> bool ``` diff --git a/pages/rbs_doc/Object.md b/pages/rbs_doc/Object.md index 6bcb42e..d7cc881 100644 --- a/pages/rbs_doc/Object.md +++ b/pages/rbs_doc/Object.md @@ -8,147 +8,122 @@ folder: rbs_doc ### <=> ```ruby -<=>(untyped) -> Integer? +instance.<=>(untyped) -> Integer? ``` ### === ```ruby -===(untyped) -> bool +instance.===(untyped) -> bool ``` ### attr_accessor ```ruby -attr_accessor(*Symbol) -> void +instance.attr_accessor(*Symbol) -> void ``` ### attr_reader ```ruby -attr_reader(*Symbol) -> void +instance.attr_reader(*Symbol) -> void ``` ### block_given? ```ruby -block_given?() -> bool +instance.block_given?() -> bool ``` ### class ```ruby -class-> class +instance.class-> class ``` ### dup ```ruby -dup() -> self +instance.dup() -> self ``` ### exit ```ruby -exit(?Integer) -> void +instance.exit(?Integer) -> void ``` ### inspect ```ruby -inspect() -> String +instance.inspect() -> String ``` ### is_a? ```ruby -is_a?(untyped) -> bool +instance.is_a?(untyped) -> bool ``` ### nil? ```ruby -nil?() -> bool +instance.nil?() -> bool ``` ### object_id ```ruby -object_id() -> Integer +instance.object_id() -> Integer ``` ### p ```ruby -p[T < _Inspect] (T arg0) -> T -p(_Inspect arg0, _Inspect arg1, *_Inspect rest) -> Array[_Inspect] -p() -> nil +instance.p[T < _Inspect] (T arg0) -> T +instance.p(_Inspect arg0, _Inspect arg1, *_Inspect rest) -> Array[_Inspect] +instance.p() -> nil ``` ### print ```ruby -print(*_ToS args) -> nil +instance.print(*_ToS args) -> nil ``` ### printf ```ruby -printf() -> nil -printf(String fmt, *untyped args) -> nil +instance.printf() -> nil +instance.printf(String fmt, *untyped args) -> nil ``` ### puts ```ruby -puts(*_ToS objects) -> nil +instance.puts(*_ToS objects) -> nil ``` ### raise ```ruby -raise() -> bot -raise(string message) -> bot -raise(Exception exception, ?String cause) -> bot -raise(_Exception exception, ?String cause) -> bot +instance.raise() -> bot +instance.raise(string message) -> bot +instance.raise(Exception exception, ?String cause) -> bot +instance.raise(_Exception exception, ?String cause) -> bot ``` ### sleep ```ruby -sleep(Integer | Float) -> Integer +instance.sleep(Integer | Float) -> Integer ``` ### sleep_ms ```ruby -sleep_ms(Integer) -> Integer +instance.sleep_ms(Integer) -> Integer ``` ### sprintf ```ruby -sprintf(String format, *untyped args) -> String +instance.sprintf(String format, *untyped args) -> String ``` ### to_s ```ruby -to_s() -> String +instance.to_s() -> String ``` ## Instance methods (picoruby-require) -### extern - -```ruby -extern(String path, ?bool force) -> (bool|nil) -``` ### load ```ruby -load(String) -> bool -``` -### load_file - -```ruby -load_file(String) -> bool +instance.load(String) -> bool ``` ### require ```ruby -require(String) -> bool -``` -### require_file - -```ruby -require_file(String) -> bool -``` -### require_relative - -```ruby -require_relative(String) -> bool -``` -### required? - -```ruby -required?(String) -> bool +instance.require(String) -> bool ``` diff --git a/pages/rbs_doc/PCF8523.md b/pages/rbs_doc/PCF8523.md index 130bb9b..53da88c 100644 --- a/pages/rbs_doc/PCF8523.md +++ b/pages/rbs_doc/PCF8523.md @@ -8,21 +8,26 @@ folder: rbs_doc ### new ```ruby -PCF8523.new(i2c: I2C) -> void +PCF8523.new(i2c: I2C) -> instance ``` ## Instance methods ### current_time ```ruby -current_time() -> Time +instance.current_time() -> Time ``` ### current_time= ```ruby -current_time=(Time) -> Time +instance.current_time=(Time) -> Time ``` ### set_power_management ```ruby -set_power_management(?Integer pow) -> Integer +instance.set_power_management(?Integer pow) -> Integer +``` +## Attr accessors +### i2c (reader) +```ruby +instance.i2c -> I2C ``` diff --git a/pages/rbs_doc/PWM.md b/pages/rbs_doc/PWM.md index 2ac8e98..2d5fd0e 100644 --- a/pages/rbs_doc/PWM.md +++ b/pages/rbs_doc/PWM.md @@ -8,31 +8,26 @@ folder: rbs_doc ### new ```ruby -PWM.new(Integer pin, ?frequency: (Float|Integer), ?duty: (Float|Integer)) -> void +PWM.new(Integer pin, ?frequency: (Float|Integer), ?duty: (Float|Integer)) -> instance ``` ## Instance methods -### _init - -```ruby -_init(Integer pin) -> 0 -``` ### duty ```ruby -duty(Float|Integer) -> Float +instance.duty(Float|Integer) -> Float ``` ### frequency ```ruby -frequency(Float|Integer) -> Float +instance.frequency(Float|Integer) -> Float ``` ### period_us ```ruby -period_us(Integer) -> Float +instance.period_us(Integer) -> Float ``` ### pulse_width_us ```ruby -pulse_width_us(Integer) -> Float +instance.pulse_width_us(Integer) -> Float ``` diff --git a/pages/rbs_doc/Proc.md b/pages/rbs_doc/Proc.md index a5e1539..3eb7f75 100644 --- a/pages/rbs_doc/Proc.md +++ b/pages/rbs_doc/Proc.md @@ -14,5 +14,5 @@ Proc.new() { (*untyped) -> untyped } -> void ### call ```ruby -call(*untyped arg0) -> untyped +instance.call(*untyped arg0) -> untyped ``` diff --git a/pages/rbs_doc/RGB.md b/pages/rbs_doc/RGB.md index 5b534d9..aed09d8 100644 --- a/pages/rbs_doc/RGB.md +++ b/pages/rbs_doc/RGB.md @@ -24,177 +24,177 @@ folder: rbs_doc ### new ```ruby -RGB.new(Integer pin, Integer underglow_size, Integer backlight_size, ?bool is_rgbw) -> void +RGB.new(Integer pin, Integer underglow_size, Integer backlight_size, ?bool is_rgbw) -> instance ``` ## Instance methods ### add_pixel ```ruby -add_pixel(Integer, Integer) -> void +instance.add_pixel(Integer, Integer) -> void ``` ### effect= ```ruby -effect=(rgb_effect_t) -> void +instance.effect=(rgb_effect_t) -> void ``` ### fifo_push ```ruby -fifo_push(true data) -> void +instance.fifo_push(true data) -> void ``` ### hsv2rgb ```ruby -hsv2rgb(Float | Integer h, Integer s, Float | Integer v) -> Integer +instance.hsv2rgb(Float | Integer h, Integer s, Float | Integer v) -> Integer ``` ### hue= ```ruby -hue=(Integer) -> void +instance.hue=(Integer) -> void ``` ### init_values ```ruby -init_values() -> void +instance.init_values() -> void ``` ### invoke_anchor ```ruby -invoke_anchor(Symbol | nil) -> Integer +instance.invoke_anchor(Symbol | nil) -> Integer ``` ### invoke_partner ```ruby -invoke_partner(Integer) -> void +instance.invoke_partner(Integer) -> void ``` ### ping? ```ruby -ping?() -> bool +instance.ping?() -> bool ``` ### reset_pixel ```ruby -reset_pixel() -> void +instance.reset_pixel() -> void ``` ### resume ```ruby -resume() -> void +instance.resume() -> void ``` ### saturation= ```ruby -saturation=(Integer) -> void +instance.saturation=(Integer) -> void ``` ### show ```ruby -show-> void +instance.show-> void ``` ### speed= ```ruby -speed=(Integer) -> void +instance.speed=(Integer) -> void ``` ### thunder ```ruby -thunder-> void +instance.thunder-> void ``` ### toggle ```ruby -toggle() -> void +instance.toggle() -> void ``` ### turn_off ```ruby -turn_off() -> void +instance.turn_off() -> void ``` ### turn_on ```ruby -turn_on() -> void +instance.turn_on() -> void ``` ### value= ```ruby -value=(Integer) -> void +instance.value=(Integer | Float) -> void ``` ### ws2812_add_matrix_pixel_at ```ruby -ws2812_add_matrix_pixel_at(Integer, Integer, Integer) -> void +instance.ws2812_add_matrix_pixel_at(Integer, Integer, Integer) -> void ``` ### ws2812_circle ```ruby -ws2812_circle(Integer, Integer, Integer) -> void +instance.ws2812_circle(Integer, Integer, Integer) -> void ``` ### ws2812_circle_set_center ```ruby -ws2812_circle_set_center(Integer, Integer) -> void +instance.ws2812_circle_set_center(Integer, Integer) -> void ``` ### ws2812_fill ```ruby -ws2812_fill(Integer, Integer) -> void +instance.ws2812_fill(Integer, Integer) -> void ``` ### ws2812_init ```ruby -ws2812_init(Integer, Integer, bool) -> void +instance.ws2812_init(Integer, Integer, bool) -> void ``` ### ws2812_init_pixel_distance ```ruby -ws2812_init_pixel_distance(Integer) -> void +instance.ws2812_init_pixel_distance(Integer) -> void ``` ### ws2812_rand_show ```ruby -ws2812_rand_show(Integer, Integer, Integer) -> void +instance.ws2812_rand_show(Integer, Integer, Integer) -> void ``` ### ws2812_reset_swirl_index ```ruby -ws2812_reset_swirl_index() -> bool +instance.ws2812_reset_swirl_index() -> bool ``` ### ws2812_rotate_swirl ```ruby -ws2812_rotate_swirl(Integer) -> bool +instance.ws2812_rotate_swirl(Integer) -> bool ``` ### ws2812_set_pixel_at ```ruby -ws2812_set_pixel_at(Integer, Integer) -> void +instance.ws2812_set_pixel_at(Integer, Integer) -> void ``` ### ws2812_show ```ruby -ws2812_show() -> void +instance.ws2812_show() -> void ``` ## Attr accessors ### pixel_size (reader) ```ruby -Integer +instance.pixel_size -> Integer ``` ### effect (reader) ```ruby -rgb_effect_t +instance.effect -> rgb_effect_t ``` ### action (accessor) ```ruby -action_type +instance.action -> action_type ``` ### anchor (accessor) ```ruby -bool +instance.anchor -> bool ``` ### split_sync (accessor) ```ruby -bool +instance.split_sync -> bool ``` diff --git a/pages/rbs_doc/RTD.md b/pages/rbs_doc/RTD.md index ac19934..3099272 100644 --- a/pages/rbs_doc/RTD.md +++ b/pages/rbs_doc/RTD.md @@ -5,7 +5,7 @@ permalink: RTD.html folder: rbs_doc --- ## Type aliases -### unit_t +### rtd_unit_t ```ruby :celsius | :fahrenheit | :kelvin ``` @@ -18,21 +18,21 @@ RTD.new( current_gpio: GPIO, r_ref: (Float | Integer), ?channels: Hash[Symbol, (Integer | ADC)] - ) -> void + ) -> instance ``` ## Instance methods ### read ```ruby -read(?unit: unit_t) -> Float +instance.read(?unit: rtd_unit_t) -> Float ``` ### temperature_in_celsius ```ruby -temperature_in_celsius(Float) -> Float +instance.temperature_in_celsius(Float) -> Float ``` ## Attr accessors ### sample_count (accessor) ```ruby -Integer +instance.sample_count -> Integer ``` diff --git a/pages/rbs_doc/Range.md b/pages/rbs_doc/Range.md index 76d4ac8..44665e4 100644 --- a/pages/rbs_doc/Range.md +++ b/pages/rbs_doc/Range.md @@ -14,42 +14,42 @@ Range.new(Elem from, Elem to, ?boolish exclude_end) -> void ### == ```ruby -==(untyped obj) -> bool +instance.==(untyped obj) -> bool ``` ### === ```ruby -===(untyped obj) -> bool +instance.===(untyped obj) -> bool ``` ### each ```ruby -each[Elem] () { (Elem arg0) -> untyped } -> self +instance.each[Elem] () { (Elem arg0) -> untyped } -> self ``` ### exclude_end? ```ruby -exclude_end?() -> bool +instance.exclude_end?() -> bool ``` ### first ```ruby -first() -> Elem -first(Integer n) -> ::Array[Elem] +instance.first() -> Elem +instance.first(Integer n) -> ::Array[Elem] ``` ### inspect ```ruby -inspect() -> String +instance.inspect() -> String ``` ### last ```ruby -last() -> Elem -last(Integer n) -> ::Array[Elem] +instance.last() -> Elem +instance.last(Integer n) -> ::Array[Elem] ``` ### to_s ```ruby -to_s() -> String +instance.to_s() -> String ``` diff --git a/pages/rbs_doc/RotaryEncoder.md b/pages/rbs_doc/RotaryEncoder.md index 52d2ce5..80e8bb8 100644 --- a/pages/rbs_doc/RotaryEncoder.md +++ b/pages/rbs_doc/RotaryEncoder.md @@ -8,76 +8,76 @@ folder: rbs_doc ### new ```ruby -RotaryEncoder.new(Integer pin_a, Integer pin_b) -> void +RotaryEncoder.new(Integer pin_a, Integer pin_b) -> instance ``` ## Instance methods ### call_proc_if ```ruby -call_proc_if(Integer) -> void +instance.call_proc_if(Integer) -> void ``` ### ccw ```ruby -ccw() { () -> void } -> void +instance.ccw() { () -> void } -> void ``` ### clockwise ```ruby -clockwise() { () -> void } -> void +instance.clockwise() { () -> void } -> void ``` ### configure ```ruby -configure(Symbol symbol) -> void +instance.configure(Symbol symbol) -> void ``` ### consume_encoder ```ruby -consume_encoder(Integer) -> Integer +instance.consume_encoder(Integer) -> Integer ``` ### consume_rotation_anchor ```ruby -consume_rotation_anchor() -> void +instance.consume_rotation_anchor() -> void ``` ### consume_rotation_partner ```ruby -consume_rotation_partner() -> Integer +instance.consume_rotation_partner() -> Integer ``` ### counterclockwise ```ruby -counterclockwise() { () -> void } -> void +instance.counterclockwise() { () -> void } -> void ``` ### create_keycodes ```ruby -create_keycodes(Integer) -> void +instance.create_keycodes(Integer) -> void ``` ### cw ```ruby -cw() { () -> void } -> void +instance.cw() { () -> void } -> void ``` ### init_encoder ```ruby -init_encoder(Integer, Integer) -> Integer +instance.init_encoder(Integer, Integer) -> Integer ``` ### init_pins ```ruby -init_pins() -> void +instance.init_pins() -> void ``` ### left? ```ruby -left?() -> bool +instance.left?() -> bool ``` ### right? ```ruby -right?() -> bool +instance.right?() -> bool ``` diff --git a/pages/rbs_doc/RubyVM.md b/pages/rbs_doc/RubyVM.md deleted file mode 100644 index 520e087..0000000 --- a/pages/rbs_doc/RubyVM.md +++ /dev/null @@ -1,6 +0,0 @@ ---- -title: RubyVM -sidebar: picoruby_sidebar -permalink: RubyVM.html -folder: rbs_doc ---- diff --git a/pages/rbs_doc/SPI.md b/pages/rbs_doc/SPI.md index 5e27a7e..0e7d1e5 100644 --- a/pages/rbs_doc/SPI.md +++ b/pages/rbs_doc/SPI.md @@ -5,11 +5,11 @@ permalink: SPI.html folder: rbs_doc --- ## Type aliases -### first_bit_t +### spi_first_bit_t ```ruby 0|1 ``` -### mode_t +### spi_mode_t ```ruby 0|1|2|3 ``` @@ -24,83 +24,63 @@ SPI.new( ?cipo_pin: Integer, ?copi_pin: Integer, ?cs_pin: Integer, - ?mode: mode_t, - ?first_bit: first_bit_t - ) -> void + ?mode: spi_mode_t, + ?first_bit: spi_first_bit_t + ) -> instance ``` ## Instance methods -### _init - -```ruby -_init(String unit, Integer frequency, Integer sck_pin, Integer cipo_pin, Integer copo_pin, Integer mode, Integer first_bit, Integer data_bits) -> Integer -``` -### _read - -```ruby -_read(Integer repeated_tx_data, Integer len) -> (String|Integer) -``` -### _transfer - -```ruby -_transfer(Array[Integer]) -> (String|Integer) -``` -### _write - -```ruby -_write(Array[Integer]) -> Integer -``` ### cipo_pin ```ruby -cipo_pin() -> Integer +instance.cipo_pin() -> Integer ``` ### copi_pin ```ruby -copi_pin() -> Integer +instance.copi_pin() -> Integer ``` ### cs_pin ```ruby -cs_pin() -> Integer +instance.cs_pin() -> Integer ``` ### deselect ```ruby -deselect() -> void +instance.deselect() -> void ``` ### params_to_array ```ruby -params_to_array(*(Integer|String)|Array[Integer] params) -> Array[Integer] +instance.params_to_array(*(Integer|String)|Array[Integer] params) -> Array[Integer] ``` ### read ```ruby -read(Integer len, ?Integer repeated_tx_data) -> String +instance.read(Integer len, ?Integer repeated_tx_data) -> String ``` ### sck_pin ```ruby -sck_pin() -> Integer +instance.sck_pin() -> Integer ``` ### select ```ruby -select() ?{ (SPI) -> untyped } -> untyped +instance.select() ?{ (SPI) -> untyped } -> untyped ``` ### transfer ```ruby -transfer(*(Integer|String)|Array[Integer] outputs, ?additional_read_bytes: Integer) -> String +instance.transfer(*(Integer|String)|Array[Integer] outputs, ?additional_read_bytes: Integer) -> String ``` ### write ```ruby -write(*(Integer|String)|Array[Integer] outputs) -> Integer +instance.write(*(Integer|String)|Array[Integer] outputs) -> Integer ``` ## Attr accessors ### unit (reader) ```ruby -String +instance.unit -> String ``` diff --git a/pages/rbs_doc/SQLite3.md b/pages/rbs_doc/SQLite3.md index 9980b43..a1ae89e 100644 --- a/pages/rbs_doc/SQLite3.md +++ b/pages/rbs_doc/SQLite3.md @@ -5,7 +5,7 @@ permalink: SQLite3.html folder: rbs_doc --- ## Type aliases -### var_t +### sqlite3_var_t ```ruby String | Integer | Float | nil | bool ``` diff --git a/pages/rbs_doc/SQLite3_Database.md b/pages/rbs_doc/SQLite3_Database.md index c15e1a5..0750494 100644 --- a/pages/rbs_doc/SQLite3_Database.md +++ b/pages/rbs_doc/SQLite3_Database.md @@ -5,16 +5,11 @@ permalink: SQLite3_Database.html folder: rbs_doc --- ## Type aliases -### row_t +### sqlite3_row_t ```ruby Hash[String, String] | Array[String] ``` ## Singleton methods -### _open - -```ruby -SQLite3::Database._open(String filename) -> SQLite3::Database -``` ### new ```ruby @@ -29,29 +24,29 @@ SQLite3::Database.open(String filename) ?{ (SQLite3::Database) -> void } -> SQLi ### close ```ruby -close-> void +instance.close() -> void ``` ### closed? ```ruby -closed?-> bool +instance.closed?() -> bool ``` ### execute ```ruby -execute(String sql, ?Array[var_t] bind_vars) -> Array[Array[var_t] | Hash[String, var_t]] -execute(String sql, ?Array[var_t] bind_vars) { (Array[var_t]) -> Array[var_t] } -> nil -execute(String sql, ?Array[var_t] bind_vars) { (Hash[String, var_t]) -> Hash[String, var_t] } -> nil -execute(String sql, ?Array[var_t] bind_vars) { (untyped) -> untyped } -> nil +instance.execute(String sql, ?Array[sqlite3_var_t] bind_vars) -> Array[Array[sqlite3_var_t] | Hash[String, sqlite3_var_t]] +instance.execute(String sql, ?Array[sqlite3_var_t] bind_vars) { (Array[sqlite3_var_t]) -> Array[sqlite3_var_t] } -> nil +instance.execute(String sql, ?Array[sqlite3_var_t] bind_vars) { (Hash[String, sqlite3_var_t]) -> Hash[String, sqlite3_var_t] } -> nil +instance.execute(String sql, ?Array[sqlite3_var_t] bind_vars) { (untyped) -> untyped } -> nil ``` ### prepare ```ruby -prepare(String sql) { (SQLite3::Statement) -> untyped } -> nil -prepare(String sql) -> SQLite3::Statement +instance.prepare(String sql) { (SQLite3::Statement) -> untyped } -> nil +instance.prepare(String sql) -> SQLite3::Statement ``` ## Attr accessors ### results_as_hash (accessor) ```ruby -bool +instance.results_as_hash -> bool ``` diff --git a/pages/rbs_doc/SQLite3_ResultSet.md b/pages/rbs_doc/SQLite3_ResultSet.md index f5a2400..bd1d5e2 100644 --- a/pages/rbs_doc/SQLite3_ResultSet.md +++ b/pages/rbs_doc/SQLite3_ResultSet.md @@ -8,21 +8,21 @@ folder: rbs_doc ### new ```ruby -SQLite3::ResultSet.new(SQLite3::Database, SQLite3::Statement) -> void +SQLite3::ResultSet.new(SQLite3::Database, SQLite3::Statement) -> instance ``` ## Instance methods ### each ```ruby -each() { (Array[var_t] | Hash[String, var_t]) -> void } -> nil +instance.each() { (Array[sqlite3_var_t] | Hash[String, sqlite3_var_t]) -> void } -> nil ``` ### next ```ruby -next() -> (Array[var_t] | Hash[String, var_t] | nil) +instance.next() -> (Array[sqlite3_var_t] | Hash[String, sqlite3_var_t] | nil) ``` ### to_a ```ruby -to_a() -> Array[Array[var_t]] +instance.to_a() -> Array[Array[sqlite3_var_t]] ``` diff --git a/pages/rbs_doc/SQLite3_Statement.md b/pages/rbs_doc/SQLite3_Statement.md index a4a2d83..e1e47cf 100644 --- a/pages/rbs_doc/SQLite3_Statement.md +++ b/pages/rbs_doc/SQLite3_Statement.md @@ -8,87 +8,87 @@ folder: rbs_doc ### new ```ruby -SQLite3::Statement.new(SQLite3::Database db, String sql) -> void +SQLite3::Statement.new(SQLite3::Database db, String sql) -> instance ``` ## Instance methods ### active? ```ruby -active?-> bool +instance.active?-> bool ``` ### bind_param ```ruby -bind_param(Integer|Symbol|String key, var_t var) -> self +instance.bind_param(Integer|Symbol|String key, sqlite3_var_t var) -> self ``` ### bind_params ```ruby -bind_params(*(var_t | Hash[Symbol, var_t]) bind_vars) -> Array[var_t | Hash[Symbol, var_t]] +instance.bind_params(*(sqlite3_var_t | Hash[Symbol, sqlite3_var_t]) bind_vars) -> Array[sqlite3_var_t | Hash[Symbol, sqlite3_var_t]] ``` ### close ```ruby -close-> self +instance.close-> self ``` ### closed? ```ruby -closed?-> bool +instance.closed?-> bool ``` ### column_count ```ruby -column_count-> Integer +instance.column_count-> Integer ``` ### column_decltype ```ruby -column_decltype(Integer index) -> String +instance.column_decltype(Integer index) -> String ``` ### column_name ```ruby -column_name(Integer index) -> String +instance.column_name(Integer index) -> String ``` ### columns ```ruby -columns-> Array[String] +instance.columns-> Array[String] ``` ### done? ```ruby -done?-> bool +instance.done?-> bool ``` ### execute ```ruby -execute(*var_t bind_vars) -> SQLite3::ResultSet -execute(*var_t bind_vars) { (SQLite3::ResultSet) -> nil } -> nil +instance.execute(*sqlite3_var_t bind_vars) -> SQLite3::ResultSet +instance.execute(*sqlite3_var_t bind_vars) { (SQLite3::ResultSet) -> nil } -> nil ``` ### get_metadata ```ruby -get_metadata-> void +instance.get_metadata-> void ``` ### must_be_open! ```ruby -must_be_open!-> nil +instance.must_be_open!-> nil ``` ### reset! ```ruby -reset!-> self +instance.reset!-> self ``` ### step ```ruby -step-> (Array[var_t] | nil) +instance.step-> (Array[sqlite3_var_t] | nil) ``` ### types ```ruby -types-> Array[String] +instance.types-> Array[String] ``` diff --git a/pages/rbs_doc/Sandbox.md b/pages/rbs_doc/Sandbox.md index 257da1f..a326e35 100644 --- a/pages/rbs_doc/Sandbox.md +++ b/pages/rbs_doc/Sandbox.md @@ -8,61 +8,61 @@ folder: rbs_doc ### new ```ruby -Sandbox.new(?bool suppress_error) -> void +Sandbox.new(?bool suppress_error) -> instance ``` ## Instance methods ### compile ```ruby -compile(String) -> bool +instance.compile(String) -> bool ``` ### exec_mrb ```ruby -exec_mrb(String) -> bool +instance.exec_mrb(String) -> bool ``` ### execute ```ruby -execute() -> bool +instance.execute() -> bool ``` ### free_parser ```ruby -free_parser() -> void +instance.free_parser() -> void ``` ### interrupt ```ruby -interrupt() -> void +instance.interrupt() -> void ``` ### load_file ```ruby -load_file(String, ?signal: bool) -> void +instance.load_file(String, ?signal: bool) -> void ``` ### result ```ruby -result() -> untyped +instance.result() -> untyped ``` ### state ```ruby -state() -> Integer +instance.state() -> Integer ``` ### suspend ```ruby -suspend() -> void +instance.suspend() -> void ``` ### wait ```ruby -wait(?timeout: (Integer|nil), ?signal: bool) -> bool +instance.wait(?timeout: (Integer|nil), ?signal: bool) -> bool ``` ## Attr accessors ### error (accessor) ```ruby -Exception? +instance.error -> Exception? ``` diff --git a/pages/rbs_doc/Shell.md b/pages/rbs_doc/Shell.md index 71ac56d..0e8b942 100644 --- a/pages/rbs_doc/Shell.md +++ b/pages/rbs_doc/Shell.md @@ -19,35 +19,35 @@ Shell.next_executable-> {code: String, name: String} ### run_irb ```ruby -run_irb-> void +instance.run_irb-> void ``` ### run_shell ```ruby -run_shell-> void +instance.run_shell-> void ``` ### setup_root_volume ```ruby -setup_root_volume(Symbol drive, ?label: String) -> void +instance.setup_root_volume(Symbol drive, ?label: String) -> void ``` ### setup_system_files ```ruby -setup_system_files(?force: bool) -> void +instance.setup_system_files(?force: bool) -> void ``` ### show_logo ```ruby -show_logo-> nil +instance.show_logo-> nil ``` ### simple_question ```ruby -simple_question(String question) { (String answer) -> boolish } -> void +instance.simple_question(String question) { (String answer) -> boolish } -> void ``` ### start ```ruby -start(?:shell mode) -> nil +instance.start(?:shell mode) -> nil ``` diff --git a/pages/rbs_doc/Shell_Command.md b/pages/rbs_doc/Shell_Command.md index 025801d..c18ddca 100644 --- a/pages/rbs_doc/Shell_Command.md +++ b/pages/rbs_doc/Shell_Command.md @@ -8,26 +8,16 @@ folder: rbs_doc ### new ```ruby -Shell::Command.new-> void +Shell::Command.new() -> instance ``` ## Instance methods -### _echo - -```ruby -_echo-> nil -``` -### _type - -```ruby -_type-> nil -``` ### exec ```ruby -exec(*untyped params) -> void +instance.exec(*untyped params) -> void ``` ### find_executable ```ruby -find_executable(String name) -> String? +instance.find_executable(String name) -> String? ``` diff --git a/pages/rbs_doc/Sounder.md b/pages/rbs_doc/Sounder.md index abd45d2..4da46e7 100644 --- a/pages/rbs_doc/Sounder.md +++ b/pages/rbs_doc/Sounder.md @@ -8,61 +8,51 @@ folder: rbs_doc ### new ```ruby -Sounder.new(Integer) -> void +Sounder.new(Integer) -> instance ``` ## Instance methods ### add_note ```ruby -add_note(Float frequency, Integer duration) -> bool +instance.add_note(Float frequency, Integer duration) -> bool ``` ### add_song ```ruby -add_song(Symbol name, *String measures) -> void +instance.add_song(Symbol name, *String measures) -> void ``` ### clear_song ```ruby -clear_song() -> void +instance.clear_song() -> void ``` ### compile ```ruby -compile(*String | Symbol) -> void +instance.compile(*String | Symbol) -> void ``` ### lock ```ruby -lock() -> void +instance.lock() -> void ``` ### play ```ruby -play(*String | Symbol) -> void +instance.play(*String | Symbol) -> void ``` ### replay ```ruby -replay() -> void +instance.replay() -> void ``` ### replay_if_key_pressed ```ruby -replay_if_key_pressed() -> void -``` -### sounder_init - -```ruby -sounder_init(Integer) -> void -``` -### sounder_replay - -```ruby -sounder_replay() -> void +instance.replay_if_key_pressed() -> void ``` ### unlock ```ruby -unlock() -> void +instance.unlock() -> void ``` diff --git a/pages/rbs_doc/String.md b/pages/rbs_doc/String.md index 624c46e..899789d 100644 --- a/pages/rbs_doc/String.md +++ b/pages/rbs_doc/String.md @@ -14,245 +14,245 @@ String.new(?string str) -> void ### ! ```ruby -!() -> bool +instance.!() -> bool ``` ### * ```ruby -*(int n) -> String +instance.*(int n) -> String ``` ### + ```ruby -+(string other_str) -> String +instance.+(string other_str) -> String ``` ### << ```ruby -<<(string | Integer str_or_codepoint) -> String +instance.<<(string | Integer str_or_codepoint) -> String ``` ### <=> ```ruby -<=>(string other) -> Integer -<=>(untyped other) -> Integer? +instance.<=>(string other) -> Integer +instance.<=>(untyped other) -> Integer? ``` ### == ```ruby -==(untyped obj) -> bool +instance.==(untyped obj) -> bool ``` ### === ```ruby -===(untyped obj) -> bool +instance.===(untyped obj) -> bool ``` ### [] ```ruby -[](int index) -> String? -[](int start, int length) -> String? -[](Range[Integer] | Range[Integer?] range) -> String? -[](String match_str) -> String? +instance.[](int index) -> String? +instance.[](int start, int length) -> String? +instance.[](Range[Integer] | Range[Integer?] range) -> String? +instance.[](String match_str) -> String? ``` ### []= ```ruby -[]=(int pos, String new_str) -> String -[]=(int begin_pos, int end_pos, String new_str) -> String -[]=(Range[Integer] | Range[Integer?] range, String new_str) -> String -[]=(String other_str, String new_str) -> String +instance.[]=(int pos, String new_str) -> String +instance.[]=(int begin_pos, int end_pos, String new_str) -> String +instance.[]=(Range[Integer] | Range[Integer?] range, String new_str) -> String +instance.[]=(String other_str, String new_str) -> String ``` ### __ljust_rjust_argcheck ```ruby -__ljust_rjust_argcheck(Integer width, String padding) -> void +instance.__ljust_rjust_argcheck(Integer width, String padding) -> void ``` ### bytes ```ruby -bytes() -> Array[Integer] -bytes() { (Integer byte) -> void } -> String +instance.bytes() -> Array[Integer] +instance.bytes() { (Integer byte) -> void } -> String ``` ### chomp ```ruby -chomp(?string separator) -> String +instance.chomp(?string separator) -> String ``` ### chomp! ```ruby -chomp!(?string separator) -> String? +instance.chomp!(?string separator) -> String? ``` ### clear ```ruby -clear() -> String +instance.clear() -> String ``` ### downcase ```ruby -downcase() -> String -downcase(:ascii | :fold | :lithuanian | :turkic) -> String -downcase(:lithuanian, :turkic) -> String -downcase(:turkic, :lithuanian) -> String +instance.downcase() -> String +instance.downcase(:ascii | :fold | :lithuanian | :turkic) -> String +instance.downcase(:lithuanian, :turkic) -> String +instance.downcase(:turkic, :lithuanian) -> String ``` ### downcase! ```ruby -downcase!() -> String? -downcase!(:ascii | :fold | :lithuanian | :turkic) -> String? -downcase!(:lithuanian, :turkic) -> String? -downcase!(:turkic, :lithuanian) -> String? +instance.downcase!() -> String? +instance.downcase!(:ascii | :fold | :lithuanian | :turkic) -> String? +instance.downcase!(:lithuanian, :turkic) -> String? +instance.downcase!(:turkic, :lithuanian) -> String? ``` ### each_byte ```ruby -each_byte() { (Integer byte) -> void } -> self +instance.each_byte() { (Integer byte) -> void } -> self ``` ### each_char ```ruby -each_char() { (String char) -> void } -> self +instance.each_char() { (String char) -> void } -> self ``` ### empty? ```ruby -empty?() -> bool +instance.empty?() -> bool ``` ### end_with? ```ruby -end_with?(*string suffixes) -> bool +instance.end_with?(*string suffixes) -> bool ``` ### getbyte ```ruby -getbyte(int index) -> Integer? +instance.getbyte(int index) -> Integer? ``` ### include? ```ruby -include?(string other_str) -> bool +instance.include?(string other_str) -> bool ``` ### index ```ruby -index(string substr_or_regexp, ?int offset) -> Integer? +instance.index(string substr_or_regexp, ?int offset) -> Integer? ``` ### inspect ```ruby -inspect() -> String +instance.inspect() -> String ``` ### intern ```ruby -intern() -> Symbol +instance.intern() -> Symbol ``` ### length ```ruby -length() -> Integer +instance.length() -> Integer ``` ### ljust ```ruby -ljust(Integer width, ?string padstr) -> String +instance.ljust(Integer width, ?string padstr) -> String ``` ### lstrip ```ruby -lstrip() -> String +instance.lstrip() -> String ``` ### lstrip! ```ruby -lstrip!() -> self? +instance.lstrip!() -> self? ``` ### ord ```ruby -ord() -> Integer +instance.ord() -> Integer ``` ### rjust ```ruby -rjust(Integer width, ?string padstr) -> String +instance.rjust(Integer width, ?string padstr) -> String ``` ### rstrip ```ruby -rstrip() -> String +instance.rstrip() -> String ``` ### rstrip! ```ruby -rstrip!() -> self? +instance.rstrip!() -> self? ``` ### split ```ruby -split(?string pattern, ?int limit) -> Array[String] +instance.split(?string pattern, ?int limit) -> Array[String] ``` ### start_with? ```ruby -start_with?(*string prefixes) -> bool +instance.start_with?(*string prefixes) -> bool ``` ### strip ```ruby -strip() -> String +instance.strip() -> String ``` ### strip! ```ruby -strip!() -> self? +instance.strip!() -> self? ``` ### to_f ```ruby -to_f() -> Float +instance.to_f() -> Float ``` ### to_i ```ruby -to_i(?int base) -> Integer +instance.to_i(?int base) -> Integer ``` ### to_s ```ruby -to_s() -> String +instance.to_s() -> String ``` ### to_sym ```ruby -to_sym() -> Symbol +instance.to_sym() -> Symbol ``` ### tr ```ruby -tr(string from_str, string to_str) -> String +instance.tr(string from_str, string to_str) -> String ``` ### tr! ```ruby -tr!(string from_str, string to_str) -> String? +instance.tr!(string from_str, string to_str) -> String? ``` ### upcase ```ruby -upcase() -> String -upcase(:ascii | :lithuanian | :turkic) -> String -upcase(:lithuanian, :turkic) -> String -upcase(:turkic, :lithuanian) -> String +instance.upcase() -> String +instance.upcase(:ascii | :lithuanian | :turkic) -> String +instance.upcase(:lithuanian, :turkic) -> String +instance.upcase(:turkic, :lithuanian) -> String ``` ### upcase! ```ruby -upcase!() -> self? -upcase!(:ascii | :lithuanian | :turkic) -> self? -upcase!(:lithuanian, :turkic) -> self? -upcase!(:turkic, :lithuanian) -> self? +instance.upcase!() -> self? +instance.upcase!(:ascii | :lithuanian | :turkic) -> self? +instance.upcase!(:lithuanian, :turkic) -> self? +instance.upcase!(:turkic, :lithuanian) -> self? ``` diff --git a/pages/rbs_doc/Symbol.md b/pages/rbs_doc/Symbol.md index 7de78b3..7369d91 100644 --- a/pages/rbs_doc/Symbol.md +++ b/pages/rbs_doc/Symbol.md @@ -8,31 +8,31 @@ folder: rbs_doc ### <=> ```ruby -<=>(Symbol other) -> Integer -<=>(untyped other) -> Integer? +instance.<=>(Symbol other) -> Integer +instance.<=>(untyped other) -> Integer? ``` ### == ```ruby -==(untyped obj) -> bool +instance.==(untyped obj) -> bool ``` ### === ```ruby -===(untyped obj) -> bool +instance.===(untyped obj) -> bool ``` ### id2name ```ruby -id2name() -> String +instance.id2name() -> String ``` ### inspect ```ruby -inspect() -> String +instance.inspect() -> String ``` ### to_sym ```ruby -to_sym() -> Symbol +instance.to_sym() -> Symbol ``` diff --git a/pages/rbs_doc/Task.md b/pages/rbs_doc/Task.md index e277f65..6e1ea57 100644 --- a/pages/rbs_doc/Task.md +++ b/pages/rbs_doc/Task.md @@ -5,44 +5,39 @@ permalink: Task.html folder: rbs_doc --- ## Singleton methods -### new - -```ruby -Task.new(*untyped) { (*untyped) -> void } -> void -``` ### list ```ruby Task.list() -> Array[Task] ``` -## Instance methods -### _start +### new ```ruby -_start() -> void +Task.new(*untyped) { (*untyped) -> void } -> instance ``` +## Instance methods ### join ```ruby -join(?Integer|nil) -> (self | nil) +instance.join(?Integer|nil) -> (self | nil) ``` ### name= ```ruby -name=(String) -> String +instance.name=(String) -> String ``` ### suspend ```ruby -suspend() -> self +instance.suspend() -> self ``` ### terminate ```ruby -terminate() -> self +instance.terminate() -> self ``` ## Attr accessors ### name (reader) ```ruby -String | nil +instance.name -> String | nil ``` diff --git a/pages/rbs_doc/Terminal_Base.md b/pages/rbs_doc/Terminal_Base.md index a6aea4c..8a83923 100644 --- a/pages/rbs_doc/Terminal_Base.md +++ b/pages/rbs_doc/Terminal_Base.md @@ -14,43 +14,43 @@ Terminal::Base.new-> void ### clear ```ruby -clear-> untyped +instance.clear-> untyped ``` ### debug ```ruby -debug(untyped text) -> Integer? +instance.debug(untyped text) -> Integer? ``` ### home ```ruby -home-> untyped +instance.home-> untyped ``` ### next_head ```ruby -next_head-> untyped +instance.next_head-> untyped ``` ### physical_line_count ```ruby -physical_line_count-> Integer +instance.physical_line_count-> Integer ``` ### system ```ruby -system(untyped command) -> Integer +instance.system(untyped command) -> Integer ``` ## Attr accessors ### width (reader) ```ruby -Integer +instance.width -> Integer ``` ### height (reader) ```ruby -Integer +instance.height -> Integer ``` ### debug_tty (accessor) ```ruby -String? +instance.debug_tty -> String? ``` diff --git a/pages/rbs_doc/Terminal_Buffer.md b/pages/rbs_doc/Terminal_Buffer.md index 1fcf957..ff4e4f3 100644 --- a/pages/rbs_doc/Terminal_Buffer.md +++ b/pages/rbs_doc/Terminal_Buffer.md @@ -8,93 +8,93 @@ folder: rbs_doc ### new ```ruby -Terminal::Buffer.new-> void +Terminal::Buffer.new() -> instance ``` ## Instance methods ### bottom ```ruby -bottom-> void +instance.bottom-> void ``` ### clear ```ruby -clear-> void +instance.clear-> void ``` ### current_char ```ruby -current_char-> String? +instance.current_char-> String? ``` ### current_line ```ruby -current_line-> String +instance.current_line-> String ``` ### current_tail ```ruby -current_tail(?Integer n) -> String +instance.current_tail(?Integer n) -> String ``` ### down ```ruby -down-> void +instance.down-> void ``` ### dump ```ruby -dump-> String +instance.dump-> String ``` ### head ```ruby -head-> void +instance.head-> void ``` ### home ```ruby -home-> void +instance.home-> void ``` ### left ```ruby -left-> void +instance.left-> void ``` ### put ```ruby -put(String | Symbol c) -> void +instance.put(String | Symbol c) -> void ``` ### right ```ruby -right-> void +instance.right-> void ``` ### tail ```ruby -tail-> void +instance.tail-> void ``` ### up ```ruby -up-> void +instance.up-> void ``` ## Attr accessors ### lines (accessor) ```ruby -Array[String] +instance.lines -> Array[String] ``` ### changed (accessor) ```ruby -bool +instance.changed -> bool ``` ### cursor_x (reader) ```ruby -Integer +instance.cursor_x -> Integer ``` ### cursor_y (reader) ```ruby -Integer +instance.cursor_y -> Integer ``` diff --git a/pages/rbs_doc/Terminal_Editor.md b/pages/rbs_doc/Terminal_Editor.md index 2c094cc..596cf1d 100644 --- a/pages/rbs_doc/Terminal_Editor.md +++ b/pages/rbs_doc/Terminal_Editor.md @@ -14,49 +14,49 @@ Terminal::Editor.new-> void ### calculate_visual_cursor ```ruby -calculate_visual_cursor-> void +instance.calculate_visual_cursor-> void ``` ### load_file_into_buffer ```ruby -load_file_into_buffer(untyped filepath) -> bool +instance.load_file_into_buffer(untyped filepath) -> bool ``` ### refresh ```ruby -refresh-> void +instance.refresh-> void ``` ### refresh_cursor ```ruby -refresh_cursor() { (self) -> void } -> void +instance.refresh_cursor() { (self) -> void } -> void ``` ### refresh_footer ```ruby -refresh_footer() { (self) -> void } -> void +instance.refresh_footer() { (self) -> void } -> void ``` ### save_file_from_buffer ```ruby -save_file_from_buffer(untyped filepath) -> String +instance.save_file_from_buffer(untyped filepath) -> String ``` ### show_cursor ```ruby -show_cursor-> untyped +instance.show_cursor-> untyped ``` ### start ```ruby -start() { (self, Terminal::Buffer, Integer) -> void } -> void +instance.start() { (self, Terminal::Buffer, Integer) -> void } -> void ``` ## Attr accessors ### footer_height (accessor) ```ruby -Integer +instance.footer_height -> Integer ``` ### quit_by_ctrl_c (accessor) ```ruby -bool +instance.quit_by_ctrl_c -> bool ``` diff --git a/pages/rbs_doc/Terminal_Line.md b/pages/rbs_doc/Terminal_Line.md index 9ead694..2ec47fa 100644 --- a/pages/rbs_doc/Terminal_Line.md +++ b/pages/rbs_doc/Terminal_Line.md @@ -14,35 +14,35 @@ Terminal::Line.new-> void ### feed_at_bottom ```ruby -feed_at_bottom-> Integer +instance.feed_at_bottom-> Integer ``` ### history_head ```ruby -history_head-> Integer +instance.history_head-> Integer ``` ### load_history ```ruby -load_history(:down | :up dir) -> void +instance.load_history(:down | :up dir) -> void ``` ### prompt= ```ruby -prompt=(String word) -> Integer +instance.prompt=(String word) -> Integer ``` ### refresh ```ruby -refresh-> void +instance.refresh-> void ``` ### save_history ```ruby -save_history-> Integer +instance.save_history-> Integer ``` ### start ```ruby -start() { (self, Terminal::Buffer, Integer) -> void } -> void +instance.start() { (self, Terminal::Buffer, Integer) -> void } -> void ``` diff --git a/pages/rbs_doc/Time.md b/pages/rbs_doc/Time.md index 7385ef1..21ee868 100644 --- a/pages/rbs_doc/Time.md +++ b/pages/rbs_doc/Time.md @@ -46,132 +46,132 @@ Time.time_methods() -> Time::TimeMethods ### + ```ruby -+(Integer arg0) -> Time +instance.+(Integer arg0) -> Time ``` ### - ```ruby --(Time arg0) -> Float --(Integer arg0) -> Time +instance.-(Time arg0) -> Float +instance.-(Integer arg0) -> Time ``` ### < ```ruby -<(Time arg0) -> bool +instance.<(Time arg0) -> bool ``` ### <= ```ruby -<=(Time arg0) -> bool +instance.<=(Time arg0) -> bool ``` ### <=> ```ruby -<=>(Time other) -> Integer -<=>(untyped other) -> Integer? +instance.<=>(Time other) -> Integer +instance.<=>(untyped other) -> Integer? ``` ### > ```ruby ->(Time arg0) -> bool +instance.>(Time arg0) -> bool ``` ### >= ```ruby ->=(Time arg0) -> bool +instance.>=(Time arg0) -> bool ``` ### friday? ```ruby -friday?() -> bool +instance.friday?() -> bool ``` ### hour ```ruby -hour() -> Integer +instance.hour() -> Integer ``` ### inspect ```ruby -inspect() -> String +instance.inspect() -> String ``` ### mday ```ruby -mday() -> Integer +instance.mday() -> Integer ``` ### min ```ruby -min() -> Integer +instance.min() -> Integer ``` ### mon ```ruby -mon() -> Integer +instance.mon() -> Integer ``` ### monday? ```ruby -monday?() -> bool +instance.monday?() -> bool ``` ### saturday? ```ruby -saturday?() -> bool +instance.saturday?() -> bool ``` ### sec ```ruby -sec() -> Integer +instance.sec() -> Integer ``` ### sunday? ```ruby -sunday?() -> bool +instance.sunday?() -> bool ``` ### thursday? ```ruby -thursday?() -> bool +instance.thursday?() -> bool ``` ### to_f ```ruby -to_f() -> Float +instance.to_f() -> Float ``` ### to_i ```ruby -to_i() -> Integer +instance.to_i() -> Integer ``` ### to_s ```ruby -to_s() -> String +instance.to_s() -> String ``` ### tuesday? ```ruby -tuesday?() -> bool +instance.tuesday?() -> bool ``` ### usec ```ruby -usec() -> Integer +instance.usec() -> Integer ``` ### wday ```ruby -wday() -> Integer +instance.wday() -> Integer ``` ### wednesday? ```ruby -wednesday?() -> bool +instance.wednesday?() -> bool ``` ### year ```ruby -year() -> Integer +instance.year() -> Integer ``` diff --git a/pages/rbs_doc/TimeMethods.md b/pages/rbs_doc/TimeMethods.md deleted file mode 100644 index e9ec9aa..0000000 --- a/pages/rbs_doc/TimeMethods.md +++ /dev/null @@ -1,6 +0,0 @@ ---- -title: TimeMethods -sidebar: picoruby_sidebar -permalink: TimeMethods.html -folder: rbs_doc ---- diff --git a/pages/rbs_doc/Time_TimeMethods.md b/pages/rbs_doc/Time_TimeMethods.md new file mode 100644 index 0000000..9f88104 --- /dev/null +++ b/pages/rbs_doc/Time_TimeMethods.md @@ -0,0 +1,6 @@ +--- +title: Time::TimeMethods +sidebar: picoruby_sidebar +permalink: Time_TimeMethods.html +folder: rbs_doc +--- diff --git a/pages/rbs_doc/TrueClass.md b/pages/rbs_doc/TrueClass.md index 22a2892..25a86b2 100644 --- a/pages/rbs_doc/TrueClass.md +++ b/pages/rbs_doc/TrueClass.md @@ -8,33 +8,33 @@ folder: rbs_doc ### ! ```ruby -!() -> false +instance.!() -> false ``` ### & ```ruby -&(false | nil) -> false -&(untyped obj) -> bool +instance.&(false | nil) -> false +instance.&(untyped obj) -> bool ``` ### === ```ruby -===(true) -> true -===(untyped obj) -> bool +instance.===(true) -> true +instance.===(untyped obj) -> bool ``` ### ^ ```ruby -^(false | nil) -> true -^(untyped obj) -> bool +instance.^(false | nil) -> true +instance.^(untyped obj) -> bool ``` ### to_s ```ruby -to_s() -> "true" +instance.to_s() -> "true" ``` ### | ```ruby -|(untyped obj) -> true +instance.|(untyped obj) -> true ``` diff --git a/pages/rbs_doc/UART.md b/pages/rbs_doc/UART.md index a6c8864..465ddf1 100644 --- a/pages/rbs_doc/UART.md +++ b/pages/rbs_doc/UART.md @@ -25,73 +25,73 @@ UART.new( ?rts_pin: Integer, ?cts_pin: Integer, ?rx_buffer_size: Integer? - ) -> void + ) -> instance ``` ## Instance methods ### break ```ruby -break(?Integer|Float time) -> self +instance.break(?Integer|Float time) -> self ``` ### bytes_available ```ruby -bytes_available() -> Integer +instance.bytes_available() -> Integer ``` ### clear_rx_buffer ```ruby -clear_rx_buffer() -> self +instance.clear_rx_buffer() -> self ``` ### clear_tx_buffer ```ruby -clear_tx_buffer() -> self +instance.clear_tx_buffer() -> self ``` ### flush ```ruby -flush() -> self +instance.flush() -> self ``` ### gets ```ruby -gets() -> String +instance.gets() -> String ``` ### line_ending= ```ruby -line_ending=(("\n"|"\r\n"|"\r") line_ending) -> void +instance.line_ending=(("\n"|"\r\n"|"\r") line_ending) -> void ``` ### puts ```ruby -puts(String) -> nil +instance.puts(String) -> nil ``` ### read ```ruby -read(?Integer len) -> (String | nil) +instance.read(?Integer len) -> (String | nil) ``` ### readpartial ```ruby -readpartial(Integer maxlen) -> String +instance.readpartial(Integer maxlen) -> String ``` ### set_flow_control ```ruby -set_flow_control(Integer flow_control, Integer rts_pin, Integer cts_pin) -> void +instance.set_flow_control(Integer flow_control, Integer rts_pin, Integer cts_pin) -> void ``` ### set_format ```ruby -set_format(Integer data_bits, Integer stop_bits, Integer parity) -> void +instance.set_format(Integer data_bits, Integer stop_bits, Integer parity) -> void ``` ### setmode ```ruby -setmode( +instance.setmode( ?baudrate: Integer?, ?data_bits: Integer?, ?stop_bits: Integer?, @@ -104,10 +104,10 @@ setmode( ### write ```ruby -write(String str) -> Integer +instance.write(String str) -> Integer ``` ## Attr accessors ### baudrate (reader) ```ruby -Integer +instance.baudrate -> Integer ``` diff --git a/pages/rbs_doc/VFS_Dir.md b/pages/rbs_doc/VFS_Dir.md index 3c382ea..d70c20a 100644 --- a/pages/rbs_doc/VFS_Dir.md +++ b/pages/rbs_doc/VFS_Dir.md @@ -14,5 +14,5 @@ VFS::Dir.open(String) -> dir_t ### pat= ```ruby -pat=(array[path] | path) -> Array[String] +instance.pat=(array[path] | path) -> Array[String] ``` diff --git a/pages/rbs_doc/VIA.md b/pages/rbs_doc/VIA.md index 34fb77c..5d76bdc 100644 --- a/pages/rbs_doc/VIA.md +++ b/pages/rbs_doc/VIA.md @@ -4,138 +4,144 @@ sidebar: picoruby_sidebar permalink: VIA.html folder: rbs_doc --- +## Singleton methods +### new + +```ruby +VIA.new() -> instance +``` ## Instance methods ### add_mode_key ```ruby -add_mode_key(Symbol key_name, [Symbol | Array[Symbol] | Proc | nil, Symbol | Proc | nil, Integer?, Integer?] param) -> void +instance.add_mode_key(Symbol key_name, [Symbol | Array[Symbol] | Proc | nil, Symbol | Proc | nil, Integer?, Integer?] param) -> void ``` ### check_for_keycode_shift ```ruby -check_for_keycode_shift(Integer) -> ( Symbol | nil ) +instance.check_for_keycode_shift(Integer) -> ( Symbol | nil ) ``` ### cols_size ```ruby -cols_size-> Integer +instance.cols_size-> Integer ``` ### define_mode_key ```ruby -define_mode_key(Symbol key_name, [Symbol | Array[Symbol] | Proc | nil, Symbol | Proc | nil, Integer?, Integer?] param) -> void +instance.define_mode_key(Symbol key_name, [Symbol | Array[Symbol] | Proc | nil, Symbol | Proc | nil, Integer?, Integer?] param) -> void ``` ### dynamic_keymap_get_buffer ```ruby -dynamic_keymap_get_buffer(Array[Integer]) -> Array[Integer] +instance.dynamic_keymap_get_buffer(Array[Integer]) -> Array[Integer] ``` ### dynamic_keymap_get_keycode ```ruby -dynamic_keymap_get_keycode(Integer, Integer, Integer) -> Integer +instance.dynamic_keymap_get_keycode(Integer, Integer, Integer) -> Integer ``` ### dynamic_keymap_set_buffer ```ruby -dynamic_keymap_set_buffer(Array[Integer]) -> void +instance.dynamic_keymap_set_buffer(Array[Integer]) -> void ``` ### dynamic_keymap_set_keycode ```ruby -dynamic_keymap_set_keycode(Integer, Integer, Integer, Integer) -> void +instance.dynamic_keymap_set_keycode(Integer, Integer, Integer, Integer) -> void ``` ### expand_composite_key ```ruby -expand_composite_key(Symbol) -> Array[Symbol] +instance.expand_composite_key(Symbol) -> Array[Symbol] ``` ### get_modifier_name ```ruby -get_modifier_name(Integer) -> String +instance.get_modifier_name(Integer) -> String ``` ### get_via_composite_keycode ```ruby -get_via_composite_keycode(Symbol) -> Integer +instance.get_via_composite_keycode(Symbol) -> Integer ``` ### init_keymap ```ruby -init_keymap-> void +instance.init_keymap-> void ``` ### load_mode_keys ```ruby -load_mode_keys-> void +instance.load_mode_keys-> void ``` ### prk_keycode_into_via_keycode ```ruby -prk_keycode_into_via_keycode(Integer | Symbol | Proc) -> Integer +instance.prk_keycode_into_via_keycode(Integer | Symbol | Proc) -> Integer ``` ### raw_hid_receive ```ruby -raw_hid_receive(Array[Integer]) -> Array[Integer] +instance.raw_hid_receive(Array[Integer]) -> Array[Integer] ``` ### raw_hid_receive_kb ```ruby -raw_hid_receive_kb(Array[Integer]) -> Array[Integer] +instance.raw_hid_receive_kb(Array[Integer]) -> Array[Integer] ``` ### rows_size ```ruby -rows_size-> Integer +instance.rows_size-> Integer ``` ### save_keymap ```ruby -save_keymap-> void +instance.save_keymap-> void ``` ### save_on_flash ```ruby -save_on_flash-> void +instance.save_on_flash-> void ``` ### save_on_keyboard ```ruby -save_on_keyboard-> void +instance.save_on_keyboard-> void ``` ### start! ```ruby -start!-> void +instance.start!-> void ``` ### sync_keymap ```ruby -sync_keymap(?bool)-> void +instance.sync_keymap(?bool)-> void ``` ### task ```ruby -task-> void +instance.task-> void ``` ### via_get_layer_name ```ruby -via_get_layer_name(Integer) -> Symbol +instance.via_get_layer_name(Integer) -> Symbol ``` ### via_keycode_into_keysymbol ```ruby -via_keycode_into_keysymbol(Integer) -> Symbol +instance.via_keycode_into_keysymbol(Integer) -> Symbol ``` ## Attr accessors ### kbd (accessor) ```ruby -Keyboard +instance.kbd -> Keyboard ``` ### layer_count (accessor) ```ruby -Integer +instance.layer_count -> Integer ``` diff --git a/pages/rbs_doc/Vim.md b/pages/rbs_doc/Vim.md index 50fe5bf..c5464d3 100644 --- a/pages/rbs_doc/Vim.md +++ b/pages/rbs_doc/Vim.md @@ -8,26 +8,21 @@ folder: rbs_doc ### new ```ruby -Vim.new(String filepath) -> void +Vim.new(String filepath) -> instance ``` ## Instance methods -### _start - -```ruby -_start-> void -``` ### exec_command ```ruby -exec_command(Terminal::Buffer buffer) -> (:quit | String | nil) +instance.exec_command(Terminal::Buffer buffer) -> (:quit | String | nil) ``` ### save_file ```ruby -save_file-> String +instance.save_file-> String ``` ### start ```ruby -start-> void +instance.start-> void ``` diff --git a/pages/rbs_doc/Watchdog.md b/pages/rbs_doc/Watchdog.md index c826d44..35de46f 100644 --- a/pages/rbs_doc/Watchdog.md +++ b/pages/rbs_doc/Watchdog.md @@ -48,5 +48,5 @@ Watchdog.update(Integer delay_ms) -> 0 ## Attr accessors ### enabled (accessor) ```ruby -bool +instance.enabled -> bool ```