http-2 1.1.0 has been released.
https://github.com/igrigorik/http-2
Pure Ruby, framework and transport agnostic, implementation of HTTP/2
protocol and HPACK header compression with support for:
* [Binary framing](https://hpbn.co/http2/#binary-framing-layer) parsing and
encoding
* [Stream multiplexing](https://hpbn.co/http2/#streams-messages-and-frames)
and [prioritization](https://hpbn.co/http2/#stream-prioritization)
* Connection and stream [flow control](https://hpbn.co/http2/#flow-control)
* [Header compression](https://hpbn.co/http2/#header-compression) and
[server push](https://hpbn.co/http2/#server-push)
* Connection and stream management
* And more... see [API docs](https://www.rubydoc.info/gems/http-2)
Protocol specifications:
* [Hypertext Transfer Protocol Version 2 (RFC 7540)](
https://httpwg.github.io/specs/rfc7540.html)
* [HPACK: Header Compression for HTTP/2 (RFC 7541)](
https://httpwg.github.io/specs/rfc7541.html)
Here are the updates since the last release:
## 1.1.0
Several changes which improved performance for the common cases. A few
highlights:
* Opting into ruby 3.4 features when possible (such as
`String#append_as_bytes` instead of `String#<<`)
* reducing string and array allocations on several places (connection
management, frame generation, hpack header compression, etc)
* "streams recently closed" not having to regenerate the list when not
necessary
## 1.0.2
### Improvements
* Freezing static tables (used for header huffman coding) correctly. This
makes them shareable, which makes `http-2` usable across ractors.
* Moved buffer helpers from String refinements into mixins. Refinements
impose a relevant performance penalty, unfortunately, despite its cleaner
API.
## 1.0.1
### Improvements
* discard closed streams from the connection (reduces memory consumption).
### Bugfixes
* allow RST_STREAM frames to be ignored on closed streams.
* prevent already closed streams from being initialized again.
minitest-speed version 1.1.0 has been released!
* home: <https://github.com/seattlerb/minitest-speed>
* rdoc: <http://docs.seattlerb.org/minitest-speed>
minitest-speed adds test hooks to verify the time it takes to run the
setup, body, and teardown phases of each test. If the time of any
phase goes over the maximum time, it fails the test. Use class
variables to set the maximum thresholds and crank it down over time.
Changes:
### 1.1.0 / 2025-04-07
* 3 minor enhancements:
* Added a message to the assertions to clarify which one fired. (HeyNonster)
* Added permit_slow_* methods to allow for disabling the speed checks. (HeyNonster)
* Allow for custom clock_time to be set. (HeyNonster)
ruby2ruby version 2.5.2 has been released!
* home: <https://github.com/seattlerb/ruby2ruby>
* rdoc: <http://docs.seattlerb.org/ruby2ruby>
ruby2ruby provides a means of generating pure ruby code easily from
RubyParser compatible Sexps. This makes making dynamic language
processors in ruby easier than ever!
Changes:
### 2.5.2 / 2025-03-25
* 1 bug fix:
* Added support for 3 slot op_asgn (eg `a &= 1`)
This upgrade release updates the targeted wxWidgets release to the new 3.2.7 release and also provides
a few updates for wxWidgets changes.
** What's Changed **
* update targeted wxWidgets release to 3.2.7
* update wxWidgets master branch compatibility to at least commit d180041641241306175ab45b685d4c54cfff0e3a
For more details see the original release announcement here: https://github.com/mcorino/wxRuby3/discussions/369
minitest version 5.25.5 has been released!
* home: <https://github.com/minitest/minitest>
* bugs: <https://github.com/minitest/minitest/issues>
* rdoc: <https://docs.seattlerb.org/minitest>
* clog: <https://github.com/minitest/minitest/blob/master/History.rdoc>
* vim: <https://github.com/sunaku/vim-ruby-minitest>
* emacs: <https://github.com/arthurnn/minitest-emacs>
minitest provides a complete suite of testing facilities supporting
TDD, BDD, mocking, and benchmarking.
"I had a class with Jim Weirich on testing last week and we were
allowed to choose our testing frameworks. Kirk Haines and I were
paired up and we cracked open the code for a few test
frameworks...
I MUST say that minitest is *very* readable / understandable
compared to the 'other two' options we looked at. Nicely done and
thank you for helping us keep our mental sanity."
-- Wayne E. Seguin
minitest/test is a small and incredibly fast unit testing framework.
It provides a rich set of assertions to make your tests clean and
readable.
minitest/spec is a functionally complete spec engine. It hooks onto
minitest/test and seamlessly bridges test assertions over to spec
expectations.
minitest/benchmark is an awesome way to assert the performance of your
algorithms in a repeatable manner. Now you can assert that your newb
co-worker doesn't replace your linear algorithm with an exponential
one!
minitest/mock by Steven Baker, is a beautifully tiny mock (and stub)
object framework.
minitest/pride shows pride in testing and adds coloring to your test
output. I guess it is an example of how to write IO pipes too. :P
minitest/test is meant to have a clean implementation for language
implementors that need a minimal set of methods to bootstrap a working
test suite. For example, there is no magic involved for test-case
discovery.
"Again, I can't praise enough the idea of a testing/specing
framework that I can actually read in full in one sitting!"
-- Piotr Szotkowski
Comparing to rspec:
rspec is a testing DSL. minitest is ruby.
-- Adam Hawkins, "Bow Before MiniTest"
minitest doesn't reinvent anything that ruby already provides, like:
classes, modules, inheritance, methods. This means you only have to
learn ruby to use minitest and all of your regular OO practices like
extract-method refactorings still apply.
Changes:
### 5.25.5 / 2025-03-12
* 4 bug fixes:
* Bumped minimum ruby to 2.7.
* Fixed expectation docs for must/wont_pattern_match. (jaredcwhite)
* Reorder Minitest::Test.ancestors to allow reaching Minitest::Assertions#skipped? (Edouard-chin)
* Update the ruby and rails compatibility tables. (bquorning)
RubyInline version 3.14.2 has been released!
* rdoc: <http://docs.seattlerb.org/RubyInline/>
* home: <http://www.zenspider.com/ZSS/Products/RubyInline/>
* code: <https://github.com/seattlerb/rubyinline>
Inline allows you to write foreign code within your ruby code. It
automatically determines if the code in question has changed and
builds it only when necessary. The extensions are then automatically
loaded into the class/module that defines it.
You can even write extra builders that will allow you to write inlined
code in any language. Use Inline::C as a template and look at
Module#inline for the required API.
Changes:
### 3.14.2 / 2025-03-11
* 2 bug fixes:
* Fix for windows builds. (fenrir-naru)
* Ruby 3.4: Fixed breakage from ruby 3.4 call stack changes.
*REF:*
https://github.com/ahoward/clee
*README.md:*
NAME
----
`clee`
TL;DR;
--------
`clee` is a tiny, 0 dependency, DSL for building über clean CLIs in Ruby
INSTALL
-------
```sh
gem install clee
```
URI
---
http://github.com/ahoward/clee
ABOUT
-----
`clee` is a minimalist version of `main` (https://github.com/ahoward/main)
a
command line DSL i wrote almost 15 years ago, that has seen over [4 million
downloads](https://drawohara.io/rubygems/)
> then why should i use `clee` instead of `main` ?
* `clee` has 0 dependencies beyond ruby itself
* `clee` is very very small
```sh
drawohara@drawohara.dev:ahoward #=> loc clee/lib
clee/lib/clee.rb: 478
===
@loc: 478
drawohara@drawohara.dev:ahoward #=> loc main/lib
main/lib/main/cast.rb: 139
main/lib/main/daemon.rb: 395
main/lib/main/dsl.rb: 65
main/lib/main/factories.rb: 24
main/lib/main/getoptlong.rb: 245
main/lib/main/logger.rb: 43
main/lib/main/mode.rb: 41
main/lib/main/parameter.rb: 589
main/lib/main/program/class_methods.rb: 362
main/lib/main/program/instance_methods.rb: 274
main/lib/main/program.rb: 6
main/lib/main/softspoken.rb: 12
main/lib/main/stdext.rb: 34
main/lib/main/test.rb: 69
main/lib/main/usage.rb: 159
main/lib/main/util.rb: 96
main/lib/main.rb: 70
===
@loc: 2623
```
* you can use this to decide which to use:
```ruby
case
when wants?(:simple, :tiny, :scripting)
:clee
when wants?(:powerful, :testable, :complete, :mature)
:main
else
[:clee, :main].sort_by{ rand }.first
end
```
API
---
##### `clee`'s api is very simple. it has every feature you need, and none
that you
don't, including:
- auto generated help messages
- support for `my_clee --help` and `my_clee help` to 'just work'
- support for modifying help/usage messages simply
- sane exit codes
- support for --options, env=val pairs, etc
- argv parsing
- fancy color'd logging
- modes, and sub-modes
##### the smallest clee script looks like this
```ruby
require 'clee'
clee do
run do
p 42
end
end
```
##### you can name your scripts
```ruby
require 'clee'
clee do
run do
help! #=> this will print a default usage message that will include
'my_clee'
end
end
```
##### you can alter the default tldr, and help messages
```ruby
require 'clee'
clee do
tldr <<~____
avoid using the default 'tldr'
____
end
```
```ruby
require 'clee'
clee do
help <<~____
NAME
my_clee
USAGE
fully custom help...
____
end
```
##### specifying params is trivial
```ruby
require 'clee'
clee do
# support `my_clee --verbose` and -v
#
option :verbose, :v
# support `my_clee --path=./lib`
#
option :path, value: :required
# support `my_clee API_KEY=123` *and* `API_KEY=123 my_clee`
#
env :API_KEY
# support `my_clee --foo=42` *and* `my_clee foo=42` *and* `foo=42 my_clee`
syntax
#
param :foo, value: 'required'
# the interface and help messages work the same way for all the above
#
def run
if @options.has_key?(:verbose)
@verbose = true
end
@path = @options.fetch(:path)
@api_key = @env.fetch(:API_KEY)
@foo = @parms.fetch(:foo)
end
end
```
##### modes, and sub-modes, are supported
```ruby
require 'clee'
clee :my_clee do
run :foo do
p 42
end
run :foo, :bar do
p 42.0
end
run do
p 42.42
end
end
```
##### assuming you saved the above as `my_clee`, you could then do
```sh
~> my_clee foo #=> 42
~> my_clee foo bar #=> 42.0
~> my_clee #=> 42.42
```
##### `clee` scripts have a sweet dependency-less colored logger that
understands what a #tty really is...
```ruby
require 'clee'
clee do
def run
log 'hai!'
log 'hai!', level: :warning
log 'blue', color: :blue
end
end
```
##### `clee` ships with a lil code-gen-thang
```sh
~> clee new my_clee > my_clee
~> chmod 755 my_clee
~> ./my_clee
```
i could write more docs but, they would then outnumber the LOC of the
library
so:
1. see [./lib/clee.rb](./lib/clee.rb)
2. if that still doesn't float your boat install `ima`, a universal
command-line filter built on `clee`, that brings AI to your CLI and do
something like this
```sh
~> gem install clee ima
~> ima explain clee to me --context=$(gem which clee)
```
which might produce something like this ->
---
Clee is a Ruby library that provides a simple way to create command-line
interfaces (CLI) for Ruby applications. It allows developers to define
commands, options, and parameters for their application, and handles the
parsing and execution of these commands.
The core features of Clee include:
* Command definition: Clee allows developers to define commands and their
associated options and parameters.
* Option parsing: Clee can parse command-line options and parameters, and
provides a simple way to define and handle these options.
* Parameter handling: Clee provides a way to handle command-line
parameters, including required and optional parameters.
* Help generation: Clee can generate help text for commands and options,
making it easy to provide documentation for users.
* Logging: Clee provides a logging mechanism that allows developers to log
messages at different levels (e.g. debug, info, warning, error).
Clee is designed to be flexible and customizable, making it easy to
integrate into existing Ruby applications. It also provides a number of
features that make it easy to use, including automatic help generation and
logging.
Some of the key concepts in Clee include:
* Commands: These are the top-level actions that a user can perform with
the application.
* Options: These are the flags or switches that can be used to modify the
behavior of a command.
* Parameters: These are the values that are passed to a command or option.
* Modes: These are alternative behaviors that a command can exhibit,
depending on the options or parameters passed to it.
Overall, Clee is a powerful and flexible library that makes it easy to
create command-line interfaces for Ruby applications. Its simple and
intuitive API makes it easy to use, even for developers who are new to CLI
development.
---
SING IT 🎵
----------
* **DOCS are dead, long live AI!**
* **UIs are dead, long live CLIS!**
FINALLY
-------
> why `clee`? that is honestly such a stupid name...
a good friend used to pronounce 'cli' as 'clee'. it stuck. i like it.
> i still need you write more docs for this free code
[c'mon in!](https://github.com/ahoward/clee/pulls)
--
- a
"be kind whenever possible. it is always possible." -- h.h. the 14th
dalai lama
-->> https://drawohara.io
It is amazing how cryptic, difficult to reason about, and expensive to
maintain Ruby codebases become when they include countless 'concerns'
without honoring the Ruby naming convention for mixins as representing
"traits"...
Continue reading blog post:
https://andymaleh.blogspot.com/2025/03/ruby-mixins-vs-rails-concerns.html
This is a minor update release.
** What's Changed **
* fix potential crash with use of Wx::PGChoiceEntry objects
* update wxWidgets master branch compatibility to at least commit 4d5fbf5afa276ebec0fed95c8feb5d6ec485622d
* fix some platform build configuration issues
For more details see the original release announcement here: https://github.com/mcorino/wxRuby3/discussions/365
