tzispa_utils 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 03d766019c0461759e3125672a0a7b29de48292e
-  data.tar.gz: 7e038be0727063d8744efa11654b7309ffa1dacf
+  metadata.gz: ca4b92f6f0b683404de7f1cc52994ddf93999cf4
+  data.tar.gz: 83300a6e5917346f27cda41d471ff7f4f1e719c6
 SHA512:
-  metadata.gz: 3cb6386b173141f9d580a77af4f05f4ee9d6f3377d1529fecc3954d0bcfe449b82499bd58ca27568fd923f587d542640227278098bf2ceffa200d17c293c36d8
-  data.tar.gz: 119ca9321417f2378f4b5fcfa5b8c61267b0f1f7d50292cb68ee43edd512df462bb0d30f250a0fe75064d0fed27c3e808f62aa81889d0be9332ac6bbb4f51d73
+  metadata.gz: 2968a00cffa40a2afb2ac0b7155753b10eb1edc999afd1aacb6331b889cc5b1a6bda01a40064507688c32631fac820aec44e017fe37e7554b9340b0aff157886
+  data.tar.gz: 830b03732abc7ceabca1dd9c3006e427015cd96cfd04422b28fa182e395fcf3d4ae45f5cae913351f8a6a25374231759c10491512db4fe72087d4ccadf15e6af

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 Tzispa Utils
 
+## v0.3.2
+- bug fixes
+- added tests for hash refinements
+- added mail class utility
+
 ## v0.3.1
 - added Hash refinement
 

data/lib/tzispa/utils/decorator.rb

@@ -1,16 +1,19 @@
+# frozen_string_literal: true
+
 module Tzispa
   module Utils
 
     class Decorator < SimpleDelegator
+      attr_reader :component
 
-      def component
-        @component ||= __getobj__
+      def initialize(component)
+        @component = component
+        super
       end
 
       def cclass
-        component.class
+        @component.class
       end
-
     end
 
   end

data/lib/tzispa/utils/duplicable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Tzispa
   module Utils
     module Duplicable
@@ -12,7 +14,7 @@ module Tzispa
           value.dup
         end
       end
-      
+
     end
   end
-end
+end

data/lib/tzispa/utils/hash.rb

@@ -1,57 +1,90 @@
+# frozen_string_literal: true
+
 require 'tzispa/utils/duplicable'
 
 module Tzispa
   module Utils
+    module TzHash
 
-    DUPLICATE_LOGIC = proc do |value|
-      case value
-      when Hash
-        value.deep_dup
-      when ::Hash
-        Hash.new(value).deep_dup.to_h
-      end
-    end.freeze
+      DUPLICATE_LOGIC = proc do |value|
+        case value
+        when Hash
+          value.deep_dup
+        when ::Hash
+          Hash.new(value).deep_dup.to_h
+        end
+      end.freeze
+
+      refine ::Hash do
+        def symbolize
+          dup.tap(&:symbolize!)
+        end
 
-    refine Hash do
+        def symbolize!
+          keys.each do |k|
+            v = delete(k)
+            self[k.to_sym] = v
+          end
 
-      def symbolize!
-        keys.each do |k|
-          v = delete(k)
-          self[k.to_sym] = v
+          self
         end
 
-        self
-      end
+        def deep_symbolize
+          dup.tap do |hsh|
+            hsh.keys.each do |k|
+              v = hsh.delete(k)
+              v = v.dup.deep_symbolize if v.respond_to?(:to_hash)
+
+              hsh[k.to_sym] = v
+            end
+          end
+        end
 
-      def deep_symbolize!
-        keys.each do |k|
-          v = delete(k)
-          v = self.class.new(v).deep_symbolize! if v.respond_to?(:to_hash)
+        def deep_symbolize!
+          keys.each do |k|
+            v = delete(k)
+            v = v.deep_symbolize! if v.respond_to?(:to_hash)
 
-          self[k.to_sym] = v
+            self[k.to_sym] = v
+          end
+
+          self
         end
 
