dry-mutations 0.8.98 → 0.8.99

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b80a530afd1c61d67a42c30dff68c110bcfa9d2
-  data.tar.gz: bf5131d90014289ca96734bd375db7926e516446
+  metadata.gz: adf3c66151551d8178bec6e8cb4be0cebc44c510
+  data.tar.gz: 511479d97e75272438c8ae12c2800b8fd7b7e4d3
 SHA512:
-  metadata.gz: 644df92df56e36d80539363d9eb94650ac158b597f1fc34a7c0aba61a061cfe62ae81b75bc4026487690300ac2eddfa2ec7b832c9e6e005032faf78dc3287f05
-  data.tar.gz: 91a4705b8789f241e216c684588b8bf891bf0482fb5bb4d165db1640c15866b7c985ac2c26027e0a463dad5d8046452cca2247a1e36e044d5e5964d840d7f17f
+  metadata.gz: 87e8f198e537c75f70fb563efec3fea2611628283851ddf41b3d1e2f27ea8c6549d2a49d23a227e1f1575995ad5286ea3a6f1e4c758b189a70cbe575236b6b0c
+  data.tar.gz: be2bde7e5fd9f2a237bc5669b57ab3f5ef435bfdbdc591be543e9da0d7e5fd47bf1792ba1a05e38e5ac8fb6622ffe2bb12fa2698200885df2a7e11a5ddbfc1f3

data/.rubocop.yml

@@ -29,6 +29,9 @@ Style/MethodName:
     - 'lib/dry/mutations/utils.rb'
     - 'lib/dry/transactions/*.rb'
 
+Style/VariableName:
+  SupportedStyles: snake_case
+
 ################################################################################
 
 Style/Alias:

data/.rubocop_todo.yml

@@ -35,9 +35,3 @@ Style/FirstParameterIndentation:
 # SupportedStyles: single_quotes, double_quotes
 Style/StringLiterals:
   Enabled: false
-
-# Offense count: 2
-# Configuration parameters: EnforcedStyle, SupportedStyles.
-# SupportedStyles: snake_case, camelCase
-Style/VariableName:
-  Enabled: false

data/lib/dry/mutations/extensions/command.rb

@@ -35,11 +35,7 @@ module Dry
         attr_reader :validation
 
         def initialize(*args)
-          @raw_inputs = args.inject(Utils.Hash({})) do |h, arg|
-            arg = arg.value if arg.is_a?(Right)
-            fail ArgumentError.new("All arguments must be hashes. Given: #{args.inspect}.") unless arg.is_a?(Hash)
-            h.merge!(arg)
-          end
+          @raw_inputs = Utils.RawInputs(*args)
 
           @validation_result = schema.(@raw_inputs)
 

data/lib/dry/mutations/extensions/dummy.rb

@@ -17,17 +17,23 @@ module Dry
         end
       end
 
+      module Hole # :nodoc:
+        def initialize(*args)
+          @raw_inputs = Utils.RawInputs(*args)
+          # @validation_result = schema.(@raw_inputs)
+          @inputs = Utils.Hash @raw_inputs
+          @errors = nil
+        end
+      end
+
       # rubocop:disable Style/ConstantName
       Dummy = ENV['USE_SIEVE_AS_DUMMY'] ? Sieve : Pipe
       # rubocop:enable Style/ConstantName
 
       module Wrapper # :nodoc:
-        include Dummy
-        prepend(Module.new do
-                  def execute
-                    { Utils.Snake(self.class, short: true, symbolize: true) => super }
-                  end
-                end)
+        def execute
+          { Utils.Snake(self.class, short: true, symbolize: true) => super }
+        end
       end
     end
   end

data/lib/dry/mutations/transactions/step_adapters/tranquilo.rb

@@ -6,6 +6,7 @@ module Dry
       #   which should return the step’s result wrapped in an `Either` object.
       class Tranquilo < StepAdapters::Move # :nodoc:
         def call(step, *args, input)
+          # TODO: FIXME: PENDING: when block passing is merged into dry-validation
           step.operation.(input, *args)
         end
       end

data/lib/dry/mutations/utils.rb

