Results for case-transformer

command-line tool to convert strings via "heck" crate

Transforms string letter case to camel, snake,dash and underscore without activesupport dependencies. Forked from https://github.com/rails-api/case_transform

Convert normal parlance into way more sarcastic SpongeBob clucking chicken style.

Transform a string between camelCase, PascalCase, Capital Case, snake_case, kebab-case, CONSTANT_CASE and others.

Sortsmith provides a flexible, chainable API for sorting Ruby collections. It supports sorting by object keys, methods, case sensitivity, and custom transformations.

A hash that allows for transformation of its keys. A transformation block is given to change the key. Keys can be looked up with any value that transforms into the same key. This means a hash can be string/symbol insensitive, case insensitive, can convert camel case JSON keys to snake case Ruby keys, or anything else based on the block you provide.

sql2avro extracts data from a specified SQL database table and transforms it into an Avro file with a schema based on the database table's schema. The intended use case is to incrementally load data out of an SQL database and into HDFS for analysis via Hadoop.

A library of extensions for outoftime's sunspot gem for solr indexing server. Using the session adapter design pattern to add support for: 1) delayed_job to move indexing commits out of process. Support for case insensitive sort fields by creating indexed copy of fields transformed for sort.

SwifterEnum transforms Rails enums from simple values into powerful objects with methods, computed properties, and type safety. Your enums become smart: payment_status.can_refund?, subscription.price, status.icon - all while maintaining 100% Rails enum compatibility. Drop-in replacement that eliminates scattered helper methods and case statements throughout your codebase.

This gem provides a plugin for Sprockets to transpile modern javascript using Babel. Unlike other options in the sprockets ecosystem, it works with the latest version of Babel and any plugins/presets you install. A primary use case for this gem is to facilitate incremental migration of a large Sprockets-powered javascript codebase to ES6 modules by transforming them to UMD modules that preserve your existing global variable references (hence the name: Babel + UMD = BumbleD). That said, this gem can be used for general purpose babel transpilation within the Sprockets pipeline.

AdaptiveConfiguration is an elegant, lightweight and simple, yet powerful Ruby gem that allows you to define a DSL (Domain-Specific Language) for structured and hierarchical configurations. It is ideal for defining complex configurations for various use cases, such as API clients, application settings, or any scenario where structured configuration is needed. In addition AdaptiveConfiguration can be more generally used to transform and validate JSON data from any source such as from a network request or API reponse.

SQrbL was created to help manage an extremely specific problem: managing SQL-based database conversions. In essence, SQrbL is a tool for managing multiple SQL queries using Ruby. SQrbL borrows some terminology and ideas from ActiveRecord's schema migrations, but where ActiveRecord manages changes to your database schema over time, SQrbL was written to manage the process of transforming your data from one schema to another. (Of course, you could use SQrbL for the former case as well -- just use it to write DDL queries -- but ActiveRecord has better tools for figuring out which migrations have already been applied.)

# 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] ```