-        self
-      end
+        def stringify
+          dup.tap(&:stringify!)
+        end
+
+        def stringify!
+          keys.each do |k|
+            v = delete(k)
+            v = self.class.new(v).stringify! if v.respond_to?(:to_hash)
 
-      def stringify!
-        keys.each do |k|
-          v = delete(k)
-          v = self.class.new(v).stringify! if v.respond_to?(:to_hash)
+            self[k.to_s] = v
+          end
 
-          self[k.to_s] = v
+          self
         end
 
-        self
-      end
+        def tuplify
+          [].tap do |tp|
+            each do |k, v|
+              if v.respond_to? :each
+                v.each { |w| tp << [k, w] }
+              else
+                tp << [k, v]
+              end
+            end
+          end
+        end
 
-      def deep_dup
-        self.class.new.tap do |result|
-          @hash.each { |k, v| result[k] = Duplicable.dup(v, &DUPLICATE_LOGIC) }
+        def deep_dup
+          self.class.new.tap do |result|
+            @hash.each { |k, v| result[k] = Duplicable.dup(v, &DUPLICATE_LOGIC) }
+          end
         end
       end
 
     end
-
   end
 end

data/lib/tzispa/utils/indenter.rb

@@ -1,24 +1,29 @@
+# frozen_string_literal: true
+
 require 'tzispa/utils/string'
 
 module Tzispa
   module Utils
 
     class Indenter
-      using Tzispa::Utils
+      using Tzispa::Utils::TzString
 
       DEFAULT_INDENT_CHAR = ' '
+      DEFAULT_INDENT_SIZE = 2
 
       attr_reader :sbuff, :indent_char, :instr
 
-      def initialize(indent_size, indent_char=DEFAULT_INDENT_CHAR)
-        @indent_size = indent_size
+      def initialize(indent_size = nil, indent_char = nil)
+        @indent_size = indent_size || DEFAULT_INDENT_SIZE
         @indent_current = 0
-        @indent_char = indent_char
+        @indent_char = indent_char || DEFAULT_INDENT_CHAR
         @instr = String.new
       end
 
-      def <<(str)
-        @instr << String.indentize(str, @indent_current, @indent_char)
+      def <<(item)
+        ss = item.to_s.indentize(@indent_current, @indent_char)
+        @instr.concat ss
+
         self
       end
 
@@ -28,16 +33,19 @@ module Tzispa
 
       def indent
         @indent_current += @indent_size
+
         self
       end
 
       def unindent
-        @indent_current -= @indent_size if @indent_current-@indent_size >= 0
-        @indent_current = 0 if @indent_current-@indent_size < 0
+        if (@indent_current - @indent_size).positive?
+          @indent_current -= @indent_size
+        else
+          @indent_current = 0
+        end
+
         self
       end
-
-
     end
 
   end

data/lib/tzispa/utils/integer.rb

@@ -1,30 +1,38 @@
-require 'i18n'
-require 'sanitize'
-require 'escape_utils'
+# frozen_string_literal: true
+
 require 'i18n'
 
 module Tzispa
   module Utils
+    module TzInteger
+
+      refine ::Integer do
+        def to_filesize(precission = 1, sep = nil)
+          units, qty = __i18n_filesize
+          ns = (to_f / (qty / 1024)).round(precission).to_s.split('.')
+          ns.pop if ns.last.to_i.zero?
+          __nu_format(ns.join(sep || I18n.t('number.format.separator', default: '.')),
+                      units)
+        end
 
-    refine Integer do
+        def __nu_format(number, units)
+          I18n.t('number.human.storage_units.format', default: '%n %u')
+              .sub('%n', number)
+              .sub('%u', units)
+        end
 
