Porting to new Literal::Properties

Author: stevegeek

README.md

@@ -44,15 +44,16 @@ class ShelveBookOperation < ::TypedOperation::Base
   # Or if you prefer:
   #   `param :description, String`
 
-  named_param :author_id, Integer, &:to_i
-  named_param :isbn, String
+  # `param` creates named parameters by default
+  param :author_id, Integer, &:to_i
+  param :isbn, String
 
   # Optional parameters are specified by wrapping the type constraint in the `optional` method, or using the `optional:` option
-  named_param :shelf_code, optional(Integer)
+  param :shelf_code, optional(Integer)
   # Or if you prefer:
   #   `named_param :shelf_code, Integer, optional: true`
 
-  named_param :category, String, default: "unknown".freeze
+  param :category, String, default: "unknown".freeze
 
   # optional hook called when the operation is initialized, and after the parameters have been set
   def prepare
@@ -521,7 +522,8 @@ This is an example of a `ApplicationOperation` in a Rails app that uses `Dry::Mo
 
 class ApplicationOperation < ::TypedOperation::Base
   # We choose to use dry-monads for our operations, so include the required modules
-  include Dry::Monads[:result, :do]
+  include Dry::Monads[:result]
+  include Dry::Monads::Do.for(:perform)
 
   class << self
     # Setup our own preferred names for the DSL methods
@@ -711,55 +713,21 @@ end
 
 Note you are provided the ActionPolicy error object, but you cannot stop the error from being re-raised.
 
-### Using with `literal` monads
-
-You can use the `literal` gem to provide a `Result` type for your operations.
-
-```ruby
-class MyOperation < ::TypedOperation::Base
-  param :account_name, String
-  param :owner, String
-
-  def perform
-    create_account.bind do |account|
-      associate_owner(account).map { account }
-    end
-  end
-
-  private
-
-  def create_account
-    # ...
-    # Literal::Failure.new(:cant_create_account)
-    Literal::Success.new(account_name)
-  end
-  
-  def associate_owner(account)
-    # ...
-    Literal::Failure.new(:cant_associate_owner)
-    # Literal::Success.new("ok")
-  end
-end
-
-MyOperation.new(account_name: "foo", owner: "bar").call
-# => Literal::Failure(:cant_associate_owner)
-```
-
 ### Using with `Dry::Monads`
 
 As per the example in [`Dry::Monads` documentation](https://dry-rb.org/gems/dry-monads/1.0/do-notation/)
 
 ```ruby
 class MyOperation < ::TypedOperation::Base
   include Dry::Monads[:result]
-  include Dry::Monads::Do.for(:call)
+  include Dry::Monads::Do.for(:perform, :create_account)
 
   param :account_name, String
   param :owner, ::Owner
 
   def perform
     account = yield create_account(account_name)
-    yield associate_owner(account, owner)
+    yield AnotherOperation.call(account, owner)
 
     Success(account)
   end

lib/typed_operation.rb

@@ -11,8 +11,7 @@
 require "typed_operation/operations/partial_application"
 require "typed_operation/operations/callable"
 require "typed_operation/operations/lifecycle"
-require "typed_operation/operations/deconstruct"
-require "typed_operation/operations/attribute_builder"
+require "typed_operation/operations/property_builder"
 require "typed_operation/operations/executable"
 require "typed_operation/curried"
 require "typed_operation/immutable_base"

lib/typed_operation/base.rb

@@ -8,18 +8,6 @@ class Base < Literal::Struct
 
     include Operations::Lifecycle
     include Operations::Callable
-    include Operations::Deconstruct
     include Operations::Executable
-
-    class << self
-      def attribute(name, type, special = nil, reader: :public, writer: :public, positional: false, default: nil)
-        super(name, type, special, reader:, writer: false, positional:, default:)
-      end
-    end
-
-    def with(...)
-      # copy to new operation with new attrs
-      self.class.new(**attributes.merge(...))
-    end
   end
 end

lib/typed_operation/immutable_base.rb

@@ -8,7 +8,6 @@ class ImmutableBase < Literal::Data
 
     include Operations::Lifecycle
     include Operations::Callable
-    include Operations::Deconstruct
     include Operations::Executable
   end
 end

lib/typed_operation/operations/deconstruct.rb

@@ -5,25 +5,23 @@ module Operations
     # Introspection methods
     module Introspection
       def positional_parameters
-        literal_attributes.filter_map { |name, attribute| name if attribute.positional? }
+        literal_properties.filter_map { |property| property.name if property.positional? }
       end
 
       def keyword_parameters
-        literal_attributes.filter_map { |name, attribute| name unless attribute.positional? }
+        literal_properties.filter_map { |property| property.name if property.keyword? }
       end
 
       def required_parameters
-        literal_attributes.filter do |name, attribute|
-          attribute.default.nil? # Any optional parameters will have a default value/proc in their Literal::Attribute
-        end
+        literal_properties.filter { |property| property.required? }
       end
 
       def required_positional_parameters
-        required_parameters.filter_map { |name, attribute| name if attribute.positional? }
+        required_parameters.filter_map { |property| property.name if property.positional? }
       end
 
       def required_keyword_parameters
-        required_parameters.filter_map { |name, attribute| name unless attribute.positional? }
+        required_parameters.filter_map { |property| property.name if property.keyword? }
       end
 
       def optional_positional_parameters