@@ -1,139 +1,3 @@
-module Dry
-  module Mutations
-    module Utils # :nodoc:
-      FALSEY =  /\A#{Regexp.union(%w(0 skip false falsey no n)).source}\z/i
-      TRUTHY =  /\A#{Regexp.union(%w(1 use true truthy yes y)).source}\z/i
-
-      def self.Falsey? input, explicit: true
-        explicit ? input.to_s =~ FALSEY : input.to_s !~ TRUTHY
-      end
-
-      def self.Truthy? input, explicit: true
-        explicit ? input.to_s =~ TRUTHY : input.to_s !~ FALSEY
-      end
-
-      def self.Snake(whatever, short: false, symbolize: false)
-        result = whatever.to_s.split('::').map do |e|
-          e.gsub(/(?<=[^\W_])(?=[A-Z])/, '_').downcase
-        end
-        result = short ? result.last : result.join('__')
-        symbolize ? result.to_sym : result
-      end
-
-      def self.SnakeSafe(whatever, existing = [], update_existing: true, short: false, symbolize: false)
-        result = Snake(whatever, short: short)
-        str = loop do
-          break result unless existing.include? result
-          suffix = result[/(?<=_)\d+(?=\z)/]
-          suffix.nil? ? result << '_1' : result[-suffix.length..-1] = (suffix.to_i + 1).to_s
-        end.tap { |r| existing << r if update_existing }
-        symbolize ? str.to_sym : str
-      end
-
-      def self.Camel(whatever)
-        whatever.to_s.split('__').map do |s|
-          s.gsub(/(?:\A|_)(?<letter>\w)/) { $~[:letter].upcase }
-        end.join('::')
-      end
-
-      def self.Constant(whatever)
-        ::Kernel.const_get(Camel(whatever))
-      end
-
-      def self.Λ input, **params
-        case
-        when params[:method] then input.method(params.delete[:method].to_sym).to_proc
-        when input.respond_to?(:to_proc) then input.to_proc
-        when input.respond_to?(:call) then input.method(:call).to_proc
-        else fail ArgumentError, "The executor given can not be executed (forgot to specify :method param?)"
-        end
-      end
-
-      # Lazy detector for Hashie::Mash
-      #   TODO: Make it possible to choose friendly hash implementation
-      USE_HASHIE_MASH = Falsey?(ENV['PLAIN_HASHES'], explicit: false) && begin
-        require 'hashie/mash'
-        true
-      rescue LoadError => e
-        $stderr.puts [
-          '[DRY] Could not find Hashie::Mash.',
-          'You probably want to install it / add it to your Gemfile.',
-          "Error: [#{e.message}]."
-        ].join($/)
-      end
-
-      # Converts a hash to a best available hash implementation
-      #   with stringified keys, since `Mutations` expect hash
-      #   keys to be strings.
-      def self.Hash hash = {}
-        case
-        when USE_HASHIE_MASH
-          Kernel.const_get('::Hashie::Mash').new(hash)
-        when hash.respond_to?(:with_indifferent_access)
-          hash.with_indifferent_access
-        else
-          hash.map { |k, v| [k.to_s, v] }.to_h
-        end
-      end
-
-      ITSELF = ->(h, k) { h[k] = k }
-      DRY_TO_MUTATIONS = {
-        min_size?:    :min_length,
-        max_size?:    :max_length,
-        format?:      :matches,
-        inclusion?:   :in, # deprecated in Dry
-        included_in?: :in,
-        gteq?:        :min,
-        lteq?:        :max
-      }.freeze
-      MUTATIONS_TO_DRY = DRY_TO_MUTATIONS.invert.merge(default: :default?).freeze
-
-      # Fuzzy converts params between different implementaions
-      def self.Guards *keys, **params
-        return {} if params.empty? || params[:empty] # Mutations `empty?` guard takes precedence on all others
-
-        keys = params.keys if keys.empty?
-        keys.flatten! # allow array to be passed as the only parameter
-
-        map = [DRY_TO_MUTATIONS, MUTATIONS_TO_DRY].detect do |h|
-          (h.keys & keys).any?
-        end || Hash.new(&ITSELF)
-
-        map.values_at(*keys).zip(keys.map(&params.method(:[])))
-           .to_h
-           .tap { |h| h.delete(nil) }
-      end
-
-      def self.Type type, **params
-        case type.to_s
-        when 'string'
-          if Falsey?(params[:strip])
-            :str?
-          else
-            # TODO: this silently coerces everything to be a string
-            #       when `param[:strip]` is specified. This is likely OK, though.
-            ::Dry::Types::Constructor.new(
-              ::Dry::Types['strict.string'], fn: ->(v) { v.to_s.strip }
-            )
-          end
-        when 'date'
-          ::Dry::Types::Constructor.new(
-            ::Dry::Types['strict.date'], fn: ->(v) { v.is_a?(Date) ? v : (Date.parse(v.to_s) rescue v) }
-          )
-        when 'integer'
-          :int?
-          # FIXME: Why ints are not coercible?!
-          #::Dry::Types::Constructor.new(
-          #  ::Dry::Types['coercible.int'], fn: ->(v) { v.is_a?(Integer) ? v : (v.to_i rescue v) }
-          #)
-        when 'boolean' then :bool?
-        else :"#{type}?"
-        end
-      end
-
-      def self.smart_send receiver, *args, **params
-        params.empty? ? receiver.__send__(*args) : receiver.__send__(*args, **params)
-      end
-    end
-  end
-end
+require 'dry/mutations/utils/generic'
+require 'dry/mutations/utils/procs'
+require 'dry/mutations/utils/dry-mutations'

