clean-architecture 3.0.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79fccd9c446b769e45c8e7c4a6f378789cd33ae10a299e7966186c6b8f8161e1
-  data.tar.gz: 566434a7e22887b2228811569bb95c4dd6e252453bec836860f5437584c8850e
+  metadata.gz: 26f4d4e8bc36d2129af4020e4cc0cd48234b0eaeb53cc7d3f757f9ce44f4b1b2
+  data.tar.gz: b4b80b13d1471153345a5e5d4b9d95de0aad4feafe9990b36385269962a3fbee
 SHA512:
-  metadata.gz: 121377ec84ca3bc904248256b38022d206edb19e149c025be35d66296df48ac9fd4f54ee1c1924d52140a07533bd5384f9d0a2825b897a5b603f9c51414bca6e
-  data.tar.gz: 4e5cb96519180360d657833b2c853e41023bf363d249e3eaf2468cf72f1fcccc541706602dfe251838cae46cf39a1addea9a99c6e21812c06e3d81255f3b0003
+  metadata.gz: 10917007ec3aa1498de76c1657d7b16a70551fba6e8ca1099d12bebe5b36429af78a9c33afe11790227a80481828d8cf6b53323b56102119860b51c9512db5bd
+  data.tar.gz: 35c346424430c7b4a4c2abbdf26400652b01fa28a40cff6e6f3957c9dd07e9f8b4df342904b26ff789a9f298be6d110cc2695371552e68410927b88d99a88588

data/.github/workflows/ci.yml

@@ -0,0 +1,52 @@
+---
+name: Continuous Integration
+on:
+  push:
+    branches-ignore:
+    - refs/tags/*_staging
+    - refs/tags/*_production
+jobs:
+  build:
+    runs-on: ubuntu-18.04
+    steps:
+    - name: Checkout branch
+      uses: actions/checkout@v1
+    - name: Extract branch name
+      shell: bash
+      run: echo "##[set-output name=branch;]$(echo ${GITHUB_REF#refs/heads/})"
+      id: extract_branch
+    - name: Set up Ruby
+      uses: actions/setup-ruby@v1
+      with:
+        ruby-version: 2.6.5
+    - name: Cache gems
+      uses: actions/cache@v1
+      with:
+        path: vendor/bundle
+        key: "${{ runner.OS }}-gem-cache-${{ hashFiles('**/clean-architecture.gemspec')
+          }}"
+        restore-keys: "${{ runner.OS }}-gem-cache-\n"
+    - name: Install bundler
+      run: (bundler -v | grep "2.0.2") || gem install bundler:2.0.2
+    - name: Install gems
+      run: bundle install --jobs $(nproc) --retry 3 --without metrics --path vendor/bundle
+    - name: Create cache directory
+      run: mkdir -p tmp/cache
+    - name: Typecheck with Sorbet
+      run: bundle exec srb tc . --ignore=/vendor
+    - name: Run RSpec test suite
+      run: bundle exec rspec spec
+      env:
+        METRICS: '1'
+    - name: Post to Slack if build fails
+      if: failure() && (github.ref == 'refs/heads/master' || github.ref == 'refs/heads/stable')
+      uses: pullreminders/slack-action@master
+      env:
+        SLACK_BOT_TOKEN: "${{ secrets.SLACK_BOT_TOKEN }}"
+      with:
+        args: '{\"channel\":\"C33574SJJ\",\"text\":\"* ${{ github.repository }} BUILD
+          FAILURE*\", \"attachments\": [{ \"fallback\": \"Failure summary\", \"color\":
+          \"#ff0000\", \"fields\": [{\"title\": \"Branch\", \"value\":\"${{ steps.extract_branch.outputs.branch
+          }}\"}, {\"title\": \"Who broke it\", \"value\":\"${{ github.actor }}\"},
+          { \"title\": \"Build output\", \"value\": \"https://github.com/${{ github.repository
+          }}/commit/${{ github.sha }}/checks\", \"short\": false }]}]}'