lib/typed_operation/operations/introspection.rb

@@ -4,7 +4,7 @@ module TypedOperation
   module Operations
     module Lifecycle
       # This is called by Literal on initialization of underlying Struct/Data
-      def after_initialization
+      def after_initialize
         prepare if respond_to?(:prepare)
       end
     end

lib/typed_operation/operations/lifecycle.rb

@@ -4,10 +4,15 @@ module TypedOperation
   module Operations
     # Method to define parameters for your operation.
     module Parameters
+      # Override literal `prop` to prevent creating writers (Literal::Data does this by default)
+      def self.prop(name, type, kind = :keyword, reader: :public, writer: :public, default: nil)
+        super(name, type, kind, reader:, writer: false, default:)
+      end
+
       # Parameter for keyword argument, or a positional argument if you use positional: true
       # Required, but you can set a default or use optional: true if you want optional
       def param(name, signature = :any, **options, &converter)
-        AttributeBuilder.new(self, name, signature, options).define(&converter)
+        PropertyBuilder.new(self, name, signature, options).define(&converter)
       end
 
       # Alternative DSL

lib/typed_operation/operations/parameters.rb

@@ -2,13 +2,13 @@
 
 module TypedOperation
   module Operations
-    class AttributeBuilder
+    class PropertyBuilder
       def initialize(typed_operation, parameter_name, type_signature, options)
         @typed_operation = typed_operation
         @name = parameter_name
         @signature = type_signature
-        @optional = options[:optional]
-        @positional = options[:positional]
+        @optional = options[:optional] # Wraps signature in NilableType
+        @positional = options[:positional] # Changes kind to positional
         @reader = options[:reader] || :public
         @default_key = options.key?(:default)
         @default = options[:default]
@@ -51,7 +51,7 @@ def type_nilable?
       end
 
       def union_with_nil_to_support_nil_default
-        @signature = Literal::Union.new(@signature, NilClass) if has_default_value_nil?
+        @signature = Literal::Types::UnionType.new(@signature, NilClass) if has_default_value_nil?
       end
 
       def has_default_value_nil?
@@ -61,8 +61,6 @@ def has_default_value_nil?
       def validate_positional_order_params!
         # Optional ones can always be added after required ones, or before any others, but required ones must be first
         unless type_nilable? || @typed_operation.optional_positional_parameters.empty?
-          puts type_nilable?
-          puts @typed_operation.optional_positional_parameters
           raise ParameterError, "Cannot define required positional parameter '#{@name}' after optional positional parameters"
         end
       end

lib/typed_operation/operations/property_builder.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "test_helper"
+require "dry-monads"
 
 module TypedOperation
   class BaseTest < Minitest::Test
@@ -165,11 +166,12 @@ def test_operation_raises_on_invalid_positional_params
     end
 
     def test_operation_raises_on_invalid_positional_params_using_optional
-      assert_raises do
+      assert_raises(::TypedOperation::ParameterError) do
         Class.new(::TypedOperation::Base) do
           # This is invalid, because positional params can't be optional before required ones
           positional_param :first, optional(String)
-          positional_param :second, String
+          positional_param :second, Literal::Types::NilableType.new(String)
+          positional_param :third, String # required after optional is not possible
         end
       end
     end
@@ -422,12 +424,10 @@ def test_operation_can_be_partially_applied_then_curry
       assert_equal "a/b//d/e/f", curried_operation.call("b").call("d")
     end
 
-    def test_operation_instance_can_be_copied_using_with
-      operation = TestOperation.new(foo: "1", bar: "2", baz: "3")
-      operation2 = operation.with(foo: "a")
-      assert_equal "a", operation2.foo
-      assert_equal "2", operation2.bar
-      assert_equal "3", operation2.baz
+    def test_operation_instance_can_be_copied_using_dup
+      operation = TestKeywordAndPositionalOperation.new("1", "2", kw1: "1", kw2: "2")
+      operation2 = operation.dup
+      assert_equal "1/2/1/2", operation2.call
     end
 
     def test_operation_should_not_freeze_arguments
@@ -436,5 +436,31 @@ def test_operation_should_not_freeze_arguments
       operation.my_hash[:b] = 2
       assert_equal({a: 1, b: 2}, operation.my_hash)
     end
+
+    def test_with_dry_maybe_monad_partially_apply_then_curry
+      operation_class = Class.new(::TypedOperation::Base) do
+        positional_param :v1, Integer
+        positional_param :v2, Integer
+
+        def perform
+          ::Dry::Monads::Maybe(v1 + v2)
+        end
+      end
+
+      operation = operation_class.with(1)
+      operation2 = operation_class.with(3)
+      m = ::Dry::Monads::Maybe::Some.new(2)
+      assert_equal m.bind(&operation.curry).bind(&operation2.curry), Dry::Monads::Maybe::Some.new(6)
+      m = Dry::Monads::Maybe::None.instance
+      assert_equal m.bind(&operation.curry).bind(&operation2.curry), Dry::Monads::Maybe::None.instance
+    end
+
+    def test_can_dup
+      operation = TestOperation.new(foo: "1", bar: "2", baz: "3")
+      operation2 = operation.dup
+      assert_equal "1", operation2.foo
+      assert_equal "2", operation2.bar
+      assert_equal "3", operation2.baz
+    end
   end
 end