Typechecking module.
JavaScript consumer code for Curious APIs.
A curious and unusual bric-a-brac, for curious and unusual folk.
curious-ants-frequently-finest
coal-secret-curious-tail
Stylelint default configuration for Curious Media projects
Curious Byte UI Kit
A wrapper project for curious learning analytics
Common utilities for Peeky, the testing framework for curious minds
Configuration utils for Peeky, the testing framework for curious minds
Test runner for Peeky, the testing framework for curious minds
customs-curious-type-plan
Curious Byte UI Kit
Curious Byte UI Kit modified for a PoC need for testing purposes
Eslint plugin for Peeky, the testing framework for curious minds
Command-line interface for Peeky, the testing framework for curious minds
ESLint default configuration for Curious Media projects
Server for Peeky, the testing framework for curious minds
Lock your source code in your own git repo. Stop AI agents, scrapers, and curious eyes from reading what's yours.
Default editorconfig settings for Curious Media
Frontend production build for Peeky, the testing framework for curious minds
Curious Bot Server
An establishment of luxury and curiosity, for curious and unusual folk.
Library for interacting with the smart-pacifier from Curious Inventions
MCP server providing authentic 16-bit SNES gaming sounds, R2D2 expressive emotions, and professional music synthesis for AI agents
A Rust procedural macro for creating complex regex patterns using a Domain-Specific Language (DSL).
A procedural macro for implementing a document search domain-specific language
A library for determining the satisfiability of boolean formulas written in conjunctive normal form, developed to support investigation into solvers by researchers, developers, or anyone curious.
Rust's `std` offers the [`Wrapping`](std::num::Wrapping) type for "intentionally wrapping" arithmetic, but curiously does not provide analagous implementations for intentionally saturating, checked, overflowing or panicking arithmetic. This crate addresses these missing wrappers as well as re-exports `std`'s [`Wrapping`](std::num::Wrapping) type for completeness and consistency.
a simple allocator for small-to-tiny Wasm projects in rust
Sundry tools in Rust for the curious sort
Code for testing an extention of the Collatz Conjecture
Silky smooth Java-Rust interop
A curious file tracker - monitors and logs new files in a searchable TUI
A flame graph generator for Reddit threads. See the depths that a flame-war can go
The Formal Language Where Code Verifies Itself
A simple interface for keeping track of HTML-form-like questions without feeling like you're accomodating HTML forms.
Predicate methods for those curious about their datastructures. Provides String, Array, and Hash subclasses with dynamic predicate methods that allow you to interrogate the contents of the most common Ruby datastructures in a readable, friendly fashion. Also allows you to auto-instanciate and read inquisitive datastructures straight from your `ENV` hash.
Display unique 10-digit numbers instead of ActiveRecord IDs. Hides the ID param so curious website visitors are unable to determine your resource count.
Curious where a method, error or just some text originates? Check your bundled libraries with bundle grep!
This gem exists only to ensure that another, private gem isn't accidentally released. If you're curious about this methodology, drop us a line
This handy adapter will let you enqueue delayed jobs from a Ruby/Rails app and have the job processed by Mosquito in Crystal. The idea behind this came from a Ruby/Rails app needing a better way to process massive background jobs more effeciently, and a desire to stay curious and explore.
I needed a way to generate a natural language request without having to input specific numbers. Red Davis did an excellent Baysian algorithm that can also be used for generating useable numerical input. For those curious about Red Davis work, check out: https://github.com/reddavis/Naive-Bayes
Most of our data describe more or less the same real world objects. And csv or any other tabular formats is a very common, convenient and efficient trick we use daily. But then what? If you are curious and keep track of things, you probably have a messy computer full of data, Excel files, lists and tables. Manicvs is an attempt to provide useful methods to sort, combine, add data and manipulate in any useful mean your collection of csv files using command line interface or as a library.
DRbService is a framework we use at LAIKA for creating authenticated SSL-encrypted DRb services that provide access to privileged operations without the need to give shell access to everyone. There are a few examples in the `examples/` directory of the gem, which are stripped-down versions of the services we actually use. The current implementation is kind of a hack, but I intend to eventually finish a DRb protocol that does the same thing in a more elegant, less-hackish way, as well as a tool that can generate a new service along with support files for one of several different runtime environments. If you're curious, see the `drb/authsslprotocol.rb` file for the protocol. This will replace the current method-hiding code in `drbservice.rb`, but existing services should be able to switch over quite easily. Or that's the intention.
Ply is a ruby gem for reading Stanford PLY-format 3D model files. The PLY file format is a flexible format for storing semi-structured binary data, and is often used to stored polygonalized 3D models generated with range scanning hardware. You can find some examples of the format at the {Stanford 3D Scanning Repository}[http://graphics.stanford.edu/data/3Dscanrep/]. Ply provides a simple API for quick access to the data in a PLY file (including examining the structure of a particular file's content), and an almost-as-simple event-driven API which can be used to process extremely large ply files in a streaming fashion, without needing to keep the full dataset represented in the file in memory. Ply handles all three types of PLY files (ascii, binary-big-endian and binary-little-endian). If you don't have any Stanford PLY files on hand, you probably don't need this gem, but if you're curious, the PLY file format is described at Wikipedia[http://en.wikipedia.org/wiki/PLY_(file_format)].
Chef-Berksfile-Env ================== A Chef plugin which allows you to lock down your Chef Environment's cookbook versions with a Berksfile. This is effectively the same as doing `berks apply ...` but via `knife environment from file ...`. View the [Change Log](https://github.com/bbaugher/chef-berksfile-env/blob/master/CHANGELOG.md) to see what has changed. Installation ------------ /opt/chef/embedded/bin/gem install chef-berksfile-env Usage ----- In your chef repo create a Berksfile next to your Chef environment file like this, chef-repo/environments/[ENV_NAME]/Berksfile This is the default location that will used by the plugin. We have to put the Berksfile in its own directory since [multiple Berksfiles can't exist in the same directory](https://github.com/berkshelf/berkshelf/issues/1247). The berksfile should include any cookbooks that your nodes or roles explicitly mention for that environment, source "https://supermarket.getchef.com" cookbook "java" cookbook "yum", "~> 2.0" ... Next we need to generate our Berksfile's lock file, berks install Your environment file must by in `.rb` format and look like this, require 'chef-berksfile-env' # The name must be defined first so we can use it to find the Berksfile name "my_env" # Load Berksfile locked dependencies as my environment's cookbook version contraints load_berksfile ... Now our environment will use the locked versions of the cookbooks and transitive dependencies generated by our Berksfile. Upgrading to the latest dependecies is now as simple as, berks install Our Berksfile also provides an easy way to ensure all the cookbooks and their versions that our environment requires are uploaded to our chef-server, berks upload How the Plugin Finds the Berksfile ---------------------------------- If you are curious how the plugin knows to find the Berksfile in `chef-repo/environments/[ENV]/Berksfile`, you want to put your Berksfile somewhere else or you have run into this error `Expected Berksfile at [/path/../Berksfile] but does not exist`, this section will explain how this works and ways to tweak the path or fix your error. `load_berksfile` has an optional argument which represents the path to your Berksfile. This path can be pseduo relative (explained in a moment) or absolute. By default the value is `environments/[ENV_NAME]/Berksfile`. By pseduo relative I mean that its a relative path but the plugin will check to see if the directory we are executing from partially matches our relative path. So if we are running knife from `/home/chef-repo/environments` and our relative path is `chef-repo/environments/dev/Berksfile` the plugin will see that the relative path is partially included in our execution directory and will attempt to merge the two to come up with `/home/chef-repo/environments/dev/Berksfile`. If we can't make any match at all we attempt to guess the path by just joining the relative path with our execution directory. So why do we do this? Well the only way to use this plugin is if your environment is in Ruby format. Chef's `knife from file ...` uses Ruby's `instance_eval` in order to do this. This means the code on Chef's end effectively looks like this, env.instance_eval(IO.read(env_ruby_file)) which means that any context about the location of the environment file is lost. So we have no great way to discern the location of our environment Ruby file, so instead we guess.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.