data/.ruby-version

@@ -1 +1 @@
-2.5.1
+2.6.5

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+3.0.1
+
+  * Add new failure code - unprocessable_entity
+
 3.0.0
 
   * Add sorbet and support for Sorbet T::Struct

data/Gemfile

@@ -11,13 +11,11 @@ group :development, :test do
   gem 'pry-byebug'
   gem 'rb-fsevent', require: false
   gem 'rb-readline'
-  gem 'reek'
   gem 'rspec'
   gem 'rubocop'
   gem 'rubocop-rspec'
   gem 'sorbet'
   gem 'stackprof'
-  gem 'timecop'
 end
 
 group :test do

data/clean-architecture.gemspec

@@ -26,10 +26,10 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'dry-struct'
   spec.add_dependency 'dry-types'
   spec.add_dependency 'dry-validation', '>= 1.0.0'
-  spec.add_dependency 'duckface-interfaces', '~> 0.0'
+  spec.add_dependency 'duckface-interfaces', '>= 0.0'
   spec.add_dependency 'sorbet-runtime'
 
   spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake', '~> 12.0'
-  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rake', '>= 12.0'
+  spec.add_development_dependency 'rspec', '>= 3.0'
 end

data/lib/clean_architecture/queries/http_failure_code.rb

@@ -24,7 +24,8 @@ module CleanArchitecture
         'error' => :internal_server_error,
         'expectation_failed' => :expectation_failed,
         'not_found' => :not_found,
-        'unauthorized' => :unauthorized
+        'unauthorized' => :unauthorized,
+        'unprocessable_entity' => :unprocessable_entity
       }.freeze
     end
   end

data/lib/clean_architecture/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module CleanArchitecture
-  VERSION = '3.0.0'
+  VERSION = '3.0.1'
 end

data/sorbet/rbi/gems/activemodel.rbi

@@ -7,7 +7,8 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/activemodel/all/activemodel.rbi
 #
-# activemodel-6.0.0
+# activemodel-6.0.2.1
+
 module ActiveModel
   def self.eager_load!; end
   def self.gem_version; end

data/sorbet/rbi/gems/activesupport.rbi

@@ -7,7 +7,8 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/activesupport/all/activesupport.rbi
 #
-# activesupport-6.0.0
+# activesupport-6.0.2.1
+
 class Hash
   def blank?; end
   def deep_merge!(other_hash, &block); end
@@ -65,7 +66,6 @@ end
 class Module::DelegationError < NoMethodError
 end
 class ActiveSupport::Deprecation
-  def self.allocate; end
   def self.behavior(*args, &block); end
   def self.behavior=(arg); end
   def self.debug(*args, &block); end
@@ -78,7 +78,6 @@ class ActiveSupport::Deprecation
   def self.gem_name=(arg); end
   def self.initialize(*args, &block); end
   def self.instance; end
-  def self.new(*arg0); end
   def self.silence(*args, &block); end
   def self.silenced(*args, &block); end
   def self.silenced=(arg); end
@@ -404,6 +403,7 @@ class TrueClass
   def blank?; end
 end
 class String
+  def blank?; end
   def camelcase(first_letter = nil); end
   def camelize(first_letter = nil); end
   def classify; end

data/sorbet/rbi/gems/ast.rbi

@@ -8,6 +8,7 @@
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/ast/all/ast.rbi
 #
 # ast-2.4.0
+
 module AST
 end
 class AST::Node

data/sorbet/rbi/gems/byebug.rbi

@@ -7,7 +7,8 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/byebug/all/byebug.rbi
 #
-# byebug-11.0.1
+# byebug-11.1.1
+
 module Byebug
   def add_catchpoint(arg0); end
   def breakpoints; end
@@ -130,7 +131,7 @@ class Byebug::Context
   include Byebug::Helpers::FileHelper
 end
 class Byebug::DebugThread < Thread
