trailblazer-option 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0c5d6eb7b91e88296224c9a75b28fae91a4c91d58b36f1193ed8c13068e77261
+  data.tar.gz: 4fb0d17ce2fbb30a2ac25c358c4a7b082e056aa406d646ac026991ba43ffe263
+SHA512:
+  metadata.gz: 709e99594cbfb5810f6861a20294552ace31a364025e83a14709dee74e0339d8ed5e1e7ce9ac35bb18018864994a1ee81b1c8eea6115edf25f3d3d2b9febe22a
+  data.tar.gz: 8ac22945f47ead2bc30d143f608dbaf257605fe95bad012c7328bde2aff2acf278bd3410854fe7787c0d0d3450f8cd8a28d4edc1f0d01c7f0bcc455f12b4ff17

data/.github/workflows/ci.yml

@@ -0,0 +1,17 @@
+name: CI
+on: [push, pull_request]
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        # Due to https://github.com/actions/runner/issues/849, we have to use quotes for '3.0'
+        ruby: [2.5, 2.6, 2.7, '3.0', head, jruby, jruby-head]
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - run: bundle exec rake

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.swp

data/CHANGES.md

@@ -0,0 +1,3 @@
+# 0.1.0
+
+* Separated from `trailblazer-context`, beginning its own world.

data/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake"
+gem "minitest"
+gem "minitest-line"

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-2021 TRAILBLAZER GmbH
+
+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 @@
+# trailblazer-option

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: %i[test]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "trailblazer/option"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/trailblazer-option.rb

@@ -0,0 +1,2 @@
+require "trailblazer/option/version"
+require "trailblazer/option"

data/lib/trailblazer/option.rb

@@ -0,0 +1,56 @@
+module Trailblazer
+  class Option
+    # A call implementation invoking `value.(*args, **keyword_arguments)` and plainly forwarding all arguments.
+    # Override this for your own step strategy.
+    # @private
+    def self.call!(value, *args, signal: :call, keyword_arguments: {}, **, &block)
+      # {**keyword_arguments} gets removed automatically if it's an empty hash.
+      # DISCUSS: is this a good practice?
+      value.public_send(signal, *args, **keyword_arguments, &block)
+    end
+
+    # Note that #evaluate_callable, #evaluate_proc and #evaluate_method drop most of the args.
+    # If you need those, override this class.
+    #
+    # @private
+    def self.evaluate_callable(value, *args, **options, &block)
+      call!(value, *args, **options, &block)
+    end
+
+    # Pass given `value` as a block and evaluate it within `exec_context` binding.
+    # @private
+    def self.evaluate_proc(value, *args, signal: :instance_exec, exec_context: raise("No :exec_context given."), **options)
+      call!(exec_context, *args, signal: signal, **options, &value)
+    end
+
+    # Make the exec_context's instance method a "lambda" and reuse #call!.
+    # @private
+    def self.evaluate_method(value, *args, exec_context: raise("No :exec_context given."), **options, &block)
+      call!(exec_context.method(value), *args, **options, &block)
+    end
+
+    # Choose appropriate evaluator and forward all arguments.
+    # @private
+    def self.evaluator(value, *args, **options, &block)
+      evaluate = case value
+                 when Symbol then  method(:evaluate_method)
+                 when Proc   then  method(:evaluate_proc)
+                 else              method(:evaluate_callable)
+                 end
+
+      evaluate.(value, *args, **options, &block)
+    end
+
+    # Generic builder for a callable "option".
+    # @param call_implementation [Class, Module] implements the process of calling the proc
+    #   while passing arguments/options to it in a specific style (e.g. kw args, step interface).
+    # @return [Proc] when called, this proc will evaluate its option (at run-time).
+    def self.build(value)
+      ->(*args, **options, &block) { evaluator(value, *args, **options, &block) }
+    end
+  end
+
+  def self.Option(value)
+    Option.build(value)
+  end
+end

data/lib/trailblazer/option/version.rb

@@ -0,0 +1,5 @@
+module Trailblazer
+  class Option
+    VERSION = '0.1.0'
+  end
+end

data/test/option_test.rb

