a scene/multi-scene management system for three
Expo module implementation of a parser based on https://httpwg.org/specs/rfc8941.html
realistic password strength estimation
JavaScript 3D library
A BVH implementation to speed up raycasting against three.js meshes.
A React renderer for Threejs
stand-alone library of threejs examples
SDF-based text rendering for Three.js
Intl.LocaleMatcher ponyfill
useful add-ons for react-three-fiber
[`react-three-fiber`](https://github.com/drcmda/react-three-fiber) support. This package is for version 6 of react-three-fiber
Various utilities related to Three.js
TypeScript definitions for three
Converts SVG Strokes To Fill.
joi to JSON / OpenAPI Schema Converter
Objective-C bridge for Node.js
Convert a SVG to multiple image formats (without puppeteer or a headless browser)
Globe data visualization as a ThreeJS reusable 3D object
Get an objective-c header file and translate it to equivalent javascript calls
ThreeJS geometry for drawing polygons on a sphere
postprocessing wrapper for React and @react-three/fiber
Easy way to render ThreeJS objects with built-in interaction defaults
BSV Blockchain Software Development Kit
Automatically install npm, bower, tsd, and pip packages/dependencies if the relative configurations are found in the gulp file stream respectively
Provides three abilities to delegate method calls to an object.
Ruby-ACL is library that handles access permisions. Ruby-ACL offers to create and modify three ACL objects - three dimensions: Principal, Privilege, Resource object.
A toolset for manipulating and utilizing long text strings. Useful for analyzing user input or bodys of text. Can break text into compacted series of words, sentences and paragraphs.
Symbiont is a cool implementation of proc-objects execution algorithm: in the context of other object, but with the preservation of the closed environment of the proc object and with the ability of control the method dispatch inside it. A proc object is executed in three contexts: in the context of required object, in the context of a closed proc's environment and in the global (Kernel) context.
Erubis is an implementation of eRuby and has the following features: * Very fast, almost three times faster than ERB and about 10% faster than eruby. * Multi-language support (Ruby/PHP/C/Java/Scheme/Perl/Javascript) * Auto escaping support * Auto trimming spaces around '<% %>' * Embedded pattern changeable (default '<% %>') * Enable to handle Processing Instructions (PI) as embedded pattern (ex. '<?rb ... ?>') * Context object available and easy to combine eRuby template with YAML datafile * Print statement available * Easy to extend and customize in subclass * Ruby on Rails support
Given a set of three dimensions (height, width, depth), this class produces an SVG drawing representing the object’s volume as a wireframe-style box, with an optional tennis ball for scale.
Example: EnglishNumber.new(63).in_english # => 'sixty-three'. EnglishNumber objects can be added, subtracted, multiplied, divided. For now gem is deliberately limited to numbers maximum five digits long. Lower limit might be set manually (see the source code)
Safer is an umbrella library, with components designed to make it simple to verify and improve the safety of your ruby code. There are at present three modules under the safer umbrella: [<tt>Safer::IVar</tt>] generates specially-named accessor functions for class instance variables. [<tt>Safer::Protocol</tt>] is used to provide a ruby analogue to Objective-C Protocols (which are similar to Java interfaces, but do not require inheritance). [<tt>Safer::HashProtocol</tt>] verifies that a Hash keys follow a defined format. Intended to help use of Hash objects as keyword parameters.
MesaReader is a ruby module that contains three classes, MesaData, MesaProfileIndex, and MesaLogDir. These classes are intended to read in three types of files or directories, MESA history/profile logs, MESA profile indexes, and entire MESA LOGS directories, respectively. The resulting objects can then be maniuplated to return useful data in a ruby or tioga script. In addition to simple returning of data columns (the primary function of the MesaData class), some basic searching features are built-in, allowing you to search for profiles that correspond to something in the history, or for parts of history columns that depend on other history columns. All returned vectors have many built-in methods since they are DVectors from the DObjects module in Tioga, which is a requirement. For detailed instructions, see the readme on the github page at https://github.com/wmwolf/MESA_Reader
Erubis is an implementation of eRuby and has the following features: * Very fast, almost three times faster than ERB and about 10% faster than eruby. * Multi-language support (Ruby/PHP/C/Java/Scheme/Perl/Javascript) * Auto escaping support * Auto trimming spaces around '<% %>' * Embedded pattern changeable (default '<% %>') * Enable to handle Processing Instructions (PI) as embedded pattern (ex. '<?rb ... ?>') * Context object available and easy to combine eRuby template with YAML datafile * Print statement available * Easy to extend and customize in subclass * Ruby on Rails support
# Procer **NOTE: Experimental. Use it to experience what a default `to_proc` could have been. For production code, I recommend an explicit transformation, like the one provided by the gem `jgomo3-func`**. A reasonable good default `to_proc` method for all objects. Install with: ``` gem install procer ``` When you require Procer, all objects will have a default `to_proc` method which will try to call one of the following methods, in the given order: - `call` - `[]` - `===` Many methods which receive a block, can benefit greatly from this because you can now pass an object to perform the block role. Think of the Enumerable module and all its methods. Many objects define `===`, but not `to_proc`. So they will be nicely usable in a `case/when` expression, but not in other contexts. This is the case of classes and ranges, which you can use in `case/when` expressions, but they don't define `to_proc`. Now they do define `to_proc` so they are useful in those contexts. Examples: ```ruby require 'procer' [1, 2, '3', '4', 5, 6].filter(&Numeric) # => [1, 2, 5, 6] [-10, 100, -2, 3, 20, -33].filter(&(0..50)) # => [3, 20] ``` Also, Hashes already implement `to_proc` and that is useful with Enumerator. We can use it as a transformation table with `map`: ```ruby table = { 1 => 'one', 2 => 'two', 3 => 'three' } [3, 1, 2].map(&table) # => ['three, 'one, 'two'] ``` Sadly, Arrays, even when they have the same interface as hashes as a function of indices, don't implement `to_proc` and so they can't be used in the same way. Until now. ```ruby table = ['zero', 'one', 'two'] [2, 0, 1].map(&table) # => ['two', 'zero', 'one'] ``` Alternatively, you could have used `values_at`: ```ruby table.values_at([3, 1, 2]) # In the Hash example table.values_at([2, 0, 1]) # In the Array example ``` But the map solution is more generic and `table` can be anything that implements `to_proc` and not something that necessarily implements `values_at`. Notice that if the object implements `[]` that will triumph over `===`. It was unexpected when I tried to use Integers as the object, as they implement `[]` as a way to access their binary form: ```ruby 5 # b101 [5[2], 5[1], 5[0]] # [1, 0, 1] ``` So the proc will work like that: ```ruby [2, 4, 5].map(&5) # Actual => [1, 0, 0] # I was expecting => [false, false, true] ```
# Hexflex [](https://travis-ci.org/aauthor/hexflex) Hexflex is a Ruby gem and command-line tool for automatically generating [hexaflexagon] templates. ## Installation gem install 'hexaflexa' ...or you can put it in your Gemfile. ## Usage ### as a gem in your ruby project To create an [RVG] object containing a vector of the hexaflexagon template: Hexflex.make_template_vector(side_fills: ARRAY_OF_SIDE_FILLS, template: TEMPLATE) To save the hexaflexagon template as a file to the disk: Hexflex.create_template_image!(side_fills: ARRAY_OF_SIDE_FILLS, template: TEMPLATE, output_file_name: OUTPUT) Where: - a `SIDE_FILL` is a [standard X color] or path to file for a side of the hexaflexagon. Either three or zero sides should be specified. The default are cyan, magenta, and yellow. - `TEMPLATE` is template the form for the hexaflexagon. It can either be "tape" or "glue". The default is "tape". - `OUTPUT` is a path to save the hexaflexagon template image. The default is "out.png". ### as a command-line tool hexflex [-s SIDE_FILL -s SIDE_FILL -s SIDE_FILL] [-t TEMPLATE] [-o OUTPUT] See above for definitions of `SIDE_FILL`, `TEMPLATE`, AND `OUTPUT`. [hexaflexagon]: https://en.wikipedia.org/wiki/Flexagon#Trihexaflexagon [standard X color]: https://en.wikipedia.org/wiki/X11_color_names [RVG]: https://rmagick.github.io/rvg.html