-      def to_filesize(precission=1)
-        fsz = {
-          I18n.t('number.human.storage_units.byte.other', default: 'Bytes')  => 1024,
-          I18n.t('number.human.storage_units.kb', default: 'KB')             => 1024 * 1024,
-          I18n.t('number.human.storage_units.mb', default: 'MB')             => 1024 * 1024 * 1024,
-          I18n.t('number.human.storage_units.gb', default: 'GB')             => 1024 * 1024 * 1024 * 1024,
-          I18n.t('number.human.storage_units.tb', default: 'TB')             => 1024 * 1024 * 1024 * 1024 * 1024
-        }.select { |k, v| self < v }.first
-        ns = (self.to_f / (fsz[1] / 1024)).round(precission).to_s.split('.')
-        n = ns[1].to_i == 0 ? ns[0] : ns.join( I18n.t('number.format.separator', default: '.') )
-        u = fsz[0]
-        fmt = I18n.t('number.human.storage_units.format', default:  '%n %u')
-        fmt.sub('%n', n).sub('%u', u)
+        def __i18n_filesize
+          {
+            I18n.t('number.human.storage_units.byte.other', default: 'Bytes') => 1024,
+            I18n.t('number.human.storage_units.kb', default: 'KB') => 1024**2,
+            I18n.t('number.human.storage_units.mb', default: 'MB') => 1024**3,
+            I18n.t('number.human.storage_units.gb', default: 'GB') => 1024**4,
+            I18n.t('number.human.storage_units.tb', default: 'TB') => 1024**5,
+            I18n.t('number.human.storage_units.pb', default: 'PB') => 1024**6
+          }.select { |_, v| self < v }.first
+        end
       end
 
     end
-
-
   end
-end
+end

data/lib/tzispa/utils/mail.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'mail'
+
+module Tzispa
+  module Utils
+
+    class Mail
+      attr_accessor :from, :to, :subject, :content, :cc,
+                    :html, :charset, :debug
+
+      attr_reader :config, :mail, :logger
+
+      DEFAULT_CHARSET = 'UTF-8'
+
+      def initialize(config, logger = nil)
+        @hmtl = false
+        @debug = false
+        @charset = DEFAULT_CHARSET
+        @logger = logger
+        @config = config
+        smtp_configuration(config)
+        @mail = ::Mail.new
+      end
+
+      def send_mail
+        recipients
+        body
+        mail.subject = subject
+        mail.charset = charset
+        mail.deliver
+      rescue
+        raise if debug
+      end
+
+      def add_file(path, attach_name)
+        mail.attachments[attach_name] = File.read(path)
+      end
+
+      private
+
+      def recipients
+        mail.from = from
+        mail.to to.split(';')
+        return unless cc
+        mail.cc cc.split(';')
+      end
+
+      def body
+        if html
+          mail.html_part do
+            content_type "text/html; charset=#{charset}"
+            body content
+          end
+        else
+          mail.body = content
+        end
+      end
+
+      def smtp_configuration(config)
+        if config.smtp_auth
+          auth_delivery(config)
+        else
+          delivery(config)
+        end
+      end
+
+      def delivery(config)
+        ::Mail.defaults do
+          delivery_method :smtp, address: config.host, domain: config.domain,
+                                 port: config.port, openssl_verify_mode: config.openssl_verify,
+                                 enable_starttls_auto: config.starttls_auto
+        end
+      end
+
+      def auth_delivery(config)
+        ::Mail.defaults do
+          delivery_method :smtp, address: config.host, domain: config.domain,
+                                 port: config.port, authentication: config.authentication,
+                                 openssl_verify_mode: config.openssl_verify,
+                                 enable_starttls_auto: config.starttls_auto,
+                                 user_name: config.user_name, password: config.password
+        end
+      end
+    end
+
+  end
+end

data/lib/tzispa/utils/string.rb

@@ -1,183 +1,181 @@
+# frozen_string_literal: true
+
 require 'i18n'
 require 'sanitize'
 require 'escape_utils'
 
 module Tzispa
   module Utils