@@ -0,0 +1,170 @@
+require "test_helper"
+
+class OptionTest < Minitest::Spec
+  def assert_result(result, block = nil)
+    _(result).must_equal([{a: 1}, 2, {b: 3}, block])
+
+    _(positional.inspect).must_equal %({:a=>1})
+    _(keywords.inspect).must_equal %({:a=>2, :b=>3})
+  end
+
+  describe "positional and kws" do
+    class Step
+      def with_positional_and_keywords(options, a: nil, **more_options, &block)
+        [options, a, more_options, block]
+      end
+    end
+
+    WITH_POSITIONAL_AND_KEYWORDS = ->(options, a: nil, **more_options, &block) do
+      [options, a, more_options, block]
+    end
+
+    class WithPositionalAndKeywords
+      def self.call(options, a: nil, **more_options, &block)
+        [options, a, more_options, block]
+      end
+    end
+
+    let(:positional) { {a: 1} }
+    let(:keywords)   { {a: 2, b: 3} }
+
+    let(:block) { ->(*) { snippet } }
+
+    describe ":method" do
+      let(:option) { Trailblazer::Option(:with_positional_and_keywords) }
+
+      it "passes through all args" do
+        step = Step.new
+
+        # positional = { a: 1 }
+        # keywords   = { a: 2, b: 3 }
+        assert_result option.(positional, keyword_arguments: keywords, exec_context: step)
+      end
+
+      it "allows passing a block, too" do
+        step = Step.new
+
+        assert_result option.(positional, keyword_arguments: keywords, exec_context: step, &block), block
+      end
+    end
+
+    describe "lambda" do
+      let(:option) { Trailblazer::Option(WITH_POSITIONAL_AND_KEYWORDS) }
+
+      it "-> {} lambda" do
+        step = Step.new
+
+        assert_result option.(positional, **{keyword_arguments: keywords, exec_context: step})
+      end
+    end
+
+    describe "Callable" do
+      let(:option) { Trailblazer::Option(WithPositionalAndKeywords) }
+
+      it "passes through all args" do
+        assert_result option.(positional, keyword_arguments: keywords, exec_context: nil)
+      end
+
+      it "allows passing a block, too" do
+        assert_result option.(positional, keyword_arguments: keywords, exec_context: nil, &block), block
+      end
+    end
+  end
+
+  describe "positionals" do
+    def assert_result_pos(result)
+      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.7.0")
+        _(result).must_equal([1, 2, [3, 4]])
+        _(positionals).must_equal [1, 2, 3, 4]
+      else
+        _(result).must_equal([1, 2, [3, 4, {}]])
+        _(positionals).must_equal [1, 2, 3, 4]
+      end
+    end
+
+    # In Ruby < 3.0, {*args} will grab both positionals and keyword arguments.
+    class Step
+      def with_positionals(a, b, *args)
+        [a, b, args]
+      end
+    end
+
+    WITH_POSITIONALS = ->(a, b, *args) do
+      [a, b, args]
+    end
+
+    class WithPositionals
+      def self.call(a, b, *args)
+        [a, b, args]
+      end
+    end
+
+    let(:positionals) { [1, 2, 3, 4] }
+
+    it ":method" do
+      step = Step.new
+
+      option = Trailblazer::Option(:with_positionals)
+
+      assert_result_pos option.(*positionals, exec_context: step)
+    end
+
+    it "-> {} lambda" do
+      option = Trailblazer::Option(WITH_POSITIONALS)
+
+      assert_result_pos option.(*positionals, exec_context: "something")
+    end
+
+    it "callable" do
+      option = Trailblazer::Option(WithPositionals)
+
+      assert_result_pos option.(*positionals, exec_context: "something")
+    end
+  end
+
+  describe "keywords" do
+    def assert_result_kws(result)
+      _(keywords).must_equal({ a: 1, b: 2, c: 3, d: 4 })
+      _(result).must_equal([1, 2, { c: 3, d: 4 }])
+    end
+
+    # In Ruby < 3.0, {*args} will grab both positionals and keyword arguments.
+    class Step
+      def with_keywords(a:, b:, **rest)
+        [a, b, rest]
+      end
+    end
+
+    WITH_KEYWORDS = ->(a:, b:, **rest) do
+      [a, b, rest]
+    end
+
+    class WithKeywords
+      def self.call(a:, b:, **rest)
+        [a, b, rest]
+      end
+    end
+
+    let(:keywords) { { a: 1, b: 2, c: 3, d: 4 } }
+
+    it ":method" do
+      step = Step.new
+
+      option = Trailblazer::Option(:with_keywords)
+
+      assert_result_kws option.(keyword_arguments: keywords, exec_context: step)
+    end
+
+    it "-> {} lambda" do
+      option = Trailblazer::Option(WITH_KEYWORDS)
+
+      assert_result_kws option.(keyword_arguments: keywords, exec_context: "something")
+    end
+
+    it "callable" do
+      option = Trailblazer::Option(WithKeywords)
+
+      assert_result_kws option.(keyword_arguments: keywords, exec_context: "something")
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "trailblazer/option"
+
+require "minitest/autorun"

data/trailblazer-option.gemspec

@@ -0,0 +1,28 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "trailblazer/option/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "trailblazer-option"
+  spec.version       = Trailblazer::Option::VERSION
+  spec.authors       = ["Nick Sutterer"]
+  spec.email         = ["apotonick@gmail.com"]
+
+  spec.summary       = "Callable patterns for options in Trailblazer"
+  spec.description   = "Wrap an option at compile-time and `call` it at runtime, which allows to have the common `-> ()`, `:method` or `Callable` pattern used for most options."
+  spec.homepage      = "https://trailblazer.to/"
+  spec.licenses      = ["MIT"]
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f| 
+    f.match(%r(^test/))
+  end 
+  spec.test_files    = `git ls-files -z test`.split("\x0")
+
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "minitest-line", "~> 0.6.5"
+  spec.add_development_dependency "rake", "~> 13.0"
+
+  spec.required_ruby_version = ">= 2.1.0"
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: trailblazer-option
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nick Sutterer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-04-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-line
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.5
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Wrap an option at compile-time and `call` it at runtime, which allows
+  to have the common `-> ()`, `:method` or `Callable` pattern used for most options.
+email:
+- apotonick@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- CHANGES.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/trailblazer-option.rb
+- lib/trailblazer/option.rb
+- lib/trailblazer/option/version.rb
+- test/option_test.rb
+- test/test_helper.rb
+- trailblazer-option.gemspec
+homepage: https://trailblazer.to/
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.8
+signing_key:
+specification_version: 4
+summary: Callable patterns for options in Trailblazer
+test_files:
+- test/option_test.rb
+- test/test_helper.rb