data/lib/dry/mutations/utils/dry-mutations.rb

@@ -0,0 +1,74 @@
+module Dry
+  module Mutations
+    module Utils # :nodoc:
+      DRY_TO_MUTATIONS = {
+        min_size?:    :min_length,
+        max_size?:    :max_length,
+        format?:      :matches,
+        inclusion?:   :in, # deprecated in Dry
+        included_in?: :in,
+        gteq?:        :min,
+        lteq?:        :max
+      }.freeze
+      MUTATIONS_TO_DRY = DRY_TO_MUTATIONS.invert.merge(default: :default?).freeze
+
+      def self.RawInputs *args
+        args.inject(Utils.Hash({})) do |h, arg|
+          h.merge! case arg
+                   when Hash then arg
+                   when ::Dry::Monads::Either::Right then arg.value
+                   when ::Dry::Monads::Either::Left then fail ArgumentError.new("Can’t accept Left value: #{args.inspect}.")
+                   else fail ArgumentError.new("All arguments must be hashes. Given: #{args.inspect}.") unless arg.is_a?(Hash)
+                   end
+        end
+      end
+
+      # Fuzzy converts params between different implementaions
+      def self.Guards *keys, **params
+        return {} if params.empty? || params[:empty] # Mutations `empty?` guard takes precedence on all others
+
+        keys = params.keys if keys.empty?
+        keys.flatten! # allow array to be passed as the only parameter
+
+        map = [DRY_TO_MUTATIONS, MUTATIONS_TO_DRY].detect do |h|
+          (h.keys & keys).any?
+        end || Hash.new(&ITSELF)
+
+        map.values_at(*keys).zip(keys.map(&params.method(:[])))
+           .to_h
+           .tap { |h| h.delete(nil) }
+      end
+
+      def self.Type type, **params
+        case type.to_s
+        when 'string'
+          if Falsey?(params[:strip])
+            :str?
+          else
+            # TODO: this silently coerces everything to be a string
+            #       when `param[:strip]` is specified. This is likely OK, though.
+            ::Dry::Types::Constructor.new(
+              ::Dry::Types['strict.string'], fn: ->(v) { v.to_s.strip }
+            )
+          end
+        when 'date'
+          ::Dry::Types::Constructor.new(
+            ::Dry::Types['strict.date'], fn: ->(v) { v.is_a?(Date) ? v : (Date.parse(v.to_s) rescue v) }
+          )
+        when 'integer'
+          :int?
+          # FIXME: Why ints are not coercible?!
+          #::Dry::Types::Constructor.new(
+          #  ::Dry::Types['coercible.int'], fn: ->(v) { v.is_a?(Integer) ? v : (v.to_i rescue v) }
+          # )
+        when 'boolean' then :bool?
+        else :"#{type}?"
+        end
+      end
+
+      def self.smart_send receiver, *args, **params
+        params.empty? ? receiver.__send__(*args) : receiver.__send__(*args, **params)
+      end
+    end
+  end
+end

data/lib/dry/mutations/utils/generic.rb