-
-    NAMESPACE_SEPARATOR        = '::'
-    CLASSIFY_SEPARATOR         = '_'
-    UNDERSCORE_SEPARATOR       = '/'
-    DOT_SEPARATOR              = '.'
-    UNDERSCORE_DIVISION_TARGET = '\1_\2'
-
-
-    refine String do
-
-      def constantize
-        names = self.split(NAMESPACE_SEPARATOR)
-        names.shift if names.empty? || names.first.empty?
-        constant = Object
-        names.each do |name|
-          constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+    module TzString
+
+      NAMESPACE_SEPARATOR        = '::'
+      CLASSIFY_SEPARATOR         = '_'
+      UNDERSCORE_SEPARATOR       = '/'
+      DOT_SEPARATOR              = '.'
+      UNDERSCORE_DIVISION_TARGET = '\1_\2'
+
+      refine String do
+        def constantize
+          names = split(NAMESPACE_SEPARATOR)
+          names.shift if names.empty? || names.first.empty?
+          constant = Object
+          names.each do |name|
+            constant = if constant.const_defined?(name)
+                         constant.const_get(name)
+                       else
+                         constant.const_missing(name)
+                       end
+          end
+          constant
         end
-        constant
-      end
 
-      def camelize
-        split(CLASSIFY_SEPARATOR).collect{ |w| w.capitalize }.join
-      end
+        def camelize
+          split(CLASSIFY_SEPARATOR).collect(&:capitalize).join
+        end
 
-      def camelize!
-        split(CLASSIFY_SEPARATOR).collect!{ |w| w.capitalize }.join
-      end
+        def camelize!
+          split(CLASSIFY_SEPARATOR).collect!(&:capitalize).join
+        end
 
-      def dottize
-        dup.tap { |s|
-          s.dottize!
-        }
-      end
+        def dottize
+          dup.tap do |s|
+            s.gsub!(NAMESPACE_SEPARATOR, DOT_SEPARATOR)
+            s.gsub!(/([A-Z\d]+)([A-Z][a-z])/, UNDERSCORE_DIVISION_TARGET)
+            s.gsub!(/([a-z\d])([A-Z])/, UNDERSCORE_DIVISION_TARGET)
+            s.gsub!(/[[:space:]]|\-/, UNDERSCORE_DIVISION_TARGET)
+            s.downcase!
+          end
+        end
 
-      def dottize!
-        tap { |s|
-          s.gsub!(NAMESPACE_SEPARATOR, DOT_SEPARATOR)
-          s.gsub!(/([A-Z\d]+)([A-Z][a-z])/, UNDERSCORE_DIVISION_TARGET)
-          s.gsub!(/([a-z\d])([A-Z])/, UNDERSCORE_DIVISION_TARGET)
-          s.gsub!(/[[:space:]]|\-/, UNDERSCORE_DIVISION_TARGET)
-          s.downcase!
-        }
-      end
+        def dottize!
+          tap do |s|
+            s.gsub!(NAMESPACE_SEPARATOR, DOT_SEPARATOR)
+            s.gsub!(/([A-Z\d]+)([A-Z][a-z])/, UNDERSCORE_DIVISION_TARGET)
+            s.gsub!(/([a-z\d])([A-Z])/, UNDERSCORE_DIVISION_TARGET)
+            s.gsub!(/[[:space:]]|\-/, UNDERSCORE_DIVISION_TARGET)
+            s.downcase!
+          end
+        end
 
-      def underscore
-        dup.tap { |s|
-          s.underscore!
-        }
-      end
+        def underscore
+          dup.tap(&:underscore!)
+        end
 
-      def underscore!
-        tap { |s|
-          s.gsub!(NAMESPACE_SEPARATOR, UNDERSCORE_SEPARATOR)
-          s.gsub!(/([A-Z\d]+)([A-Z][a-z])/, UNDERSCORE_DIVISION_TARGET)
-          s.gsub!(/([a-z\d])([A-Z])/, UNDERSCORE_DIVISION_TARGET)
-          s.gsub!(/[[:space:]]|\-/, UNDERSCORE_DIVISION_TARGET)
-          s.downcase!
-        }
-      end
+        def underscore!
+          tap do |s|
+            s.gsub!(NAMESPACE_SEPARATOR, UNDERSCORE_SEPARATOR)
+            s.gsub!(/([A-Z\d]+)([A-Z][a-z])/, UNDERSCORE_DIVISION_TARGET)
+            s.gsub!(/([a-z\d])([A-Z])/, UNDERSCORE_DIVISION_TARGET)
+            s.gsub!(/[[:space:]]|\-/, UNDERSCORE_DIVISION_TARGET)
+            s.downcase!
+          end
+        end
 
