hanami-utils 1.0.4 → 1.1.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c65504458f0d4f9fe10074d2375b48bef9beab06
-  data.tar.gz: d33a0515a65119a9da3f1db4becfdaae5a20602a
+  metadata.gz: fe0165282131db30a45dc60b913b4a36f9eb2095
+  data.tar.gz: c5ec0be6be92bd58c1e0b6043634b0d0af68e7fd
 SHA512:
-  metadata.gz: 0bf23ef0c947d2d7fc88fa750c3077d474beaae7e8812175ccbaf049d731da81044fafc1984f9b4fffd429e3003c6c56bd1d10af9a055cc30b3c2a77e5bf528e
-  data.tar.gz: 9a24391a94ee3ae43f741e813ff7670d5c9b5978debf30acb1a1cef13c80ec1da421800e5c64c19703f9d4fa4287d37a97b5bc18f5a7e114bb0a8c6f097f6d39
+  metadata.gz: c4eaf7e264153e4062cafa3eccead00a4793e64e4c44f291c4b573819b4f480155122198e37d3a13283e0ad1e01a0cf96e0e3e5e3c7de3ddd48d64a35bfd7e07
+  data.tar.gz: 93ca73d54081fb22c927a398dfd6e7d4573554a48d8847a7aef91b6134bbea4904b122a8fd577e4f0fac77420e3c9df2a0c3176e019a572b5923f9ace3718dff

data/CHANGELOG.md

@@ -1,15 +1,14 @@
 # Hanami::Utils
 Ruby core extentions and class utilities for Hanami
 
-## v1.0.4 - 2017-10-02
-### Fixed
-- [Luca Guidi] Make `Hanami::Utils::BasicObject` to be fully compatible with Ruby's `pp` and to be inspected by Pry.
-- [Thiago Kenji Okada] Fix pluralization/singularization for `"release" => "releases"`
-
-## v1.0.3 - 2017-09-06
-### Fixed
-- [Malina Sulca] Fix pluralization/singularization for `"exercise" => "exercises"`
-- [Xavier Barbosa] Fix pluralization/singularization for `"area" => "areas"`
+## v1.1.0.beta1 - 2017-08-11
+### Added
+- [Marion Duprey] Allow `Hanami::Interactor#call` to accept arguments. `#initialize` should be used for Dependency Injection, while `#call` should be used for input
+- [Marion Schleifer] Introduce `Utils::Hash.stringify`
+- [Marion Schleifer] Introduce `Utils::String.titleize`, `.capitalize`, `.classify`, `.underscore`, `.dasherize`, `.demodulize`, `.namespace`, `.pluralize`, `.singularize`, and `.rsub`
+- [Luca Guidi] Introduce `Utils::Files`: a set of utils for file manipulations
+- [Luca Guidi] Introduce `Utils::String.transform` a pipelined transformations for strings
+- [Marion Duprey & Gabriel Gizotti] Filter sensitive informations for `Hanami::Logger`
 
 ## v1.0.2 - 2017-07-10
 ### Fixed

data/README.md

