inline_transforms 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 22f30721666a47350279cb918ceadc3887f4fa5aaca5202901559ec690778fa6
+  data.tar.gz: bc800383746ebb80919e00a9103fac32ad4cf8c8863a5207c2ffcd186de58ca4
+SHA512:
+  metadata.gz: 423e20167b171a3a929c9dcc063d9bcb7a10cc91a1f0b6cab20817df8ababf10471f96196c09994dad0e7b0999ac324d1466d19d99f680a7ebdb5b5a57e77ea8
+  data.tar.gz: 65bb28caa0f2d10c3a45a5a45a05574f55f230c77f47783bd5ec819280d62809c1cd2808d314176f62588e02f107d42ccb17caac0121ed16f9d205d59bd9bae1

data/.ruby-version

@@ -0,0 +1 @@
+3.4

data/.yardopts

@@ -0,0 +1,4 @@
+--format='html'
+--markup='markdown'
+--no-private
+--output-dir='./docs'

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nestor Custodio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,159 @@
+[![Gem Version](https://img.shields.io/github/v/release/nestor-custodio/inline_transforms?color=green&label=gem%20version)](https://rubygems.org/gems/inline_transforms)
+[![MIT License](https://img.shields.io/github/license/nestor-custodio/inline_transforms)](https://tldrlegal.com/license/mit-license)
+
+
+# Inline Transforms
+
+Ruby is an incredibly expressive (and easy to read!) language, but lacks a way for you to transform a value _inline_ without resorting to nested ternaries (🫠). This gem allows you to do exactly that in a way that still feels like _Ruby_ (i.e. via _value manipulation_ through method calls rather than classic flow control blocks).
+
+In simplest terms:
+```ruby
+# "Unless" Logic:
+
+final_value = original_value
+final_value = different_value if original_value == a_bad_thing
+
+# ... or ...
+
+final_value = if original_value == a_bad_thing
+                different_value
+              else
+                original_value
+              end
+
+# ... becomes ...
+
+final_value = original_value.unless a_bad_thing,
+                                    then: different_value
+
+
+# "Transform" Logic:
+
+final_value = case original_value
+              when true   then 'success'
+              when false  then 'failure'
+              when String then %(error: "#{original_value}")
+              end
+
+# ... becomes ...
+
+final_value = original_value.transform true   => 'success',
+                                       false  => 'failure',
+                                       String => %(error: "#{original_value}")
+
+```
+
+[Full documentation is available here](https://nestor-custodio.github.io/inline_transforms), but do read below for a crash course on availble featues!
+
+
+## Installation
+
+- If your project uses [Bundler](https://github.com/bundler/bundler):
+  - Add one of the following to your application's Gemfile:
+    ```ruby
+    # For on-demand usage:
+
+    gem 'inline_transforms'
+    ```
+  - And then run a:
+    ```shell
+    $ bundle install
+    ```
+
+- Or, you can keep things simple with a manual install:
+  ```shell
+  $ gem install inline_transforms
+  ```
+
+
+## Usage
+
+### Object#unless
+
+`unless` lets you specify a "bad" value and a `then` replacement.
+
+- If your `then` replacement is a `Proc`, it is resolved (via `call`) before being returned.
+- This method uses **case comparison** (`===`), so you can check for range inclusion or class.
+
+```ruby
+final = value.unless bad_value, then: fallback_value
+# ... or ...
+final = value.unless bad_value, then: -> { some_method_call with_params }
+```
+
+
+### Object#transform
+
+`transform` lets you specify a transformation hash and will return the value for the first matching key, or (if no matching key is found) the `:else` value.
+
+- Any `Proc` values in the transform hash are resolved (via `call`) before being returned.
+- This method uses **case comparison** (`===`), so range and class keys work as you expect.
+
+```ruby
+final = value.transform key_1 => value_1,
+                        key_2 => value_2,
+                        # ...
+                        else: else_value
+```
+
+
+## Potential Gotchas
+
+- `Proc` instances are only resolved if they _need to be returned and are not the original value_:
+  ```ruby
+  value = -> { 'value proc' }
+  replacement_proc = -> { 'replacement proc' }
+
+  # Returns the original `value`, still a *Proc*.
+  #
+  # The original `value` is never resolved.
+  # The `replacement_proc` is not resolved.
+  #
+  final = value.unless 99, then: replacement_proc
+
+  # Returns the *String* 'replacement proc'.
+  #
+  # The original `value` is never resolved.
+  # The `replacement_proc` DOES get resolved.
+  #
+  final = value.unless value, then: replacement_proc
+
+  # Returns 99.
+  #
+  # The original `value` is never resolved.
+  # The `replacement_proc` is not resolved.
+  #
+  final = value.transform value => 99, else: replacement_proc
+
+  # Returns the *String* 'replacement proc'.
+  #
+  # The original `value` is never resolved.
+  # The `replacement_proc` DOES get resolved.
+  #
+  final = value.transform 99 => 99, else: replacement_proc
+  ```
+
+- Because _return_ `Proc`s are resolved before being passed back, you have to "proc-wrap" any `Proc` you want returned as-is (😵‍💫):
+  ```ruby
+  value = 'some value'
+  replacement_proc = -> { 'replacement proc' }
+
+  # Returns the `replacement_proc`, still a *Proc*.
+  #
+  value.unless 99, then: -> { replacement_proc }
+  ```
+  It should be _exceedingly rare_ for someone to want to do this, but it _is_ supported and this is how you would make that happen.
+
+
+## Contribution / Development
+
+Bug reports and pull requests are welcome at: [https://github.com/nestor-custodio/inline_transforms](https://github.com/nestor-custodio/inline_transforms)
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+Linting is courtesy of [Rubocop](https://docs.rubocop.org/) (`rake rubocop`) and documentation is built using [YARD](https://yardoc.org/). Please ensure you have a clean bill of health from Rubocop and that any new features and/or changes to behaviour are reflected in the adjacent documentation before submitting a pull request.
+
+
+## License
+
+The `inline_transforms` gem is available as open source under the terms of the [MIT License](https://tldrlegal.com/license/mit-license).

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/inline_transforms/version.rb

@@ -0,0 +1,3 @@
+module InlineTransforms
+  VERSION = '0.1.0'.freeze
+end

data/lib/inline_transforms.rb

@@ -0,0 +1,78 @@
+require_relative 'inline_transforms/version'
+
+# Defines `unless` and `transform`, which we'll then want to make available in `Object` instances.
+#
+module InlineTransforms
+  # Our use of case equality in matching bad/target values
+  # is intentional and part of the promise behind the gem.
+  #
+  # rubocop:disable Style/CaseEquality
+
+  # Returns `self` ... unless it matches a "bad" value, in which case it returns an alternate (`then:`) value.
+  #
+  # (NOTE: this takes a `then: nil` named param, but is defined as taking `(**options)` because `then` is reserved.)
+  #
+  #
+  # @param bad_value [Object]
+  #   The one value we consider "bad", and for which we'd like the `then:` option back instead.
+  #
+  # @option then: [Object]
+  #   The value we'd like back if `self` matches the `bad_value` **using case comparison**.
+  #   Defaults to `nil`.
+  #
+  # @return
+  #   Returns either `self` or the value given as the `then:` option.
+  #
+  def unless(bad_value, **options)
+    return self unless inline_transforms_equality? bad_value
+
+    alt_value = options[:then]
+    return alt_value.call if alt_value.is_a? Proc
+
+    alt_value
+  end
+
+  # Returns `self` ... unless it matches one of the keys in the given "transformation hash", in which case the
+  # corresponding hash value is returned. If no matching hash key is found, this returns a fallback (`else:`) value.
+  #
+  # (NOTE: this takes an `else: nil` named param, but is defined as taking `(**options)` because `else` is reserved.)
+  #
+  #
+  # @option **
+  #   A hash of keys to case-compare against `self` so we can return the corresponding value.
+  #
+  # @option else: [Object]
+  #   The fallback value to return if no matching key is found.
+  #
+  # @return
+  #   Returns either `self`, one of the transformation hash values, or the `else:` option.
+  #
+  def transform(**options)
+    default = options.delete :else
+
+    options.each { |key, value| return value.unless Proc, then: -> { value.call } if inline_transforms_equality? key }
+    default
+  end
+
+  private
+
+  # You can't case-compare *against* a `Proc` because `Proc#===` is an alias for `Proc#call`. (?!)
+  # So we have to be careful when testing for this.
+  #
+  # @param value [Object]
+  #   The value against which to case-compare `self`.
+  #
+  # @return [true, false]
+  #
+  def inline_transforms_equality?(value)
+    return value == self if value.is_a? Proc
+
+    value === self
+  end
+
+  # rubocop:enable Style/CaseEquality
+end
+
+# Gets the `InlineTransforms` methods.
+#
+class Object; include InlineTransforms; end # rubocop:disable Style/OneClassPerFile

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: inline_transforms
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nestor Custodio
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+email:
+- nestor@custodio.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".ruby-version"
+- ".yardopts"
+- LICENSE
+- README.md
+- Rakefile
+- lib/inline_transforms.rb
+- lib/inline_transforms/version.rb
+homepage: https://github.com/nestor-custodio/inline_transforms
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/nestor-custodio/inline_transforms
+  changelog_uri: https://github.com/nestor-custodio/inline_transforms/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Facilitates inline value logic.
+test_files: []