-      def indentize(count, char = ' ')
-        dup.tap { |s|
-          s.indentize! count, char
-        }
-      end
+        def indentize(count, char = ' ')
+          dup.tap { |str| str.indentize! count, char }
+        end
 
-      # Indent a string by count chars
-      def indentize!(count, char = ' ')
-        tap { |str|
-          str.gsub!(/([^\n]*)(\n|$)/) do |match|
-            last_iteration = ($1 == "" && $2 == "")
-            line = ""
+        # Indent a string by count chars
+        def indentize!(count, char = ' ')
+          gsub!(/([^\n]*)(\n|$)/) do
+            s1 = Regexp.last_match(1)
+            s2 = Regexp.last_match(2)
+            last_iteration = (s1 == '' && s2 == '')
+            line = String.new
             line << (char * count) unless last_iteration
-            line << $1
-            line << $2
+            line << s1 << s2
             line
           end
-        }
-      end
-
+        end
 
-      # Replace accents in the string using I18n.transliterate
-      def transliterate(locale=nil)
-        I18n.transliterate(self, ({locale: locale} if locale))
-      end
+        # Replace accents in the string using I18n.transliterate
+        def transliterate(locale = nil)
+          I18n.transliterate(self, ({ locale: locale } if locale))
+        end
 
-      # Convert a string to a format suitable for a URL without ever using escaped characters.
-      # It calls strip, transliterate, downcase (optional) then removes the spaces (optional)
-      # and finally removes any characters matching the default regexp (/[^-_A-Za-z0-9]/).
-      #
-      # Options
-      #
-      # * :downcase => call downcase on the string (defaults to true)
-      # * :convert_spaces => Convert space to underscore (defaults to true)
-      # * :regexp => The regexp matching characters that will be removed (defaults to /[^-_A-Za-z0-9]/)
-      def urlize(options = {})
-        options[:downcase] ||= true
-        options[:convert_spaces] ||= true
-        options[:regexp] ||= /[^-_A-Za-z0-9]/
-
-        transliterate(options[:locale]).strip.tap { |str|
-          str.downcase! if options[:downcase]
-          str.gsub!(/\ /,'_') if options[:convert_spaces]
-          str.gsub!(options[:regexp], '')
-        }
-      end
+        # Convert a string to a format suitable for a URL without ever using escaped characters.
+        # It calls strip, transliterate, downcase (optional) then removes the spaces (optional)
+        # and finally removes any characters matching the default regexp (/[^-_A-Za-z0-9]/).
+        #
+        # Options
+        #
+        # * :downcase => call downcase on the string (defaults to true)
+        # * :convert_spaces => Convert space to underscore (defaults to true)
+        # * :regexp => matching characters that will be removed (defaults to /[^-_A-Za-z0-9]/)
+        def urlize(options = {})
+          options[:downcase] ||= true
+          options[:convert_spaces] ||= true
+          options[:regexp] ||= /[^-_A-Za-z0-9]/
+
+          transliterate(options[:locale]).strip.tap do |str|
+            str.downcase! if options[:downcase]
+            str.tr!(' ', '_') if options[:convert_spaces]
+            str.gsub!(options[:regexp], '')
+          end
+        end
 
-      def length_constraint_wordify(max, word_splitter=' ')
-        ml = 0
-        split(word_splitter).take_while { |s| (ml += s.length + 1) <= max }.join(word_splitter)
-      end
+        def length_constraint_wordify(max, word_splitter = ' ')
+          ml = 0
+          split(word_splitter).take_while { |s| (ml += s.length + 1) <= max }.join(word_splitter)
+        end
 
-      def sanitize_html(level = nil)
-        level ? Sanitize.fragment(self, level) :
-                Sanitize.fragment(self)
-      end
-      alias sanitize_htm sanitize_html
+        def sanitize_html(level = nil)
+          level ? Sanitize.fragment(self, level) : Sanitize.fragment(self)
+        end
+        alias_method :sanitize_htm, :sanitize_html
 