@@ -0,0 +1,60 @@
+module Dry
+  module Mutations
+    module Utils # :nodoc:
+      FALSEY =  /\A#{Regexp.union(%w(0 skip false falsey no n)).source}\z/i
+      TRUTHY =  /\A#{Regexp.union(%w(1 use true truthy yes y)).source}\z/i
+
+      def self.Falsey? input, explicit: true
+        explicit ? input.to_s =~ FALSEY : input.to_s !~ TRUTHY
+      end
+
+      def self.Truthy? input, explicit: true
+        explicit ? input.to_s =~ TRUTHY : input.to_s !~ FALSEY
+      end
+
+      def self.Snake(whatever, short: false, symbolize: false)
+        result = whatever.to_s.split('::').map do |e|
+          e.gsub(/(?<=[^\W_])(?=[A-Z])/, '_').downcase
+        end
+        result = short ? result.last : result.join('__')
+        symbolize ? result.to_sym : result
+      end
+
+      def self.SnakeSafe(whatever, existing = [], update_existing: true, short: false, symbolize: false)
+        result = Snake(whatever, short: short)
+        str = loop do
+          break result unless existing.include? result
+          suffix = result[/(?<=_)\d+(?=\z)/]
+          suffix.nil? ? result << '_1' : result[-suffix.length..-1] = (suffix.to_i + 1).to_s
+        end.tap { |r| existing << r if update_existing }
+        symbolize ? str.to_sym : str
+      end
+
+      def self.Camel(whatever)
+        whatever.to_s.split('__').map do |s|
+          s.gsub(/(?:\A|_)(?<letter>\w)/) { $~[:letter].upcase }
+        end.join('::')
+      end
+
+      def self.Constant(whatever)
+        ::Kernel.const_get(Camel(whatever))
+      end
+
+      # Converts a hash to a best available hash implementation
+      #   with stringified keys, since `Mutations` expect hash
+      #   keys to be strings.
+      def self.Hash hash = {}
+        case
+        when USE_HASHIE_MASH
+          Kernel.const_get('::Hashie::Mash').new(hash)
+        when hash.respond_to?(:with_indifferent_access)
+          hash.with_indifferent_access
+        else
+          hash.map { |k, v| [k.to_s, v] }.to_h
+        end
+      end
+
+      ITSELF = ->(h, k) { h[k] = k }
+    end
+  end
+end

data/lib/dry/mutations/utils/procs.rb

@@ -0,0 +1,27 @@
+module Dry
+  module Mutations
+    module Utils # :nodoc:
+      def self.Λ input, **params
+        case
+        when params[:method] then input.method(params.delete[:method].to_sym).to_proc
+        when input.respond_to?(:to_proc) then input.to_proc
+        when input.respond_to?(:call) then input.method(:call).to_proc
+        else fail ArgumentError, "The executor given can not be executed (forgot to specify :method param?)"
+        end
+      end
+
+      # Lazy detector for Hashie::Mash
+      #   TODO: Make it possible to choose friendly hash implementation
+      USE_HASHIE_MASH = Falsey?(ENV['PLAIN_HASHES'], explicit: false) && begin
+        require 'hashie/mash'
+        true
+      rescue LoadError => e
+        $stderr.puts [
+          '[DRY] Could not find Hashie::Mash.',
+          'You probably want to install it / add it to your Gemfile.',
+          "Error: [#{e.message}]."
+        ].join($/)
+      end
+    end
+  end
+end

data/lib/dry/mutations/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Mutations
-    VERSION = '0.8.98'.freeze
+    VERSION = '0.8.99'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-mutations
 version: !ruby/object:Gem::Version
-  version: 0.8.98
+  version: 0.8.99
 platform: ruby
 authors:
 - Aleksei Matiushkin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-04 00:00:00.000000000 Z
+date: 2016-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -231,6 +231,9 @@ files:
 - lib/dry/mutations/transactions/step_adapters/validate.rb
 - lib/dry/mutations/transactions/wrapper.rb
 - lib/dry/mutations/utils.rb
+- lib/dry/mutations/utils/dry-mutations.rb
+- lib/dry/mutations/utils/generic.rb
+- lib/dry/mutations/utils/procs.rb
 - lib/dry/mutations/version.rb
 homepage: http://github.com/am-kantox/dry-mutations
 licenses: