activeduty 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3851ef284433a3cf609e6934fee1eb357c0f1a8d97bd2db3677ef16732adc2a1
-  data.tar.gz: 3a24b9d50c907e610b17062ff1468fc3bde330150da2492132c255986c99a64b
+  metadata.gz: 2b879bfa0f660945b57f5b87a67ddef1bf55dd91fdece4c5dc07820d93950d90
+  data.tar.gz: 13c31dbba265e4d3e738a417595633deee7e837e23eaff04b5154b3f299ca77a
 SHA512:
-  metadata.gz: 62d7527dced5eca2869d9ad7ce69b7ecfdd1b4ecf0c3a2249f72e18790fbfca384f3ab49798ca36cdc9021650a2c7864df2be2beed4d64d63f5b18884146a8c3
-  data.tar.gz: 126a2cc3b05c4dbd1cc7b9688c5b96f0d863948c8de9a97378acbd429b5030d9cda087873ffe25edc057b013cdbc7c54195cdff81a0bdc638ff2de43aaa7cf22
+  metadata.gz: 8833e8338c11c2cc0c398485268e0d3947079c3b109efc071ee025018e03959b051a6c2b9d4d44b00550071536816aaa9be6d68b7376773654425a7fdc4773e1
+  data.tar.gz: 44b5d6e28ab6ba25f9fd150a9b9df4f3f3ca670a33bd39d426e01b107688ab3aaa94dca3c20165503f995d9ea2571cb0ef969cb5da19e4845ef6adbcd91a2f5d

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+# 0.1.1
+
+## Breaking 
+
+None.
+
+## Fixes
+
+None.
+
+## Features
+
+* Allow `init_with` to accept default arguments. 
+
+# 0.1
+
+Release.

data/README.md

@@ -1,3 +1,157 @@
 # ActiveDuty
 