-  def self.inherited(arg0); end
+  def self.inherited; end
 end
 class Byebug::Breakpoint
   def enabled=(arg0); end

data/sorbet/rbi/gems/coderay.rbi

@@ -8,6 +8,7 @@
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/coderay/all/coderay.rbi
 #
 # coderay-1.1.2
+
 module CodeRay
   def self.coderay_path(*path); end
   def self.encode(code, lang, format, options = nil); end

data/sorbet/rbi/gems/concurrent-ruby.rbi

@@ -7,7 +7,8 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/concurrent-ruby/all/concurrent-ruby.rbi
 #
-# concurrent-ruby-1.1.5
+# concurrent-ruby-1.1.6
+
 module Concurrent
   def abort_transaction; end
   def atomically; end
@@ -44,6 +45,7 @@ module Concurrent
   def self.processor_counter; end
   def self.use_simple_logger(level = nil, output = nil); end
   def self.use_stdlib_logger(level = nil, output = nil); end
+  extend Concurrent::Concern::Deprecation
   extend Concurrent::Concern::Logging
   extend Concurrent::Utility::EngineDetector
   extend Concurrent::Utility::NativeExtensionLoader
@@ -390,6 +392,12 @@ module Concurrent::Concern::Logging
   def log(level, progname, message = nil, &block); end
   include Logger::Severity
 end
+module Concurrent::Concern::Deprecation
+  def deprecated(message, strip = nil); end
+  def deprecated_method(old_name, new_name); end
+  extend Concurrent::Concern::Deprecation
+  include Concurrent::Concern::Logging
+end
 module Concurrent::ExecutorService
   def <<(task); end
   def can_overflow?; end
@@ -397,28 +405,14 @@ module Concurrent::ExecutorService
   def serialized?; end
   include Concurrent::Concern::Logging
 end
-class Concurrent::AtExitImplementation < Concurrent::Synchronization::LockableObject
-  def add(handler_id = nil, &handler); end
-  def delete(handler_id); end
-  def enabled=(value); end
-  def enabled?; end
-  def handler?(handler_id); end
-  def handlers; end
-  def initialize(*args); end
-  def install; end
-  def ns_initialize(enabled = nil); end
-  def run; end
-  def runner; end
-  include Logger::Severity
-end
 class Concurrent::AbstractExecutorService < Concurrent::Synchronization::LockableObject
   def auto_terminate=(value); end
   def auto_terminate?; end
   def fallback_policy; end
   def handle_fallback(*args); end
-  def initialize(*args, &block); end
+  def initialize(opts = nil, &block); end
   def kill; end
-  def ns_auto_terminate=(value); end
+  def name; end
   def ns_auto_terminate?; end
   def ns_execute(*args, &task); end
   def ns_kill_execution; end
@@ -427,8 +421,9 @@ class Concurrent::AbstractExecutorService < Concurrent::Synchronization::Lockabl
   def shutdown; end
   def shutdown?; end
   def shuttingdown?; end
-  def terminate_at_exit; end
+  def to_s; end
   def wait_for_termination(timeout = nil); end
+  include Concurrent::Concern::Deprecation
   include Concurrent::ExecutorService
 end
 module Concurrent::SerialExecutorService
@@ -534,7 +529,7 @@ end
 class Concurrent::RubyThreadPoolExecutor::Worker
   def <<(message); end
   def create_worker(queue, pool, idletime); end
-  def initialize(pool); end
+  def initialize(pool, id); end
   def kill; end
   def run_task(pool, task, args); end
   def stop; end
@@ -687,10 +682,10 @@ class Concurrent::AbstractThreadLocalVar
 end
 class Concurrent::RubyThreadLocalVar < Concurrent::AbstractThreadLocalVar
   def allocate_storage; end
-  def default_for(thread); end
+  def get_default; end
   def get_threadlocal_array(thread = nil); end