@@ -92,6 +92,10 @@ Safe and fast escape for URLs, HTML content and attributes. Based on OWASP/ESAPI
 
 Recursive, cross-platform ordered list of files. [[API doc](http://www.rubydoc.info/gems/hanami-utils/Hanami/Utils/FileList)]
 
+### Hanami::Utils::Files
+
+File utilities to manipulate files and directories. [[API doc](http://www.rubydoc.info/gems/hanami-utils/Hanami/Utils/Files)]
+
 ### Hanami::Utils::Hash
 
 Enhanced version of Ruby's `Hash`. [[API doc](http://www.rubydoc.info/gems/hanami-utils/Hanami/Utils/Hash)]

data/hanami-utils.gemspec

@@ -18,7 +18,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
   spec.required_ruby_version = '>= 2.3.0'
 
-  spec.add_dependency 'transproc', '~> 1.0'
+  spec.add_dependency 'transproc',       '~> 1.0'
+  spec.add_dependency 'concurrent-ruby', '~> 1.0'
 
   spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'rake',    '~> 11'

data/lib/hanami/interactor.rb

@@ -145,15 +145,14 @@ module Hanami
       super
 
       base.class_eval do
-        prepend Interface
-        extend  ClassMethods
+        extend ClassMethods
       end
     end
 
-    # Interactor interface
+    # Interactor legacy interface
     #
     # @since 0.3.5
-    module Interface
+    module LegacyInterface
       # Initialize an interactor
       #
       # It accepts arbitrary number of arguments.
@@ -262,6 +261,118 @@ module Hanami
       def call
         _call { super }
       end
+
+      private
+
+      # @since 0.3.5
+      # @api private
+      def _call
+        catch :fail do
+          validate!
+          yield
+        end
+
+        _prepare!
+      end
+
+      # @since 0.3.5
+      def validate!
+        fail! unless valid?
+      end
+    end
+
+    # Interactor interface
+    # @since 1.1.0
+    module Interface
+      # Triggers the operation and return a result.
+      #
+      # All the exposed instance variables will be available in the result.
+      #
+      # ATTENTION: This must be implemented by the including class.
+      #
+      # @return [Hanami::Interactor::Result] the result of the operation
+      #
+      # @raise [NoMethodError] if this isn't implemented by the including class.
+      #
+      # @example Expose instance variables in result payload
+      #   require 'hanami/interactor'
+      #
+      #   class Signup
+      #     include Hanami::Interactor
+      #     expose :user, :params
+      #
+      #     def call(params)
+      #       @params = params
+      #       @foo = 'bar'
+      #       @user = UserRepository.new.persist(User.new(params))
+      #     end
+      #   end
+      #
+      #   result = Signup.new(name: 'Luca').call
+      #   result.failure? # => false
+      #   result.successful? # => true
+      #
+      #   result.user   # => #<User:0x007fa311105778 @id=1 @name="Luca">
+      #   result.params # => { :name=>"Luca" }
+      #   result.foo    # => raises NoMethodError
+      #
+      # @example Failed precondition
+      #   require 'hanami/interactor'
+      #
+      #   class Signup
+      #     include Hanami::Interactor
+      #     expose :user
+      #
+      #     # THIS WON'T BE INVOKED BECAUSE #valid? WILL RETURN false
+      #     def call(params)
+      #       @user = User.new(params)
+      #       @user = UserRepository.new.persist(@user)
+      #     end
+      #
+      #     private
+      #     def valid?(params)
+      #       params.valid?
+      #     end
+      #   end
+      #
+      #   result = Signup.new.call(name: nil)
+      #   result.successful? # => false
+      #   result.failure? # => true
+      #
+      #   result.user   # => nil
+      #
+      # @example Bad usage
+      #   require 'hanami/interactor'
+      #
+      #   class Signup
+      #     include Hanami::Interactor
+      #
+      #     # Method #call is not defined
+      #   end
+      #
+      #   Signup.new.call # => NoMethodError
+      def call(*args, **kwargs)
+        @__result = ::Hanami::Interactor::Result.new
+        _call(*args, **kwargs) { super }
+      end
+
+      private
+
+      # @api private
+      # @since 1.1.0
+      def _call(*args, **kwargs)
+        catch :fail do
+          validate!(*args, **kwargs)
+          yield
+        end
+
+        _prepare!
+      end
+
+      # @since 1.1.0
+      def validate!(*args, **kwargs)
+        fail! unless valid?(*args, **kwargs)
+      end
     end
 
     private
@@ -274,7 +385,7 @@ module Hanami
     # @return [TrueClass,FalseClass] the result of the check
     #
     # @since 0.3.5
-    def valid?
+    def valid?(*)
       true
     end
 
@@ -426,22 +537,6 @@ module Hanami
       fail!
     end
 
-    # @since 0.3.5
-    # @api private
-    def _call
-      catch :fail do
-        validate!
-        yield
-      end
-
-      _prepare!
-    end
-
-    # @since 0.3.5
-    def validate!
-      fail! unless valid?
-    end
-
     # @since 0.3.5
     # @api private
     def _prepare!
@@ -453,7 +548,7 @@ module Hanami
     def _exposures
       Hash[].tap do |result|
         self.class.exposures.each do |name, ivar|
-          result[name] = instance_variable_get(ivar)
+          result[name] = instance_variable_defined?(ivar) ? instance_variable_get(ivar) : nil
         end
       end
     end
@@ -473,6 +568,17 @@ module Hanami
       end
     end
 
+    def method_added(method_name)
+      super
+      return unless method_name == :call
+
+      if instance_method(:call).arity.zero?
+        prepend Hanami::Interactor::LegacyInterface
+      else
+        prepend Hanami::Interactor::Interface
+      end
+    end
+
     # Expose local instance variables into the returning value of <tt>#call</tt>
     #
     # @param instance_variable_names [Symbol,Array<Symbol>] one or more instance

data/lib/hanami/logger.rb

@@ -3,6 +3,7 @@ require 'json'
 require 'logger'
 require 'hanami/utils/string'
 require 'hanami/utils/json'
+require 'hanami/utils/hash'
 require 'hanami/utils/class_attribute'
 
 module Hanami
@@ -117,15 +118,13 @@ module Hanami
       class_attribute :subclasses
       self.subclasses = Set.new
 
-      def self.fabricate(formatter, application_name)
-        case formatter
-        when Symbol
-          (subclasses.find { |s| s.eligible?(formatter) } || self).new
-        when nil
-          new
-        else
-          formatter
-        end.tap { |f| f.application_name = application_name }
+      def self.fabricate(formatter, application_name, filters)
+        fabricated_formatter = _formatter_instance(formatter)
+
+        fabricated_formatter.application_name = application_name
+        fabricated_formatter.hash_filter      = HashFilter.new(filters)
+
+        fabricated_formatter
       end
 
       # @api private
@@ -139,6 +138,20 @@ module Hanami
         name == :default
       end
 
+      # @api private
+      # @since 1.1.0
+      def self._formatter_instance(formatter)
+        case formatter
+        when Symbol
+          (subclasses.find { |s| s.eligible?(formatter) } || self).new
+        when nil
+          new
+        else
+          formatter
+        end
+      end
+      private_class_method :_formatter_instance
+
       # @since 0.5.0
       # @api private
       attr_writer :application_name
@@ -147,6 +160,10 @@ module Hanami
       # @api private
       attr_reader :application_name
 
+      # @since 1.1.0
+      # @api private
+      attr_writer :hash_filter
+
       # @since 0.5.0
       # @api private
       #
@@ -168,7 +185,7 @@ module Hanami
       def _message_hash(message) # rubocop:disable Metrics/MethodLength
         case message
         when Hash
-          message
+          @hash_filter.filter(message)
         when Exception
           Hash[
             message:   message.message,
@@ -206,6 +223,67 @@ module Hanami
 
         result
       end
+
+      # Filtering logic
+      #
+      # @since 1.1.0
+      # @api private
+      class HashFilter
+        # @since 1.1.0
+        # @api private
+        attr_reader :filters
+
+        # @since 1.1.0
+        # @api private
+        def initialize(filters = [])
+          @filters = filters
+        end
+
+        # @since 1.1.0
+        # @api private
+        def filter(hash)
+          _filtered_keys(hash).each do |key|
+            *keys, last = _actual_keys(hash, key.split('.'))
+            keys.inject(hash, :fetch)[last] = '[FILTERED]'
+          end
+
+          hash
+        end
+
+        private
+
+        # @since 1.1.0
+        # @api private
+        def _filtered_keys(hash)
+          _key_paths(hash).select { |key| filters.any? { |filter| key =~ %r{(\.|\A)#{filter}(\.|\z)} } }
+        end
+
+        # @since 1.1.0
+        # @api private
+        def _key_paths(hash, base = nil)
+          hash.inject([]) do |results, (k, v)|
+            results + (v.respond_to?(:each) ? _key_paths(v, _build_path(base, k)) : [_build_path(base, k)])
+          end
+        end
+
+        # @since 1.1.0
+        # @api private
+        def _build_path(base, key)
+          [base, key.to_s].compact.join('.')
+        end
+
+        # @since 1.1.0
+        # @api private
+        def _actual_keys(hash, keys)
+          search_in = hash
+
+          keys.inject([]) do |res, key|
+            correct_key = search_in.key?(key.to_sym) ? key.to_sym : key
+            search_in = search_in[correct_key]
+            res + [correct_key]
+          end
+        end
+      end
     end
 
     # Hanami::Logger JSON formatter.
@@ -375,13 +453,13 @@ module Hanami
     #   logger.info "Hello World"
     #
     #   # => {"app":"Hanami","severity":"DEBUG","time":"2017-03-30T13:57:59Z","message":"Hello World"}
-    def initialize(application_name = nil, *args, stream: $stdout, level: DEBUG, formatter: nil)
+    def initialize(application_name = nil, *args, stream: $stdout, level: DEBUG, formatter: nil, filter: []) # rubocop:disable Metrics/ParameterLists
       super(stream, *args)
 
       @level            = _level(level)
       @stream           = stream
       @application_name = application_name
-      @formatter        = Formatter.fabricate(formatter, self.application_name)
+      @formatter        = Formatter.fabricate(formatter, self.application_name, filter)
     end
 
     # Returns the current application name, this is used for tagging purposes

data/lib/hanami/utils/basic_object.rb

@@ -21,7 +21,7 @@ module Hanami
       #
       # @see http://ruby-doc.org/core/Object.html#method-i-inspect
       def inspect
-        "#<#{self.class}:#{'0x0000%x' % (__id__ << 1)}#{__inspect}>" # rubocop:disable Style/FormatString
+        "#<#{self.class}:#{'%x' % (__id__ << 1)}#{__inspect}>" # rubocop:disable Style/FormatString
       end
 
       # Alias for __id__
@@ -37,14 +37,13 @@ module Hanami
 
       # Interface for pp
       #
-      # @param printer [PP] the Pretty Printable printer
       # @return [String] the pretty-printable inspection of the object
       #
       # @since 0.9.0
       #
       # @see https://ruby-doc.org/stdlib/libdoc/pp/rdoc/PP.html
-      def pretty_print(printer)
-        printer.text(inspect)
+      def pretty_print(*)
+        inspect
       end
 
       # Returns true if responds to the given method.

data/lib/hanami/utils/files.rb

@@ -0,0 +1,384 @@
+require "pathname"
+require "fileutils"
+
+module Hanami
+  module Utils
+    # Files utilities
+    #
+    # @since 1.1.0
+    module Files # rubocop:disable Metrics/ModuleLength
+      # Creates an empty file for the given path.
+      # All the intermediate directories are created.
+      # If the path already exists, it doesn't change the contents
+      #
+      # @param path [String,Pathname] the path to file
+      #
+      # @since 1.1.0
+      def self.touch(path)
+        write(path, "")
+      end
+
+      # Creates a new file for the given path and content.
+      # All the intermediate directories are created.
+      # If the path already exists, it appends the contents.
+      #
+      # @param path [String,Pathname] the path to file
+      # @param content [String, Array<String>] the content to write
+      #
+      # @since 1.1.0
+      def self.write(path, *content)
+        mkdir_p(path)
+        open(path, ::File::CREAT | ::File::WRONLY, *content)
+      end
+
+      # Rewrites the contents of an existing file.
+      # If the path already exists, it replaces the contents.
+      #
+      # @param path [String,Pathname] the path to file
+      # @param content [String, Array<String>] the content to write
+      #
+      # @raise [Errno::ENOENT] if the path doesn't exist
+      #
+      # @since 1.1.0
+      def self.rewrite(path, *content)
+        open(path, ::File::TRUNC | ::File::WRONLY, *content)
+      end
+
+      # Copies source into destination.
+      # All the intermediate directories are created.
+      # If the destination already exists, it overrides the contents.
+      #
+      # @param source [String,Pathname] the path to the source file
+      # @param destination [String,Pathname] the path to the destination file
+      #
+      # @since 1.1.0
+      def self.cp(source, destination)
+        mkdir_p(destination)
+        FileUtils.cp(source, destination)
+      end
+
+      # Creates a directory for the given path.
+      # It assumes that all the tokens in `path` are meant to be a directory.
+      # All the intermediate directories are created.
+      #
+      # @param path [String,Pathname] the path to directory
+      #
+      # @since 1.1.0
+      #
+      # @see .mkdir_p
+      #
+      # @example
+      #   require "hanami/utils/files"
+      #
+      #   Hanami::Utils::Files.mkdir("path/to/directory")
+      #     # => creates the `path/to/directory` directory
+      #
+      #   # WRONG this isn't probably what you want, check `.mkdir_p`
+      #   Hanami::Utils::Files.mkdir("path/to/file.rb")
+      #     # => creates the `path/to/file.rb` directory
+      def self.mkdir(path)
+        FileUtils.mkdir_p(path)
+      end
+
+      # Creates a directory for the given path.
+      # It assumes that all the tokens, but the last, in `path` are meant to be
+      # a directory, whereas the last is meant to be a file.
+      # All the intermediate directories are created.
+      #
+      # @param path [String,Pathname] the path to directory
+      #
+      # @since 1.1.0
+      #
+      # @see .mkdir
+      #
+      # @example
+      #   require "hanami/utils/files"
+      #
+      #   Hanami::Utils::Files.mkdir_p("path/to/file.rb")
+      #     # => creates the `path/to` directory, but NOT `file.rb`
+      #
+      #   # WRONG it doesn't create the last directory, check `.mkdir`
+      #   Hanami::Utils::Files.mkdir_p("path/to/directory")
+      #     # => creates the `path/to` directory
+      def self.mkdir_p(path)
+        Pathname.new(path).dirname.mkpath
+      end
+
+      # Deletes given path (file).
+      #
+      # @param path [String,Pathname] the path to file
+      #
+      # @raise [Errno::ENOENT] if the path doesn't exist
+      #
+      # @since 1.1.0
+      def self.delete(path)
+        FileUtils.rm(path)
+      end
+
+      # Deletes given path (directory).
+      #
+      # @param path [String,Pathname] the path to file
+      #
+      # @raise [Errno::ENOENT] if the path doesn't exist
+      #
+      # @since 1.1.0
+      def self.delete_directory(path)
+        FileUtils.remove_entry_secure(path)
+      end
+
+      # Adds a new line at the top of the file
+      #
+      # @param path [String,Pathname] the path to file
+      # @param line [String] the line to add
+      #
+      # @raise [Errno::ENOENT] if the path doesn't exist
+      #
+      # @see .append
+      #
+      # @since 1.1.0
+      def self.unshift(path, line)
+        content = ::File.readlines(path)
+        content.unshift("#{line}\n")
+
+        rewrite(path, content)
+      end
+
+      # Adds a new line at the bottom of the file
+      #
+      # @param path [String,Pathname] the path to file
+      # @param contents [String] the contents to add
+      #
+      # @raise [Errno::ENOENT] if the path doesn't exist
+      #
+      # @see .unshift
+      #
+      # @since 1.1.0
+      def self.append(path, contents)
+        mkdir_p(path)
+
+        content = ::File.readlines(path)
+        content << "#{contents}\n"
+
+        rewrite(path, content)
+      end
+
+      # Replace first line in `path` that contains `target` with `replacement`.
+      #
+      # @param path [String,Pathname] the path to file
+      # @param target [String,Regexp] the target to replace
+      # @param replacement [String] the replacement
+      #
+      # @raise [Errno::ENOENT] if the path doesn't exist
+      # @raise [ArgumentError] if `target` cannot be found in `path`
+      #
+      # @see .replace_last_line
+      #
+      # @since 1.1.0
+      def self.replace_first_line(path, target, replacement)
+        content = ::File.readlines(path)
+        content[index(content, path, target)] = "#{replacement}\n"
+
+        rewrite(path, content)
+      end
+
+      # Replace last line in `path` that contains `target` with `replacement`.
+      #
+      # @param path [String,Pathname] the path to file
+      # @param target [String,Regexp] the target to replace
+      # @param replacement [String] the replacement
+      #
+      # @raise [Errno::ENOENT] if the path doesn't exist
+      # @raise [ArgumentError] if `target` cannot be found in `path`
+      #
+      # @see .replace_first_line
+      #
+      # @since 1.1.0
+      def self.replace_last_line(path, target, replacement)
+        content = ::File.readlines(path)
+        content[-index(content.reverse, path, target) - 1] = "#{replacement}\n"
+
+        rewrite(path, content)
+      end
+
+      # Inject `contents` in `path` before `target`.
+      #
+      # @param path [String,Pathname] the path to file
+      # @param target [String,Regexp] the target to replace
+      # @param contents [String] the contents to inject
+      #
+      # @raise [Errno::ENOENT] if the path doesn't exist
+      # @raise [ArgumentError] if `target` cannot be found in `path`
+      #
+      # @see .inject_line_after
+      #
+      # @since 1.1.0
+      def self.inject_line_before(path, target, contents)
+        content = ::File.readlines(path)
+        i       = index(content, path, target)
+
+        content.insert(i, "#{contents}\n")
+        rewrite(path, content)
+      end
+
+      # Inject `contents` in `path` after `target`.
+      #
+      # @param path [String,Pathname] the path to file
+      # @param target [String,Regexp] the target to replace
+      # @param contents [String] the contents to inject
+      #
+      # @raise [Errno::ENOENT] if the path doesn't exist
+      # @raise [ArgumentError] if `target` cannot be found in `path`
+      #
+      # @see .inject_line_before
+      #
+      # @since 1.1.0
+      def self.inject_line_after(path, target, contents)
+        content = ::File.readlines(path)
+        i       = index(content, path, target)
+
+        content.insert(i + 1, "#{contents}\n")
+        rewrite(path, content)
+      end
+
+      # Removes line from `path`, matching `target`.
+      #
+      # @param path [String,Pathname] the path to file
+      # @param target [String,Regexp] the target to remove
+      #
+      # @raise [Errno::ENOENT] if the path doesn't exist
+      # @raise [ArgumentError] if `target` cannot be found in `path`
+      #
+      # @since 1.1.0
+      def self.remove_line(path, target)
+        content = ::File.readlines(path)
+        i       = index(content, path, target)
+
+        content.delete_at(i)
+        rewrite(path, content)
+      end
+
+      # Removes `target` block from `path`
+      #
+      # @param path [String,Pathname] the path to file
+      # @param target [String] the target block to remove
+      #
+      # @raise [Errno::ENOENT] if the path doesn't exist
+      # @raise [ArgumentError] if `target` cannot be found in `path`
+      #
+      # @since 1.1.0
+      #
+      # @example
+      #   require "hanami/utils/files"
+      #
+      #   puts File.read("app.rb")
+      #
+      #   # class App
+      #   #   configure do
+      #   #     root __dir__
+      #   #   end
+      #   # end
+      #
+      #   Hanami::Utils::Files.remove_block("app.rb", "configure")
+      #
+      #   puts File.read("app.rb")
+      #
+      #   # class App
+      #   # end
+      def self.remove_block(path, target) # rubocop:disable Metrics/AbcSize
+        content  = ::File.readlines(path)
+        starting = index(content, path, target)
+        line     = content[starting]
+        size     = line[/\A[[:space:]]*/].bytesize
+        closing  = (" " * size) + (target =~ /{/ ? '}' : 'end')
+        ending   = starting + index(content[starting..-1], path, closing)
+
+        content.slice!(starting..ending)
+        rewrite(path, content)
+
+        remove_block(path, target) if match?(content, target)
+      end
+
+      # Checks if `path` exist
+      #
+      # @param path [String,Pathname] the path to file
+      #
+      # @return [TrueClass,FalseClass] the result of the check
+      #
+      # @since 1.1.0
+      #
+      # @example
+      #   require "hanami/utils/files"
+      #
+      #   Hanami::Utils::Files.exist?(__FILE__) # => true
+      #   Hanami::Utils::Files.exist?(__dir__)  # => true
+      #
+      #   Hanami::Utils::Files.exist?("missing_file") # => false
+      def self.exist?(path)
+        File.exist?(path)
+      end
+
+      # Checks if `path` is a directory
+      #
+      # @param path [String,Pathname] the path to directory
+      #
+      # @return [TrueClass,FalseClass] the result of the check
+      #
+      # @since 1.1.0
+      #
+      # @example
+      #   require "hanami/utils/files"
+      #
+      #   Hanami::Utils::Files.directory?(__dir__)  # => true
+      #   Hanami::Utils::Files.directory?(__FILE__) # => false
+      #
+      #   Hanami::Utils::Files.directory?("missing_directory") # => false
+      def self.directory?(path)
+        File.directory?(path)
+      end
+
+      # private
+
+      # @since 1.1.0
+      # @api private
+      def self.match?(content, target)
+        !line_number(content, target).nil?
+      end
+
+      private_class_method :match?
+
+      # @since 1.1.0
+      # @api private
+      def self.open(path, mode, *content)
+        ::File.open(path, mode) do |file|
+          file.write(Array(content).flatten.join)
+        end
+      end
+
+      private_class_method :open
+
+      # @since 1.1.0
+      # @api private
+      def self.index(content, path, target)
+        line_number(content, target) or
+          raise ArgumentError.new("Cannot find `#{target}' inside `#{path}'.")
+      end
+
+      private_class_method :index
+
+      # @since 1.1.0
+      # @api private
+      def self.line_number(content, target)
+        content.index do |l|
+          case target
+          when ::String
+            l.include?(target)
+          when Regexp
+            l =~ target
+          end
+        end
+      end
+
+      private_class_method :line_number
+    end
+  end
+end

data/lib/hanami/utils/hash.rb

@@ -1,3 +1,5 @@
+# rubocop:disable ClassLength
+
 require 'hanami/utils/duplicable'
 require 'transproc'
 
@@ -206,6 +208,7 @@ module Hanami
       #
       #   hash.keys    # => [:a, :b]
       #   hash.inspect # => {"a"=>23, "b"=>{"c"=>["x", "y", "z"]}}
+
       def stringify!
         keys.each do |k|
           v = delete(k)
@@ -217,6 +220,10 @@ module Hanami
         self
       end
 
+      def self.stringify(input)
+        self[:stringify_keys].call(input)
+      end
+
       # Return a deep copy of the current Hanami::Utils::Hash
       #
       # @return [Hash] a deep duplicated self

data/lib/hanami/utils/inflector.rb

@@ -226,8 +226,7 @@ module Hanami
         'police'      => 'police',
         # regressions
         # https://github.com/hanami/utils/issues/106
-        'album'       => 'albums',
-        'area'        => 'areas'
+        'album'       => 'albums'
       )
 
       # Irregular rules for singulars
@@ -268,11 +267,8 @@ module Hanami
         'species'     => 'species',
         'police'      => 'police',
         # fallback
-        'areas'       => 'area',
         'hives'       => 'hive',
-        'phases'      => 'phase',
-        'exercises'   => 'exercise',
-        'releases'    => 'release'
+        'phases'      => 'phase'
       )
 
       # Block for custom inflection rules.

data/lib/hanami/utils/string.rb

@@ -1,4 +1,6 @@
 require 'hanami/utils/inflector'
+require 'transproc'
+require 'concurrent/map'
 
 module Hanami
   module Utils
@@ -72,6 +74,314 @@ module Hanami
       # @api private
       CLASSIFY_WORD_SEPARATOR = /#{CLASSIFY_SEPARATOR}|#{NAMESPACE_SEPARATOR}|#{UNDERSCORE_SEPARATOR}|#{DASHERIZE_SEPARATOR}/
 
+      @__transformations__ = Concurrent::Map.new
+
+      extend Transproc::Registry
+      extend Transproc::Composer
+
+      # Apply the given transformation(s) to `input`
+      #
+      # It performs a pipeline of transformations, by applying the given functions from `Hanami::Utils::String` and `::String`.
+      # The transformations are applied in the given order.
+      #
+      # It doesn't mutate the input, unless you use destructive methods from `::String`
+      #
+      # @param input [::String] the string to be transformed
+      # @param transformations [Array<Symbol,Proc,Array>] one or many
+      #   transformations expressed as:
+      #     * `Symbol` to reference a function from `Hanami::Utils::String` or `String`.
+      #     * `Proc` an anonymous function that MUST accept one input
+      #     * `Array` where the first element is a `Symbol` to reference a
+      #       function from `Hanami::Utils::String` or `String` and the rest of
+      #       the elements are the arguments to pass
+      #
+      # @return [::String] the result of the transformations
+      #
+      # @raise [NoMethodError] if a `Hanami::Utils::String` and `::String`
+      #   don't respond to a given method name
+      #
+      # @raise [ArgumentError] if a Proc transformation has an arity not equal
+      #   to 1
+      #
+      # @since 1.1.0
+      #
+      # @example Basic usage
+      #   require "hanami/utils/string"
+      #
+      #   Hanami::Utils::String.transform("hanami/utils", :underscore, :classify)
+      #     # => "Hanami::Utils"
+      #
+      #   Hanami::Utils::String.transform("Hanami::Utils::String", [:gsub, /[aeiouy]/, "*"], :demodulize)
+      #     # => "H*n*m*"
+      #
+      #   Hanami::Utils::String.transform("Hanami", ->(s) { s.upcase })
+      #     # => "HANAMI"
+      #
+      # @example Unkown transformation
+      #   require "hanami/utils/string"
+      #
+      #   Hanami::Utils::String.transform("Sakura", :foo)
+      #     # => NoMethodError: undefined method `:foo' for "Sakura":String
+      #
+      # @example Proc with arity not equal to 1
+      #   require "hanami/utils/string"
+      #
+      #   Hanami::Utils::String.transform("Cherry", -> { "blossom" }))
+      #     # => ArgumentError: wrong number of arguments (given 1, expected 0)
+      #
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/AbcSize
+      def self.transform(input, *transformations)
+        fn = @__transformations__.fetch_or_store(transformations.hash) do
+          compose do |fns|
+            transformations.each do |transformation, *args|
+              fns << if transformation.is_a?(Proc)
+                       transformation
+                     elsif contain?(transformation)
+                       self[transformation, *args]
+                     elsif input.respond_to?(transformation)
+                       t(:bind, input, ->(i) { i.public_send(transformation, *args) })
+                     else
+                       raise NoMethodError.new(%(undefined method `#{transformation.inspect}' for #{input.inspect}:#{input.class}))
+                     end
+            end
+          end
+        end
+
+        fn.call(input)
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+
+      # Extracted from `transproc` source code
+      #
+      # `transproc` is Copyright 2014 by Piotr Solnica (piotr.solnica@gmail.com),
+      # released under the MIT License
+      #
+      # @since 1.1.0
+      # @api private
+      def self.bind(value, binding, fn)
+        binding.instance_exec(value, &fn)
+      end
+
+      # Return a titleized version of the string
+      #
+      # @param input [::String] the input
+      #
+      # @return [::String] the transformed string
+      #
+      # @since 1.1.0
+      #
+      # @example
+      #   require 'hanami/utils/string'
+      #
+      #   Hanami::Utils::String.titleize('hanami utils') # => "Hanami Utils"
+      def self.titleize(input)
+        string = ::String.new(input.to_s)
+        underscore(string).split(CLASSIFY_SEPARATOR).map(&:capitalize).join(TITLEIZE_SEPARATOR)
+      end
+
+      # Return a capitalized version of the string
+      #
+      # @param input [::String] the input
+      #
+      # @return [::String] the transformed string
+      #
+      # @since 1.1.0
+      #
+      # @example
+      #   require 'hanami/utils/string'
+      #
+      #   Hanami::Utils::String.capitalize('hanami') # => "Hanami"
+      #
+      #   Hanami::Utils::String.capitalize('hanami utils') # => "Hanami utils"
+      #
+      #   Hanami::Utils::String.capitalize('Hanami Utils') # => "Hanami utils"
+      #
+      #   Hanami::Utils::String.capitalize('hanami_utils') # => "Hanami utils"
+      #
+      #   Hanami::Utils::String.capitalize('hanami-utils') # => "Hanami utils"
+      def self.capitalize(input)
+        string = ::String.new(input.to_s)
+        head, *tail = underscore(string).split(CLASSIFY_SEPARATOR)
+
+        tail.unshift(head.capitalize).join(CAPITALIZE_SEPARATOR)
+      end
+
+      # Return a CamelCase version of the string
+      #
+      # @param input [::String] the input
+      #
+      # @return [String] the transformed string
+      #
+      # @since 1.1.0
+      #
+      # @example
+      #   require 'hanami/utils/string'
+      #
+      #   Hanami::Utils::String.classify('hanami_utils') # => 'HanamiUtils'
+      def self.classify(input)
+        string = ::String.new(input.to_s)
+        words = underscore(string).split(CLASSIFY_WORD_SEPARATOR).map!(&:capitalize)
+        delimiters = underscore(string).scan(CLASSIFY_WORD_SEPARATOR)
+
+        delimiters.map! do |delimiter|
+          delimiter == CLASSIFY_SEPARATOR ? EMPTY_STRING : NAMESPACE_SEPARATOR
+        end
+
+        words.zip(delimiters).join
+      end
+
+      # Return a downcased and underscore separated version of the string
+      #
+      # Revised version of `ActiveSupport::Inflector.underscore` implementation
+      # @see https://github.com/rails/rails/blob/feaa6e2048fe86bcf07e967d6e47b865e42e055b/activesupport/lib/active_support/inflector/methods.rb#L90
+      #
+      # @param input [::String] the input
+      #
+      # @return [String] the transformed string
+      #
+      # @since 1.1.0
+      #
+      # @example
+      #   require 'hanami/utils/string'
+      #
+      #   Hanami::Utils::String.underscore('HanamiUtils') # => 'hanami_utils'
+      def self.underscore(input)
+        string = ::String.new(input.to_s)
+        string.gsub!(NAMESPACE_SEPARATOR, UNDERSCORE_SEPARATOR)
+        string.gsub!(NAMESPACE_SEPARATOR, UNDERSCORE_SEPARATOR)
+        string.gsub!(/([A-Z\d]+)([A-Z][a-z])/, UNDERSCORE_DIVISION_TARGET)
+        string.gsub!(/([a-z\d])([A-Z])/, UNDERSCORE_DIVISION_TARGET)
+        string.gsub!(/[[:space:]]|\-/, UNDERSCORE_DIVISION_TARGET)
+        string.downcase
+      end
+
+      # Return a downcased and dash separated version of the string
+      #
+      # @param input [::String] the input
+      #
+      # @return [::String] the transformed string
+      #
+      # @since 1.1.0
+      #
+      # @example
+      #   require 'hanami/utils/string'
+      #
+      #   Hanami::Utils::String.dasherize('Hanami Utils') # => 'hanami-utils'
+
+      #   Hanami::Utils::String.dasherize('hanami_utils') # => 'hanami-utils'
+      #
+      #   Hanami::Utils::String.dasherize('HanamiUtils') # => "hanami-utils"
+      def self.dasherize(input)
+        string = ::String.new(input.to_s)
+        underscore(string).split(CLASSIFY_SEPARATOR).join(DASHERIZE_SEPARATOR)
+      end
+
+      # Return the string without the Ruby namespace of the class
+      #
+      # @param input [::String] the input
+      #
+      # @return [String] the transformed string
+      #
+      # @since 1.1.0
+      #
+      # @example
+      #   require 'hanami/utils/string'
+      #
+      #   Hanami::Utils::String.demodulize('Hanami::Utils::String') # => 'String'
+      #
+      #   Hanami::Utils::String.demodulize('String') # => 'String'
+      def self.demodulize(input)
+        ::String.new(input.to_s).split(NAMESPACE_SEPARATOR).last
+      end
+
+      # Return the top level namespace name
+      #
+      # @param input [::String] the input
+      #
+      # @return [String] the transformed string
+      #
+      # @since 1.1.0
+      #
+      # @example
+      #   require 'hanami/utils/string'
+      #
+      #   Hanami::Utils::String.namespace('Hanami::Utils::String') # => 'Hanami'
+      #
+      #   Hanami::Utils::String.namespace('String') # => 'String'
+      def self.namespace(input)
+        ::String.new(input.to_s).split(NAMESPACE_SEPARATOR).first
+      end
+
+      # Return a pluralized version of self.
+      #
+      # @param input [::String] the input
+      #
+      # @return [::String] the pluralized string.
+      #
+      # @since 1.1.0
+      #
+      # @see Hanami::Utils::Inflector
+      #
+      # @example
+      #   require 'hanami/utils/string'
+      #
+      #   Hanami::Utils::String.pluralize('book') # => 'books'
+      def self.pluralize(input)
+        string = ::String.new(input.to_s)
+        Inflector.pluralize(string)
+      end
+
+      # Return a singularized version of self.
+      #
+      # @param input [::String] the input
+      #
+      # @return [::String] the singularized string.
+      #
+      # @since 1.1.0
+      #
+      # @see Hanami::Utils::Inflector
+      #
+      # @example
+      #   require 'hanami/utils/string'
+      #
+      #   Hanami::Utils::String.singularize('books') # => 'book'
+      def self.singularize(input)
+        string = ::String.new(input.to_s)
+        Inflector.singularize(string)
+      end
+
+      # Replace the rightmost match of `pattern` with `replacement`
+      #
+      # If the pattern cannot be matched, it returns the original string.
+      #
+      # This method does NOT mutate the original string.
+      #
+      # @param input [::String] the input
+      # @param pattern [Regexp, ::String] the pattern to find
+      # @param replacement [String] the string to replace
+      #
+      # @return [::String] the replaced string
+      #
+      # @since 1.1.0
+      #
+      # @example
+      #   require 'hanami/utils/string'
+      #
+      #   Hanami::Utils::String.rsub('authors/books/index', %r{/}, '#')
+      #     # => 'authors/books#index'
+      def self.rsub(input, pattern, replacement)
+        string = ::String.new(input.to_s)
+        if i = string.rindex(pattern) # rubocop:disable Lint/AssignmentInCondition
+          s = string.dup
+          s[i] = replacement
+          s
+        else
+          string
+        end
+      end
+
       # Initialize the string
       #
       # @param string [::String, Symbol] the value we want to initialize
@@ -358,7 +668,7 @@ module Hanami
         @string.scan(pattern, &blk)
       end
 
-      # Replace the rightmost match of <tt>pattern</tt> with <tt>replacement</tt>
+      # Replace the rightmost match of `pattern` with `replacement`
       #
       # If the pattern cannot be matched, it returns the original string.
       #

data/lib/hanami/utils/version.rb

@@ -3,6 +3,6 @@ module Hanami
     # Defines the version
     #
     # @since 0.1.0
-    VERSION = '1.0.4'.freeze
+    VERSION = '1.1.0.beta1'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hanami-utils
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.1.0.beta1
 platform: ruby
 authors:
 - Luca Guidi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-02 00:00:00.000000000 Z
+date: 2017-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: transproc
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -90,6 +104,7 @@ files:
 - lib/hanami/utils/duplicable.rb
 - lib/hanami/utils/escape.rb
 - lib/hanami/utils/file_list.rb
+- lib/hanami/utils/files.rb
 - lib/hanami/utils/hash.rb
 - lib/hanami/utils/inflector.rb
 - lib/hanami/utils/io.rb
@@ -114,12 +129,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Ruby core extentions and Hanami utilities