-      def escape_html
-        EscapeUtils.escape_html(self)
-      end
-      alias_method :escape_htm, :escape_html
+        def escape_html
+          EscapeUtils.escape_html(self)
+        end
+        alias_method :escape_htm, :escape_html
 
-      def unescape_html
-        EscapeUtils.unescape_html(self)
+        def unescape_html
+          EscapeUtils.unescape_html(self)
+        end
+        alias_method :unescape_htm, :unescape_html
       end
-      alias_method :unescape_htm, :unescape_html
 
-    end
-
-
-    refine String.singleton_class do
-
-      def underscore(str)
-        String.new(str).underscore
-      end
+      refine String.singleton_class do
+        def underscore(str)
+          String.new(str).underscore
+        end
 
-      def camelize(str)
-        String.new(str).camelize
-      end
+        def camelize(str)
+          String.new(str).camelize
+        end
 
-      def dottize(str)
-        String.new(str).dottize
-      end
+        def dottize(str)
+          String.new(str).dottize
+        end
 
-      def constantize(str)
-        String.new(str).constantize
-      end
+        def constantize(str)
+          String.new(str).constantize
+        end
 
-      def urlize(str)
-        String.new(str).urlize
-      end
+        def urlize(str)
+          String.new(str).urlize
+        end
 
-      def indentize(str, count, char = ' ')
-        String.new(str).indentize count, char
-      end
+        def indentize(str, count, char = ' ')
+          String.new(str).indentize count, char
+        end
 
-      def sanitize_html(str, level = nil)
-        String.new(str).santize(level)
-      end
-      alias_method :sanitize_htm, :sanitize_html
+        def sanitize_html(str, level = nil)
+          String.new(str).santize(level)
+        end
+        alias_method :sanitize_htm, :sanitize_html
 
-      def escape_html(str)
-        String.new(str).escape_html
-      end
-      alias_method :escape_htm, :escape_html
+        def escape_html(str)
+          String.new(str).escape_html
+        end
+        alias_method :escape_htm, :escape_html
 
-      def unescape_html(str)
-        String.new(str).unescape_html
+        def unescape_html(str)
+          String.new(str).unescape_html
+        end
+        alias_method :unescape_htm, :unescape_html
       end
-      alias_method :unescape_htm, :unescape_html
 
     end
-
-
   end
 end

data/lib/tzispa/utils/version.rb

@@ -3,7 +3,7 @@
 module Tzispa
   module Utils
 
-    VERSION  = '0.3.1'
+    VERSION  = '0.3.2'
     NAME     = 'Tzispa Utils'
     GEM_NAME = 'tzispa_utils'
 

data/test/decorator_test.rb

@@ -1,26 +1,22 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class BaseClass
-
   attr_accessor :a, :b
 
   def sum
-    a+b
+    (a + b)
   end
-
 end
 
 class DecoratedClass < Tzispa::Utils::Decorator
-
   def substract
-    b-a
+    (b - a)
   end
-
 end
 
-
 class DecoratorTest < Minitest::Test
-
   def setup
     @base = BaseClass.new
     @base.a = 12

