hanami-utils 0.0.0 → 0.7.0

data/lib/hanami/utils/load_paths.rb

@@ -0,0 +1,167 @@
+require 'hanami/utils/kernel'
+
+module Hanami
+  module Utils
+    # A collection of loading paths.
+    #
+    # @since 0.2.0
+    class LoadPaths
+      # Initialize a new collection for the given paths
+      #
+      # @param paths [String, Pathname, Array<String>, Array<Pathname>] A single
+      #   or a collection of objects that can be converted into a Pathname
+      #
+      # @return [Hanami::Utils::LoadPaths] self
+      #
+      # @since 0.2.0
+      #
+      # @see http://ruby-doc.org/stdlib/libdoc/pathname/rdoc/Pathname.html
+      # @see Hanami::Utils::Kernel.Pathname
+      def initialize(*paths)
+        @paths = Utils::Kernel.Array(paths)
+      end
+
+      # It specifies the policy for initialize copies of the object, when #clone
+      # or #dup are invoked.
+      #
+      # @api private
+      # @since 0.2.0
+      #
+      # @see http://ruby-doc.org/core/Object.html#method-i-clone
+      # @see http://ruby-doc.org/core/Object.html#method-i-dup
+      #
+      # @example
+      #   require 'hanami/utils/load_paths'
+      #
+      #   paths  = Hanami::Utils::LoadPaths.new '.'
+      #   paths2 = paths.dup
+      #
+      #   paths  << '..'
+      #   paths2 << '../..'
+      #
+      #   paths
+      #     # => #<Hanami::Utils::LoadPaths:0x007f84e0cad430 @paths=[".", ".."]>
+      #
+      #   paths2
+      #     # => #<Hanami::Utils::LoadPaths:0x007faedc4ad3e0 @paths=[".", "../.."]>
+      def initialize_copy(original)
+        @paths = original.instance_variable_get(:@paths).dup
+      end
+
+      # Iterates thru the collection and yields the given block.
+      # It skips duplications and raises an error in case one of the paths
+      # doesn't exist.
+      #
+      # @yield [pathname] the block of code that acts on the collection
+      # @yieldparam pathname [Pathname]
+      #
+      # @return [void]
+      #
+      # @raise [Errno::ENOENT] if one of the paths doesn't exist
+      #
+      # @since 0.2.0
+      def each
+        @paths.each do |path|
+          yield realpath(path)
+        end
+      end
+
+      # Adds the given path(s).
+      #
+      # It returns self, so that multiple operations can be performed.
+      #
+      # @param paths [String, Pathname, Array<String>, Array<Pathname>] A single
+      #   or a collection of objects that can be converted into a Pathname
+      #
+      # @return [Hanami::Utils::LoadPaths] self
+      #
+      # @raise [RuntimeError] if the object was previously frozen
+      #
+      # @since 0.2.0
+      #
+      # @see http://ruby-doc.org/stdlib/libdoc/pathname/rdoc/Pathname.html
+      # @see Hanami::Utils::Kernel.Pathname
+      # @see Hanami::Utils::LoadPaths#freeze
+      #
+      # @example Basic usage
+      #   require 'hanami/utils/load_paths'
+      #
+      #   paths = Hanami::Utils::LoadPaths.new
+      #   paths.push '.'
+      #   paths.push '..', '../..'
+      #
+      # @example Chainable calls
+      #   require 'hanami/utils/load_paths'
+      #
+      #   paths = Hanami::Utils::LoadPaths.new
+      #   paths.push('.')
+      #        .push('..', '../..')
+      #
+      # @example Shovel alias (#<<)
+      #   require 'hanami/utils/load_paths'
+      #
+      #   paths = Hanami::Utils::LoadPaths.new
+      #   paths << '.'
+      #   paths << ['..', '../..']
+      #
+      # @example Chainable calls with shovel alias (#<<)
+      #   require 'hanami/utils/load_paths'
+      #
+      #   paths = Hanami::Utils::LoadPaths.new
+      #   paths << '.' << '../..'
+      def push(*paths)
+        @paths.push(*paths)
+        @paths = Kernel.Array(@paths)
+        self
+      end
+
+      alias_method :<<, :push
+
+      # It freezes the object by preventing further modifications.
+      #
+      # @since 0.2.0
+      #
+      # @see http://ruby-doc.org/core/Object.html#method-i-freeze
+      #
+      # @example
+      #   require 'hanami/utils/load_paths'
+      #
+      #   paths = Hanami::Utils::LoadPaths.new
+      #   paths.freeze
+      #
+      #   paths.frozen?  # => true
+      #
+      #   paths.push '.' # => RuntimeError
+      def freeze
+        super
+        @paths.freeze
+      end
+
+      # @since 0.6.0
+      # @api private
+      def ==(other)
+        case other
+        when self.class
+          other.paths == paths
+        else
+          other == paths
+        end
+      end
+
+      protected
+      # @since 0.6.0
+      # @api private
+      attr_reader :paths
+
+      private
+      # Allow subclasses to define their own policy to discover the realpath
+      # of the given path.
+      #
+      # @since 0.2.0
+      # @api private
+      def realpath(path)
+        Utils::Kernel.Pathname(path).realpath
+      end
+    end
+  end
+end