-  def self.thread_finalizer(array); end
-  def self.threadlocal_finalizer(index); end
+  def self.thread_finalizer(id); end
+  def self.thread_local_finalizer(index); end
   def set_threadlocal_array(array, thread = nil); end
   def value; end
   def value=(value); end
@@ -737,7 +732,7 @@ end
 class Concurrent::SimpleExecutorService < Concurrent::RubyExecutorService
   def <<(task); end
   def kill; end
-  def ns_initialize; end
+  def ns_initialize(*args); end
   def post(*args, &task); end
   def running?; end
   def self.<<(task); end
@@ -1057,6 +1052,7 @@ module Concurrent::Synchronization::AbstractStruct
   def ns_each_pair; end
   def ns_equality(other); end
   def ns_get(member); end
+  def ns_initialize_copy; end
   def ns_inspect; end
   def ns_merge(other, &block); end
   def ns_select; end
@@ -1072,6 +1068,7 @@ module Concurrent::ImmutableStruct
   def [](member); end
   def each(&block); end
   def each_pair(&block); end
+  def initialize_copy(original); end
   def inspect; end
   def merge(other, &block); end
   def select(&block); end
@@ -1090,6 +1087,7 @@ module Concurrent::MutableStruct
   def []=(member, value); end
   def each(&block); end
   def each_pair(&block); end
+  def initialize_copy(original); end
   def inspect; end
   def merge(other, &block); end
   def select(&block); end
@@ -1128,6 +1126,7 @@ module Concurrent::SettableStruct
   def []=(member, value); end
   def each(&block); end
   def each_pair(&block); end
+  def initialize_copy(original); end
   def inspect; end
   def merge(other, &block); end
   def select(&block); end

data/sorbet/rbi/gems/docile.rbi

@@ -8,6 +8,7 @@
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/docile/all/docile.rbi
 #
 # docile-1.3.2
+
 module Docile
   def dsl_eval(dsl, *args, &block); end
   def dsl_eval_immutable(dsl, *args, &block); end

data/sorbet/rbi/gems/dry-configurable.rbi

@@ -1,89 +1,139 @@
 # This file is autogenerated. Do not edit it by hand. Regenerate it with:
 #   srb rbi gems
 
-# typed: strong
+# typed: true
 #
 # If you would like to make changes to this file, great! Please create the gem's shim here:
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/dry-configurable/all/dry-configurable.rbi
 #
-# dry-configurable-0.8.3
+# dry-configurable-0.11.2
+
 module Dry
 end
 module Dry::Configurable
-  def clone; end
-  def config; end
-  def configure; end
-  def dup; end
-  def finalize!; end
-  def initialize(*arg0); end
-  def self.extended(base); end
-  def self.included(base); end
+  def self.extended(klass); end
+  def self.included(klass); end
   include Dry::Core::Constants
 end
-class Dry::Configurable::Settings
-  def add(key, value = nil, options = nil, &block); end
-  def config_class; end
-  def config_defined?; end
-  def create_config; end
-  def dup; end
-  def each; end
-  def empty?; end
-  def freeze; end
-  def initialize(settings = nil); end
-  def name?(name); end
-  def names; end
-  def self.capture(&block); end
-  def settings; end
+class Dry::Configurable::Error < StandardError
+end
+class Dry::Configurable::FrozenConfig < Dry::Configurable::Error
+end
+class Dry::Configurable::Config
+  def [](name); end
+  def []=(name, value); end
+  def _resolved; end
+  def _settings; end
+  def finalize!; end
+  def initialize(settings); end
+  def initialize_copy(source); end
+  def method_missing(meth, *args); end
+  def pristine; end
+  def resolve(meth); end
+  def respond_to_missing?(meth, include_private = nil); end
+  def to_h; end
+  def to_hash; end
+  def update(values); end
+  def values; end
+  include Anonymous_Dry_Equalizer_14
+  include Dry::Equalizer::Methods
 end