-Service objects.
+Service objects, based loosely on [Interactor](https://github.com/collectiveidea/interactor).
+
+## Design 
+
+Define the logic in `run` and call it with `call`:
+
+## Basic usage 
+
+```ruby
+class AuthenticateUser < ActiveDuty::Base
+  def initialize(email, password)
+    @email, @password = email, password 
+  end
+
+  def run
+    if user = User.authenticate(@email, @password)
+      context.user = user 
+    else
+      fail!
+    end
+  end
+end
+```
+
+Usage: 
+
+```
+service = AuthenticateUser.new("josh@example.com", password: "password")
+service.call 
+if service.success?
+  # do something
+else
+  puts service.errors.inspect 
+end 
+```
+
+## Advanced usage 
+
+### init_with
+
+A DSL for initializing.
+
+#### Ordered arguments
+
+```
+class AuthenticateUser < ActiveDuty::Base 
+  init_with :username, :password 
+end 
+```
+
+Is the equivalent of:
+
+```
+class AuthenticateUser < ActiveDuty::Base 
+  attr_reader :username, :password 
+  def initialize(username, password)
+    @username, @password = username, password 
+  end 
+end 
+```
+
+#### Keyword arguments 
+
+```
+class AuthenticateUser < ActiveDuty::Base 
+  init_with uname: :username, pw: :password  
+end 
+```
+
+Is the equivalent of:
+
+```
+class AuthenticateUser < ActiveDuty::Base 
+  attr_reader :username, :password 
+  def initialize(uname:, pw:)
+    @username, @password = uname, pw 
+  end 
+end 
+```
+
+#### Defaults 
+
+```
+class AuthenticateUser < ActiveDuty::Base 
+  init_with :username, [:password, nil] 
+end 
+```
+
+Is the equivalent of:
+
+```
+class AuthenticateUser < ActiveDuty::Base 
+  attr_reader :username, :password 
+  def initialize(username, password = nil)
+    @username, @password = username, password 
+  end 
+end 
+```
+
+#### Keyword arguments 
+
+```
+class AuthenticateUser < ActiveDuty::Base 
+  init_with uname: [nil, :username], pw: ["good-password", :password]
+end 
+```
+
+Is the equivalent of:
+
+```
+class AuthenticateUser < ActiveDuty::Base 
+  attr_reader :username, :password 
+  def initialize(uname: nil, pw: "good-password")
+    @username, @password = uname, pw 
+  end 
+end 
+```
+
+### Callbacks 
+
+Supports `after_initialize`, `before_call`, `after_call`. They use `ActiveModel::Callbacks` under the hood, so the API is familiar.
+
+### Context 
+
+An `OpenStruct` for a setting information during the runtime of your service object. Exposed via `context`.
+
+### Errors 
+
+Uses `ActiveModel::Errors` under the hood.
+
+### Rollbacks 
+
+If your call fails and you need to do some housekeeping, define a rollback:
+
+```ruby 
+class AuthenticateUser < ActiveDuty::Base
+  def rollback 
+    # do something 
+  end
+end
+```
+
+Or class-level: 
+
+```ruby 
+class AuthenticateUser < ActiveDuty::Base
+  rollback do 
+    # do something 
+  end 
+end
+```
+
+### Failing 
+
+Need to fail? Call `fail!`

data/lib/active_duty/callbacks.rb

@@ -6,20 +6,27 @@ module ActiveDuty
       define_model_callbacks :call, only: [:before, :after, :around]
 
       def self.after_initialize(&block)
-        @_after_initialize_block = block
+        @_after_initialize_callbacks ||= []
+        @_after_initialize_callbacks << block
       end
 
-      def self._after_initialize_block
-        if defined?(@_after_initialize_block)
-          @_after_initialize_block
+      def self._after_initialize_callbacks
+        if defined?(@_after_initialize_callbacks)
+          @_after_initialize_callbacks
         else
           nil
         end
       end
 
       def after_initialize!
-        if self.class._after_initialize_block
-          instance_exec(self, &self.class._after_initialize_block)
+        if self.class._after_initialize_callbacks
+          self.class._after_initialize_callbacks.each do |callback|
+            if callback.is_a?(Symbol)
+              send(callback)
+            else
+              instance_exec(self, &callback)
+            end
+          end
         end
       end
     end

data/lib/active_duty/initializers.rb

@@ -4,28 +4,100 @@ module ActiveDuty
     module ClassMethods
       def init_with(*args)
         kwargs = args.extract_options!
-
         if kwargs.empty?
-          define_method :initialize do |*initialize_args|
-            args.zip(initialize_args) do |name, value|
-              instance_variable_set("@#{name}", value)
+          init_from_ordered(args)
+        else
+          init_from_kw(kwargs)
+        end
+      end
+
+      private
+
+      # initialize from ordered arguments
+      #
+      # init_with :username, :password
+      # def initialize(username, password)
+      #   @username = username
+      #   @password = password
+      #
+      # init_with [:username], [:password, nil], [:email, "no email"], [:options, {}]
+      # def initialize(username, password = nil, email: "no email", options = {})
+      #   @username = username
+      #   @password = password
+      #   @email = email
+      #   @options = options
+      def init_from_ordered(args)
+        init_string = []
+        args.each do |arg|
+          str = ""
+          if arg.is_a?(Array)
+            if arg.size == 2
+              if arg[1].is_a?(String)
+                str << "#{arg[0]} = \"#{arg[1]}\""
+              else
+                str << "#{arg[0]} = #{arg[1]}"
+              end
+            else
+              str << "#{arg[0]}"
             end
-            self.class.attr_reader *args
+          else
+            str << "#{arg}"
           end
-        elsif kwargs.is_a?(Hash)
-          class_eval <<-METHOD, __FILE__, __LINE__ + 1
-            def initialize(#{kwargs.keys.map { |key| "#{key}:" }.join(', ')})
-              #{kwargs.map { |key, value| 
-                "
-                  instance_variable_set(:\"@#{value}\", #{key}) 
-                  self.class.attr_reader :#{value}
-                " 
-                  }.join("\n")
-                }
-            end
-          METHOD
+          init_string << str
         end
+        class_eval <<-METHOD, __FILE__, __LINE__ + 1
+            def initialize(#{init_string.join(', ')})
+              #{args.map { |arg|
+          if arg.is_a?(Array)
+            "instance_variable_set(:\"@#{arg[0]}\", #{arg[0]}) 
+                  self.class.attr_reader :#{arg[0]}"
+          else
+            "instance_variable_set(:\"@#{arg}\", #{arg}) 
+                  self.class.attr_reader :#{arg}"
+          end
+        }.join("\n")
+        }
+            end
+        METHOD
+      end
+
+      # Initialize with keyword args.
+      #
+      # { username: :user } will
+      #   def initialize(username:)
+      #     @user = username
+      #
+      # { username: ["Bob", :user] } will
+      #   def initialize(username: "Bob")
+      #     @user = username
+      def init_from_kw(args)
 
+        initializer_string = []
+        args.each do |key, values|
+          str = "#{key}:"
+          if values.is_a?(Array) && values.size == 2
+            if values[0].is_a?(String)
+              str += " \"#{values[0]}\""
+            else
+              str += "#{values[0]}"
+            end
+          end
+          initializer_string << str
+        end
+        class_eval <<-METHOD, __FILE__, __LINE__ + 1
+            def initialize(#{initializer_string.join(', ')})
+              #{args.map { |key, values|
+          if values.is_a?(Array)
+            "instance_variable_set(:\"@#{values[1]}\", #{key}) 
+                  self.class.attr_reader :#{values[1]}"
+          else
+            "instance_variable_set(:\"@#{values}\", #{key}) 
+                  self.class.attr_reader :#{values}"
+          end
+        }.join("\n")
+        }
+            end
+        METHOD
       end
 
     end

data/lib/active_duty/version.rb

@@ -1,3 +1,3 @@
 module ActiveDuty
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activeduty
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Josh Brody
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-15 00:00:00.000000000 Z
+date: 2020-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -86,6 +86,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - README.md
 - lib/active_duty.rb
 - lib/active_duty/base.rb