data/lib/hanami/utils/path_prefix.rb

@@ -0,0 +1,146 @@
+require 'hanami/utils/string'
+require 'hanami/utils/kernel'
+
+module Hanami
+  module Utils
+    # Prefixed string
+    #
+    # @since 0.1.0
+    class PathPrefix < Hanami::Utils::String
+      # Path separator
+      #
+      # @since 0.3.1
+      # @api private
+      DEFAULT_SEPARATOR = '/'.freeze
+
+      # Initialize the path prefix
+      #
+      # @param string [::String] the prefix value
+      # @param separator [::String] the separator used between tokens
+      #
+      # @return [PathPrefix] self
+      #
+      # @since 0.1.0
+      #
+      # @see Hanami::Utils::PathPrefix::DEFAULT_SEPARATOR
+      def initialize(string = nil, separator = DEFAULT_SEPARATOR)
+        super(string)
+        @separator = separator
+      end
+
+      # Joins self with the given token.
+      # It cleans up all the `separator` repetitions.
+      #
+      # @param strings [::String] the token(s) we want to join
+      #
+      # @return [Hanami::Utils::PathPrefix] the joined string
+      #
+      # @since 0.1.0
+      #
+      # @example Single string
+      #   require 'hanami/utils/path_prefix'
+      #
+      #   path_prefix = Hanami::Utils::PathPrefix.new('/posts')
+      #   path_prefix.join('new').to_s  # => "/posts/new"
+      #   path_prefix.join('/new').to_s # => "/posts/new"
+      #
+      #   path_prefix = Hanami::Utils::PathPrefix.new('posts')
+      #   path_prefix.join('new').to_s  # => "/posts/new"
+      #   path_prefix.join('/new').to_s # => "/posts/new"
+      #
+      # @example Multiple strings
+      #   require 'hanami/utils/path_prefix'
+      #
+      #   path_prefix = Hanami::Utils::PathPrefix.new('myapp')
+      #   path_prefix.join('/assets', 'application.js').to_s
+      #     # => "/myapp/assets/application.js"
+      def join(*strings)
+        relative_join(strings).absolute!
+      end
+
+      # Joins self with the given token, without prefixing it with `separator`.
+      # It cleans up all the `separator` repetitions.
+      #
+      # @param strings [::String] the tokens we want to join
+      # @param separator [::String] the separator used between tokens
+      #
+      # @return [Hanami::Utils::PathPrefix] the joined string
+      #
+      # @raise [TypeError] if one of the argument can't be treated as a
+      #   string
+      #
+      # @since 0.1.0
+      #
+      # @example
+      #   require 'hanami/utils/path_prefix'
+      #
+      #   path_prefix = Hanami::Utils::PathPrefix.new 'posts'
+      #   path_prefix.relative_join('new').to_s      # => 'posts/new'
+      #   path_prefix.relative_join('new', '_').to_s # => 'posts_new'
+      def relative_join(strings, separator = @separator)
+        raise TypeError if separator.nil?
+        prefix = @string.gsub(@separator, separator)
+        result = [prefix, strings]
+        result.flatten!
+        result.compact!
+        result.reject! {|string| string == separator }
+
+        self.class.new(
+          result.join(separator), separator
+        ).relative!
+      end
+
+      protected
+
+      # Modifies the path prefix to have a prepended separator.
+      #
+      # @return [self]
+      #
+      # @since 0.3.1
+      # @api private
+      #
+      # @see #absolute
+      def absolute!
+        @string.prepend(separator) unless absolute?
+
+        self
+      end
+
+      # Returns whether the path prefix starts with its separator.
+      #
+      # @return [TrueClass,FalseClass]
+      #
+      # @since 0.3.1
+      # @api private
+      #
+      # @example
+      #   require 'hanami/utils/path_prefix'
+      #
+      #   Hanami::Utils::PathPrefix.new('/posts').absolute? #=> true
+      #   Hanami::Utils::PathPrefix.new('posts').absolute?  #=> false
+      def absolute?
+        @string.start_with?(separator)
+      end
+
+      # Modifies the path prefix to remove the leading separator.
+      #
+      # @return [self]
+      #
+      # @since 0.3.1
+      # @api private
+      #
+      # @see #relative
+      def relative!
+        @string.gsub!(%r{(?<!:)#{ separator * 2 }}, separator)
+        @string.sub!(%r{\A#{ separator }}, '')
+
+        self
+      end
+
+      private
+      # @since 0.1.0
+      # @api private
+      attr_reader :separator
+    end
+  end
+end

data/lib/hanami/utils/string.rb

@@ -0,0 +1,419 @@
+require 'hanami/utils/inflector'
+
+module Hanami
+  module Utils
+    # String on steroids
+    #
+    # @since 0.1.0
+    class String
+      # Empty string for #classify
+      #
+      # @since 0.6.0
+      # @api private
+      EMPTY_STRING        = ''.freeze
+
+      # Separator between Ruby namespaces
+      #
+      # @since 0.1.0
+      # @api private
+      NAMESPACE_SEPARATOR = '::'.freeze
+
+      # Separator for #classify
+      #
+      # @since 0.3.0
+      # @api private
+      CLASSIFY_SEPARATOR  = '_'.freeze
+
+      # Regexp for #tokenize
+      #
+      # @since 0.3.0
+      # @api private
+      TOKENIZE_REGEXP     = /\((.*)\)/
+
+      # Separator for #tokenize
+      #
+      # @since 0.3.0
+      # @api private
+      TOKENIZE_SEPARATOR  = '|'.freeze
+
+      # Separator for #underscore
+      #
+      # @since 0.3.0
+      # @api private
+      UNDERSCORE_SEPARATOR = '/'.freeze
+
+      # gsub second parameter used in #underscore
+      #
+      # @since 0.3.0
+      # @api private
+      UNDERSCORE_DIVISION_TARGET  = '\1_\2'.freeze
+
+      # Separator for #titleize
+      #
+      # @since 0.4.0
+      # @api private
+      TITLEIZE_SEPARATOR = ' '.freeze
+
+      # Separator for #capitalize
+      #
+      # @since 0.5.2
+      # @api private
+      CAPITALIZE_SEPARATOR = ' '.freeze
+
+      # Separator for #dasherize
+      #
+      # @since 0.4.0
+      # @api private
+      DASHERIZE_SEPARATOR = '-'.freeze
+
+      # Regexp for #classify
+      #
+      # @since 0.3.4
+      # @api private
+      CLASSIFY_WORD_SEPARATOR = /#{CLASSIFY_SEPARATOR}|#{NAMESPACE_SEPARATOR}|#{UNDERSCORE_SEPARATOR}|#{DASHERIZE_SEPARATOR}/
+
+      # Initialize the string
+      #
+      # @param string [::String, Symbol] the value we want to initialize
+      #
+      # @return [String] self
+      #
+      # @since 0.1.0
+      def initialize(string)
+        @string = string.to_s
+      end
+
+      # Return a titleized version of the string
+      #
+      # @return [Hanami::Utils::String] the transformed string
+      #
+      # @since 0.4.0
+      #
+      # @example
+      #   require 'hanami/utils/string'
+      #
+      #   string = Hanami::Utils::String.new 'hanami utils'
+      #   string.titleize # => "Hanami Utils"
+      def titleize
+        self.class.new underscore.split(CLASSIFY_SEPARATOR).map(&:capitalize).join(TITLEIZE_SEPARATOR)
+      end
+
+      # Return a capitalized version of the string
+      #
+      # @return [Hanami::Utils::String] the transformed string
+      #
+      # @since 0.5.2
+      #
+      # @example
+      #   require 'hanami/utils/string'
+      #
+      #   string = Hanami::Utils::String.new 'hanami'
+      #   string.capitalize # => "Hanami"
+      #
+      #   string = Hanami::Utils::String.new 'hanami utils'
+      #   string.capitalize # => "Hanami utils"
+      #
+      #   string = Hanami::Utils::String.new 'Hanami Utils'
+      #   string.capitalize # => "Hanami utils"
+      #
+      #   string = Hanami::Utils::String.new 'hanami_utils'
+      #   string.capitalize # => "Hanami utils"
+      #
+      #   string = Hanami::Utils::String.new 'hanami-utils'
+      #   string.capitalize # => "Hanami utils"
+      def capitalize
+        head, *tail = underscore.split(CLASSIFY_SEPARATOR)
+
+        self.class.new(
+          tail.unshift(head.capitalize).join(CAPITALIZE_SEPARATOR)
+        )
+      end
+
+      # Return a CamelCase version of the string
+      #
+      # @return [String] the transformed string
+      #
+      # @since 0.1.0
+      #
+      # @example
+      #   require 'hanami/utils/string'
+      #
+      #   string = Hanami::Utils::String.new 'hanami_utils'
+      #   string.classify # => 'HanamiUtils'
+      def classify
+        words = split(CLASSIFY_WORD_SEPARATOR).map!(&:capitalize)
+        delimiters = scan(CLASSIFY_WORD_SEPARATOR)
+
+        delimiters.map! do |delimiter|
+          delimiter == CLASSIFY_SEPARATOR ? EMPTY_STRING : NAMESPACE_SEPARATOR
+        end
+
+        self.class.new 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
+      #
+      # @return [String] the transformed string
+      #
+      # @since 0.1.0
+      #
+      # @example
+      #   require 'hanami/utils/string'
+      #
+      #   string = Hanami::Utils::String.new 'HanamiUtils'
+      #   string.underscore # => 'hanami_utils'
+      def underscore
+        new_string = gsub(NAMESPACE_SEPARATOR, UNDERSCORE_SEPARATOR)
+        new_string.gsub!(/([A-Z\d]+)([A-Z][a-z])/, UNDERSCORE_DIVISION_TARGET)
+        new_string.gsub!(/([a-z\d])([A-Z])/, UNDERSCORE_DIVISION_TARGET)
+        new_string.gsub!(/[[:space:]]|\-/, UNDERSCORE_DIVISION_TARGET)
+        new_string.downcase!
+        self.class.new new_string
+      end
+
+      # Return a downcased and dash separated version of the string
+      #
+      # @return [Hanami::Utils::String] the transformed string
+      #
+      # @since 0.4.0
+      #
+      # @example
+      #   require 'hanami/utils/string'
+      #
+      #   string = Hanami::Utils::String.new 'Hanami Utils'
+      #   string.dasherize # => 'hanami-utils'
+      #
+      #   string = Hanami::Utils::String.new 'hanami_utils'
+      #   string.dasherize # => 'hanami-utils'
+      #
+      #   string = Hanami::Utils::String.new 'HanamiUtils'
+      #   string.dasherize # => "hanami-utils"
+      def dasherize
+        self.class.new underscore.split(CLASSIFY_SEPARATOR).join(DASHERIZE_SEPARATOR)
+      end
+
+      # Return the string without the Ruby namespace of the class
+      #
+      # @return [String] the transformed string
+      #
+      # @since 0.1.0
+      #
+      # @example
+      #   require 'hanami/utils/string'
+      #
+      #   string = Hanami::Utils::String.new 'Hanami::Utils::String'
+      #   string.demodulize # => 'String'
+      #
+      #   string = Hanami::Utils::String.new 'String'
+      #   string.demodulize # => 'String'
+      def demodulize
+        self.class.new split(NAMESPACE_SEPARATOR).last
+      end
+
+      # Return the top level namespace name
+      #
+      # @return [String] the transformed string
+      #
+      # @since 0.1.2
+      #
+      # @example
+      #   require 'hanami/utils/string'
+      #
+      #   string = Hanami::Utils::String.new 'Hanami::Utils::String'
+      #   string.namespace # => 'Hanami'
+      #
+      #   string = Hanami::Utils::String.new 'String'
+      #   string.namespace # => 'String'
+      def namespace
+        self.class.new split(NAMESPACE_SEPARATOR).first
+      end
+
+      # It iterates through the tokens and calls the given block.
+      # A token is a substring wrapped by `()` and separated by `|`.
+      #
+      # @yield the block that is called for each token.
+      #
+      # @return [void]
+      #
+      # @since 0.1.0
+      #
+      # @example
+      #   require 'hanami/utils/string'
+      #
+      #   string = Hanami::Utils::String.new 'Hanami::(Utils|App)'
+      #   string.tokenize do |token|
+      #     puts token
+      #   end
+      #
+      #   # =>
+      #     'Hanami::Utils'
+      #     'Hanami::App'
+      def tokenize
+        if match = TOKENIZE_REGEXP.match(@string)
+          pre, post = match.pre_match, match.post_match
+          tokens = match[1].split(TOKENIZE_SEPARATOR)
+          tokens.each do |token|
+            yield(self.class.new("#{pre}#{token}#{post}"))
+          end
+        else
+          yield(self.class.new(@string))
+        end
+
+        nil
+      end
+
+      # Return a pluralized version of self.
+      #
+      # @return [Hanami::Utils::String] the pluralized string.
+      #
+      # @api private
+      # @since 0.4.1
+      #
+      # @see Hanami::Utils::Inflector
+      def pluralize
+        self.class.new Inflector.pluralize(self)
+      end
+
+      # Return a singularized version of self.
+      #
+      # @return [Hanami::Utils::String] the singularized string.
+      #
+      # @api private
+      # @since 0.4.1
+      #
+      # @see Hanami::Utils::Inflector
+      def singularize
+        self.class.new Inflector.singularize(self)
+      end
+
+      # Returns the hash of the internal string
+      #
+      # @return [Fixnum]
+      #
+      # @since 0.3.0
+      def hash
+        @string.hash
+      end
+
+      # Returns a string representation
+      #
+      # @return [String]
+      #
+      # @since 0.3.0
+      def to_s
+        @string
+      end
+
+      alias_method :to_str,  :to_s
+
+      # Equality
+      #
+      # @return [TrueClass,FalseClass]
+      #
+      # @since 0.3.0
+      def ==(other)
+        to_s == other
+      end
+
+      alias_method :eql?, :==
+
+      # Split the string with the given pattern
+      #
+      # @return [Array<String>]
+      #
+      # @see http://www.ruby-doc.org/core/String.html#method-i-split
+      #
+      # @since 0.3.0
+      def split(pattern, limit = 0)
+        @string.split(pattern, limit)
+      end
+
+      # Replace the given pattern with the given replacement
+      #
+      # @return [String,nil]
+      #
+      # @see http://www.ruby-doc.org/core/String.html#method-i-gsub
+      #
+      # @since 0.3.0
+      def gsub(pattern, replacement = nil, &blk)
+        if block_given?
+          @string.gsub(pattern, &blk)
+        else
+          @string.gsub(pattern, replacement)
+        end
+      end
+
+      # Both forms iterate through str, matching the pattern
+      #
+      # @return [String,nil]
+      #
+      # @see http://www.ruby-doc.org/core/String.html#method-i-scan
+      #
+      # @since 0.6.0
+      def scan(pattern, &blk)
+        @string.scan(pattern, &blk)
+      end
+
+      # Replace the rightmost match of <tt>pattern</tt> with <tt>replacement</tt>
+      #
+      # If the pattern cannot be matched, it returns the original string.
+      #
+      # This method does NOT mutate the original string.
+      #
+      # @param pattern [Regexp, String] the pattern to find
+      # @param replacement [String, Hanami::Utils::String] the string to replace
+      #
+      # @return [Hanami::Utils::String] the replaced string
+      #
+      # @since 0.6.0
+      #
+      # @example
+      #   require 'hanami/utils/string'
+      #
+      #   string = Hanami::Utils::String.new('authors/books/index')
+      #   result = string.rsub(/\//, '#')
+      #
+      #   puts string
+      #     # => #<Hanami::Utils::String:0x007fdb41233ad8 @string="authors/books/index">
+      #
+      #   puts result
+      #     # => #<Hanami::Utils::String:0x007fdb41232ed0 @string="authors/books#index">
+      def rsub(pattern, replacement)
+        if i = rindex(pattern)
+          s    = @string.dup
+          s[i] = replacement
+          self.class.new s
+        else
+          self
+        end
+      end
+
+      # Override Ruby's method_missing in order to provide ::String interface
+      #
+      # @api private
+      # @since 0.3.0
+      #
+      # @raise [NoMethodError] If doesn't respond to the given method
+      def method_missing(m, *args, &blk)
+        if respond_to?(m)
+          s = @string.__send__(m, *args, &blk)
+          s = self.class.new(s) if s.is_a?(::String)
+          s
+        else
+          raise NoMethodError.new(%(undefined method `#{ m }' for "#{ @string }":#{ self.class }))
+        end
+      end
+
+      # Override Ruby's respond_to_missing? in order to support ::String interface
+      #
+      # @api private
+      # @since 0.3.0
+      def respond_to_missing?(m, include_private=false)
+        @string.respond_to?(m, include_private)
+      end
+    end
+  end
+end