-class Dry::Configurable::Settings::ArgumentParser
-  def call(val, opts, block); end
-  def options(reader: nil); end
+module Anonymous_Dry_Equalizer_14
+  def cmp?(comparator, other); end
+  def hash; end
+  def inspect; end
 end
 class Dry::Configurable::Setting
-  def initialize(name, value, processor, options = nil); end
+  def clonable_value?; end
+  def constructor; end
+  def default; end
+  def evaluate; end
+  def initialize(name, input: nil, default: nil, **options); end
+  def initialize_copy(source); end
+  def input; end
   def name; end
-  def node?; end
+  def nested(settings); end
   def options; end
-  def processor; end
+  def pristine; end
   def reader?; end
-  def undefined?; end
   def value; end
+  def with(new_opts); end
+  def writer?(meth); end
+  def writer_name; end
+  include Anonymous_Dry_Equalizer_15
+  include Dry::Equalizer::Methods
 end
-class Dry::Configurable::Config
+module Anonymous_Dry_Equalizer_15
+  def cmp?(comparator, other); end
+  def hash; end
+  def inspect; end
+end
+class Dry::Configurable::Setting::Nested < Dry::Configurable::Setting
+  def constructor; end
+  def pristine; end
+end
+class Dry::Configurable::Settings
+  def <<(setting); end
   def [](name); end
-  def []=(name, value); end
-  def define!(parent_config = nil); end
-  def defined?; end
-  def dup; end
-  def finalize!; end
-  def initialize; end
+  def each(&block); end
+  def elements; end
+  def initialize(elements = nil); end
+  def initialize_copy(source); end
+  def initialize_elements(elements); end
   def key?(name); end
-  def raise_unknown_setting_error(name); end
-  def self.[](settings); end
-  def self.config_defined?; end
-  def self.define_accessors!; end
-  def set_values!(parent); end
-  def to_h; end
-  def to_hash; end
-  def update(values); end
+  def keys; end
+  def pristine; end
+  include Anonymous_Dry_Equalizer_16
+  include Dry::Equalizer::Methods
+  include Enumerable
 end
-class Dry::Configurable::Settings::DSL
-  def initialize; end
-  def self.call(&block); end
-  def setting(*args, &block); end
+module Anonymous_Dry_Equalizer_16
+  def cmp?(comparator, other); end
+  def hash; end
+  def inspect; end
 end
-class Dry::Configurable::Error < StandardError
+class Dry::Configurable::Compiler
+  def call(ast); end
+  def visit(node); end
+  def visit_constructor(node); end
+  def visit_nested(node); end
+  def visit_setting(node); end
 end
-class Dry::Configurable::AlreadyDefinedConfig < Dry::Configurable::Error
+class Dry::Configurable::DSL
+  def ast; end
+  def compiler; end
+  def initialize(&block); end
+  def setting(name, *args, &block); end
 end
-class Dry::Configurable::FrozenConfig < Dry::Configurable::Error
+class Dry::Configurable::DSL::Args
+  def args; end
+  def default; end
+  def ensure_valid_options; end
+  def initialize(args); end
+  def options; end
+  def opts; end
+  def size; end
+  def to_ary; end
+end
+module Dry::Configurable::Methods
+  def configure(&block); end
+  def finalize!; end
 end
 module Dry::Configurable::ClassMethods
+  def __config_dsl__; end
+  def __config_reader__; end
   def _settings; end
-  def inherited(subclass); end
-  def raise_already_defined_config(key); end
-  def self.extended(base); end
-  def setting(key, value = nil, options = nil, &block); end
+  def config; end
+  def inherited(klass); end
+  def setting(*args, &block); end
   def settings; end
+  include Dry::Configurable::Methods
+end
+module Dry::Configurable::InstanceMethods
+  def config; end
+  def finalize!; end
+  def initialize(*arg0); end
+  def initialize_copy(source); end
+  include Dry::Configurable::Methods
 end