data/test/hash_test.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'tzispa/utils/hash'
+
+class HashTest < Minitest::Test
+  using Tzispa::Utils::TzHash
+
+  def test_symbolize
+    s1 = { 'one' => 1, 'two' => 2 }
+    s1s = { one: 1, two: 2 }
+    assert_equal s1.symbolize.keys, [:one, :two]
+    assert_equal s1.symbolize, s1s
+    refute_equal s1, s1s
+    s1.symbolize!
+    assert_equal s1, s1s
+  end
+
+  def test_deep_symbolize
+    s2 = { 'one' => 1, 'two' => { 'one' => 1, 'two' => 2 } }
+    s2s = { one: 1, two: { 'one' => 1, 'two' => 2 } }
+    s2d = { one: 1, two: { one: 1, two: 2 } }
+    s2m = { 'one' => 1, 'two' => { one: 1, two: 2 } }
+    assert_equal s2.symbolize, s2s
+    assert_equal s2.deep_symbolize, s2d
+    refute_equal s2, s2d
+    refute_equal s2, s2m
+    s2.deep_symbolize!
+    assert_equal s2, s2d
+  end
+
+  def test_stringify
+    s1 = { 'one' => 1, 'two' => 2 }
+    s1s = { one: 1, two: 2 }
+    assert_equal s1s.stringify.keys, %w(one two)
+    assert_equal s1s.stringify, s1
+    refute_equal s1, s1s
+    s1s.stringify!
+    assert_equal s1, s1s
+  end
+
+  def test_tuplify
+    s1 = { 'one' => 1, 'two' => 2, 'three' => 3 }
+    s2 = { file: %w(read write delete), document: %w(read update), folder: 'read' }
+    assert_equal s1.tuplify,
+                 [['one', 1], ['two', 2], ['three', 3]]
+    assert_equal s2.tuplify,
+                 [[:file, 'read'], [:file, 'write'], [:file, 'delete'],
+                  [:document, 'read'], [:document, 'update'],
+                  [:folder, 'read']]
+  end
+
+end

data/test/indenter_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class IndenterTest < Minitest::Test
@@ -7,13 +9,15 @@ class IndenterTest < Minitest::Test
   end
 
   def test_indenter
-    str_t = "indenter test"
-    assert (@ind.indent << str_t).to_s == "  indenter test"
-    assert (@ind.indent << str_t).to_s == "  indenter test    indenter test"
-    assert (@ind.unindent << str_t).to_s == "  indenter test    indenter test  indenter test"
-    assert (@ind.unindent << str_t).to_s == "  indenter test    indenter test  indenter testindenter test"
+    str_t = 'indenter test'
+    assert_equal (@ind.indent << str_t).to_s,
+                 '  indenter test'
+    assert_equal (@ind.indent << str_t).to_s,
+                 '  indenter test    indenter test'
+    assert_equal (@ind.unindent << str_t).to_s,
+                 '  indenter test    indenter test  indenter test'
+    assert_equal (@ind.unindent << str_t).to_s,
+                 '  indenter test    indenter test  indenter testindenter test'
   end
 
-
-
 end

data/test/integer_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 class IntegerTest < Minitest::Test
-  using Tzispa::Utils
+  using Tzispa::Utils::TzInteger
 
   def setup
     I18n.enforce_available_locales = false
@@ -12,6 +12,8 @@ class IntegerTest < Minitest::Test
   end
 
   def test_filesize
+    I18n.load_path = nil
+    I18n.default_locale = nil
     assert_equal 8192.to_filesize, '8 KB'
     assert_equal 8192000.to_filesize, '7.8 MB'
     assert_equal 8388608.to_filesize, '8 MB'

data/test/string_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 class StringTest < Minitest::Test
-  using Tzispa::Utils
+  using Tzispa::Utils::TzString
 
   @@locales = (I18n.load_path += Dir["test/res/locales/*.yml"])
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tzispa_utils
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Juan Antonio Piñero
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-20 00:00:00.000000000 Z
+date: 2017-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: mail
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -66,7 +80,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
-description: Utility classes used in Tzispa framework
+description: Utility classes used by Tzispa framework
 email:
 - japinero@area-integral.com
 executables: []
@@ -83,10 +97,12 @@ files:
 - lib/tzispa/utils/hash.rb
 - lib/tzispa/utils/indenter.rb
 - lib/tzispa/utils/integer.rb
+- lib/tzispa/utils/mail.rb
 - lib/tzispa/utils/string.rb
 - lib/tzispa/utils/version.rb
 - lib/tzispa_utils.rb
 - test/decorator_test.rb
+- test/hash_test.rb
 - test/indenter_test.rb
 - test/integer_test.rb
 - test/res/locales/es.yml
@@ -100,6 +116,7 @@ post_install_message:
 rdoc_options: []
 require_paths:
 - lib
+- test
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - "~>"