tzispa_helpers 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 87b4a937a075322e0d9ad944994d1a0562fbb390
+  data.tar.gz: 8ebb31c207fd19d5322097b6b11225aa52b22e80
+SHA512:
+  metadata.gz: 2464f13b0caa59b90b74a3b0d30a68b784c420b2fba0f17b89ea7e9b4a33e8a4e5f50b1f54bf8dfe9e4c5f68a2190143545ce741f00fb7f80d8be5fd973179d7
+  data.tar.gz: b3af1a958c90c2881b842277b708c5d5490bb8f4704699ce002f1e64cb7f1105e57669702fbd737c35c80c5afa59a01249261448df7fb9c64b94afc1e7a0215b

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+Tzispa Helpers
+
+## v0.1.3
+- Added mime module, code moved partially from response
+- Added 2 crawler functions: crawler_to_markdown, crawler_table_to_dl
+
+## v0.1.2
+- Added amount formatter in text helper with i18n support
+
+## v0.1.1
+- Added exception rescue in Mail.send_smtp_mail
+- Added pattern Helper
+- Added web crawler helper
+
+## v0.1.0
+- Initial release: code split from tzispa main gem

data/README.md

@@ -0,0 +1,3 @@
+Tzispa Helpers
+
+Helper modules for Tzispa framework

data/lib/tzispa/helpers/crawler.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'open-uri'
+require 'nokogiri'
+require 'htmlentities'
+require 'reverse_markdown'
+require 'unicode_utils'
+require 'redcarpet'
+
+module Tzispa
+  module Helpers
+    module Crawler
+
+
+      def crawler_save_file(url, dest_file)
+        File.open("#{dest_file}", 'wb') do |fo|
+             fo.write open(url).read
+        end
+      end
+
+      def crawler_to_markdown(source)
+        begin
+          source = source.read if source.respond_to? :read
+          htmee = HTMLEntities.new
+          ReverseMarkdown.convert(htmee.decode(source).strip, unknown_tags: :bypass)
+        rescue Encoding::UndefinedConversionError
+        end
+      end
+
+      def crawler_table_to_dl(source, table_path, columns=2, excluded_terms=[])
+        String.new.tap { |content|
+          dt, dd = Array.new, Array.new
+          htmee = HTMLEntities.new
+          markdown = Redcarpet::Markdown.new(Redcarpet::Render::HTML.new)
+          Nokogiri::HTML(source)&.xpath(table_path).collect { |row|
+            dterm = htmee.decode(row.at_xpath('td[1]')&.content).strip
+            if dterm.length > 0 && !excluded_terms.include?(UnicodeUtils.downcase dterm)
+              dt << dterm
+              dd << (2..columns).map { |i|
+                  ReverseMarkdown.convert(htmee.decode(row.at_xpath("td[#{i}]")&.children&.to_s || row.at_xpath("td[#{i}]")&.to_s).strip, unknown_tags: :bypass)
+              }.join('\n')
+            end
+          }
+          if dt.length > 0
+            content << '<dl>'
+            dt.zip(dd).sort.each do |idt,idd|
+               if idt.length > 0 && !excluded_terms.include?(UnicodeUtils.downcase idt)
+                 content << "<dt>#{idt}</dt>"
+                 content << "<dd>#{markdown.render idd}</dd>"
+               end
+            end
+            content << "</dl>"
+          end
+        }
+      end
+
+
+    end
+  end
+end

data/lib/tzispa/helpers/html.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'cgi/util'
+require 'uri'
+
+module Tzispa
+  module Helpers
+    module Html
+
+      def html_checked(value)
+        value ? ' checked="checked"' : String.new.freeze
+      end
+
+      def html_selected(value)
+        value ? ' selected="selected"' : String.new.freeze
+      end
+
+      def html_escape(str)
+        CGI::escapeHTML str
+      end
+
+      def html_unescape(str)
+        CGI::unescapeHTML str
+      end
+
+      def html_urlencode(str)
+        URI.escape str
+      end
+
+      def html_urldecode(str)
+        URI.unescape str
+      end
+
+      def html_strip(source)
+        source.gsub(/<\/?[^>]*>/, '')
+      end
+
+
+      #
+      # $Id: sanitize.rb 3 2005-04-05 12:51:14Z dwight $
+      #
+      # Copyright (c) 2005 Dwight Shih
+      # A derived work of the Perl version:
+      # Copyright (c) 2002 Brad Choate, bradchoate.com
+      #
+      # Permission is hereby granted, free of charge, to
+      # any person obtaining a copy of this software and
+      # associated documentation files (the "Software"), to
+      # deal in the Software without restriction, including
+      # without limitation the rights to use, copy, modify,
+      # merge, publish, distribute, sublicense, and/or sell
+      # copies of the Software, and to permit persons to
+      # whom the Software is furnished to do so, subject to
+      # the following conditions:
+      #
+      # The above copyright notice and this permission
+      # notice shall be included in all copies or
+      # substantial portions of the Software.
+      #
+      # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY
+      # OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+      # LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+      # FITNESS FOR A PARTICULAR PURPOSE AND
+      # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+      # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
+      # OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+      # CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+      # OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+      # OTHER DEALINGS IN THE SOFTWARE.
+      #
+      def html_sanitize( html, okTags='a href, b, br, i, p' )
+        # no closing tag necessary for these
+        soloTags = ["br","hr"]
+
+        # Build hash of allowed tags with allowed attributes
+        tags = okTags.downcase().split(',').collect!{ |s| s.split(' ') }
+        allowed = Hash.new
+        tags.each do |s|
+          key = s.shift
+          allowed[key] = s
+        end
+
+        # Analyze all <> elements
+        stack = Array.new
+        result = html.gsub( /(<.*?>)/m ) do | element |
+          if element =~ /\A<\/(\w+)/ then
+            # </tag>
+            tag = $1.downcase
+            if allowed.include?(tag) && stack.include?(tag) then
+              # If allowed and on the stack
+              # Then pop down the stack
+              top = stack.pop
+              out = "</#{top}>"
+              until top == tag do
+                top = stack.pop
+                out << "</#{top}>"
+              end
+              out
+            end
+          elsif element =~ /\A<(\w+)\s*\/>/
+            # <tag />
+            tag = $1.downcase
+            if allowed.include?(tag) then
+              "<#{tag} />"
+            end
+          elsif element =~ /\A<(\w+)/ then
+            # <tag ...>
+            tag = $1.downcase
+            if allowed.include?(tag) then
+              if ! soloTags.include?(tag) then
+                stack.push(tag)
+              end
+              if allowed[tag].length == 0 then
+                # no allowed attributes
+                "<#{tag}>"
+              else
+                # allowed attributes?
+                out = "<#{tag}"
+                while ( $' =~ /(\w+)=("[^"]+")/ )
+                  attr = $1.downcase
+                  valu = $2
+                  if allowed[tag].include?(attr) then
+                    out << " #{attr}=#{valu}"
+                  end
+                end
+                out << ">"
+              end
+            end
+          end
+        end
+
+        # eat up unmatched leading >
+        while result.sub!(/\A([^<]*)>/m) { $1 } do end
+
+        # eat up unmatched trailing <
+        while result.sub!(/<([^>]*)\Z/m) { $1 } do end
+
+        # clean up the stack
+        if stack.length > 0 then
+          result << "</#{stack.reverse.join('></')}>"
+        end
+
+        result
+      end
+
+
+    end
+  end
+end

data/lib/tzispa/helpers/mail.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'mail'
+
+module Tzispa
+  module Helpers
+    module Mail
+
+      def send_smtp_mail(from:, to:, subject:, body:, config:, cc: nil, html: false)
+        begin
+          smtp_configuration config
+          mail = ::Mail.new
+          mail.from = from
+          if !to.empty?
+            to_addrs = to.split(';')
+            mail.to = to_addrs.pop
+            to_addrs.each { |email|
+              mail.to << email
+            }
+            if cc
+              cc_addrs = cc.split(';')
+              mail.cc = cc_addrs.pop
+              cc_addrs.each { |email|
+                mail.cc << email
+              }
+            end
+            mail.subject = subject
+            if html
+              mail.html_part do
+                content_type 'text/html; charset=UTF-8'
+                body = body
+              end
+            else
+              mail.body = body
+            end
+            mail.deliver
+          else
+            nil
+          end
+        rescue
+          nil
+        end
+      end
+
+      private
+
+      def smtp_configuration(config)
+        if config.smtp_auth
+          ::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
+        else
+          ::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
+      end
+
+
+
+    end
+  end
+end

data/lib/tzispa/helpers/mime.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'rack/mime'
+
+module Tzispa
+  module Helpers
+    module Mime
+
+      def mime_type(type, value = nil)
+        return type      if type.nil?
+        return type.to_s if type.to_s.include?('/')
+        type = ".#{type}" unless type.to_s[0] == ?.
+        return Rack::Mime.mime_type(type, nil) unless value
+        Rack::Mime::MIME_TYPES[type] = value
+      end
+
+      def mime_extension(type)
+        Rack::Mime::MIME_TYPES.invert[type]
+      end
+
+    end
+  end
+end

data/lib/tzispa/helpers/pattern.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'html'
+
+module Tzispa
+  module Helpers
+    module Pattern
+
+      include Tzispa::Helpers::Html
+
+      def pattern_select_hours(selected=nil)
+        selected &&= selected.to_i
+        Proc.new {
+          (0..23).map { |hour|
+            loop_item(
+              value: hour,
+              text: hour.to_s.rjust(2, '0'),
+              selected: html_selected( selected == hour )
+            )
+          }
+        }
+      end
+
+      def pattern_select_minutes(selected=nil)
+        selected &&= selected.to_i
+        Proc.new {
+          (0..59).map { |minute|
+            loop_item(
+              value: minute,
+              text: minute.to_s.rjust(2, '0'),
+              selected: html_selected( selected == minute )
+            )
+          }
+        }
+      end
+
+      def pattern_select_year(first, last, selected=nil, reverse=true)
+        selected &&= selected.to_i
+        Proc.new {
+          ryear = (first..last)
+          enum_year = first > last ? (ryear.first).downto(ryear.last) : (ryear.first).to(ryear.last)
+          enum_year.map { |year|
+            loop_item(
+              value: year,
+              text:  year,
+              selected: html_selected( selected == year )
+            )
+          }
+        }
+      end
+
+
+
+    end
+  end
+end

data/lib/tzispa/helpers/request.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Tzispa
+  module Helpers
+    module Request
+
+      def request_data(fields)
+        Hash.new.tap { |data|
+          fields.each { |name|
+            macro_field = name.split('@:')
+            macro = macro_field.first.to_sym if macro_field.length == 2
+            field = macro_field.length == 2 ? macro_field.last : macro_field.first
+            field.split(':').tap { |fld|
+              src = fld.first
+              dest = fld.last
+              data[dest.to_sym] = macro ? send(macro, context.request[src]) : context.request[src]
+            }
+          }
+        }
+      end
+
+      def request_data_object(data_object:, fields:)
+        data_object.tap { |data|
+          fields.each { |name|
+            macro_field = name.split('@:')
+            macro = macro_field.first.to_sym if macro_field.length == 2
+            field = macro_field.length == 2 ? macro_field.last : macro_field.first
+            field.split(':').tap { |fld|
+              src = fld.first
+              dest = fld.last
+              data.send "#{dest}=".to_sym, macro ? send(macro, context.request[src]) : context.request[src]
+            }
+          }
+        }
+      end
+
+      def request_file_upload(request_file:, destination_path:, save_as: nil, keep_ext: true)
+        if request_file
+          fileext = File.extname(request_file[:filename]).downcase
+          filetype = request_file[:type]
+          save_ext = fileext if keep_ext
+          filename = (save_as ? "#{save_as}#{save_ext}" : request_file[:filename])
+          tempfile = request_file[:tempfile]
+          begin
+            dest_file = "#{destination_path}/#{filename}"
+            FileUtils.cp tempfile.path, dest_file
+            result = { name: filename, ext: fileext, path: dest_file, size: ::File.size(dest_file), type: filetype }
+          rescue => err
+            context.logger.fatal(err) if context
+            result = nil
+          ensure
+            tempfile.close
+            tempfile.unlink
+          end
+        else
+          result = nil
+        end
+        result
+      end
+
+
+    end
+  end
+end

data/lib/tzispa/helpers/response.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'uri'
+require_relative 'mime'
+
+module Tzispa
+  module Helpers
+    module Response
+
+      def self.included(base)
+        base.class_eval do
+          include Tzispa::Helpers::Mime
+        end
+      end
+
+      # Set or retrieve the response status code.
+      def status(value = nil)
+        response.status = value if value
+        response.status
+      end
+
+      # Set or retrieve the response body. When a block is given,
+      # evaluation is deferred until the body is read with #each.
+      def body(value = nil, &block)
+        if block_given?
+          def block.each; yield(call) end
+          response.body = block
+        elsif value
+          headers.delete 'Content-Length' unless request.head? || value.is_a?(Rack::File) || value.is_a?(Stream)
+          response.body = value
+        else
+          response.body
+        end
+      end
+
+      # Exit the current block, halts any further processing
+      # of the request, and returns the specified response.
+      def halt(*response)
+        response = response.first if response.length == 1
+        throw :halt, response
+      end
+
+      # Halt processing and redirect to the URI provided.
+      def redirect(uri, *args)
+        if env['HTTP_VERSION'] == 'HTTP/1.1' and env["REQUEST_METHOD"] != 'GET'
+          status 303
+        else
+          status 302
+        end
+
+        # According to RFC 2616 section 14.30, "the field value consists of a
+        # single absolute URI"
+        response['Location'] = uri(uri.to_s, config.absolute_redirects?)
+        halt(*args)
+      end
+
+      # Generates the absolute URI for a given path in the app.
+      # Takes Rack routers and reverse proxies into account.
+      def uri(addr = nil, absolute = true)
+        return addr if addr =~ /\A[A-z][A-z0-9\+\.\-]*:/
+        uri = [host = String.new]
+        if absolute
+          host << "http#{'s' if request.secure?}://"
+          if request.forwarded? or request.port != (request.secure? ? 443 : 80)
+            host << request.host_with_port
+          else
+            host << request.host
+          end
+        end
+        uri << (addr ? addr : request.path_info).to_s
+        File.join uri
+      end
+
+      # Halt processing and return the error status provided.
+      def error(code, body = nil)
+        code, body    = 500, code.to_str if code.respond_to? :to_str
+        response.body = body unless body.nil?
+        halt code
+      end
+
+      # Halt processing and return a 404 Not Found
+      def not_found(body = nil)
+        error 404, body
+      end
+
+      # Halt processing and return a 401 Unauthorized
+      def unauthorized(body = nil)
+        error 401, body
+      end
+
+      # Set multiple response headers with Hash.
+      def headers(hash = nil)
+        response.headers.merge! hash if hash
+        response.headers
+      end
+
+      # Set the Content-Type of the response body given a media type or file
+      # extension.
+      def content_type(type = nil, params = {})
+        return response['Content-Type'] unless type
+        default = params.delete :default
+        mime_type = mime_type(type) || default
+        fail "Unknown media type: %p" % type if mime_type.nil?
+        mime_type = mime_type.dup
+        unless params.include? :charset
+          params[:charset] = params.delete('charset') || config.default_encoding
+        end
+        params.delete :charset if mime_type.include? 'charset'
+        unless params.empty?
+          mime_type << (mime_type.include?(';') ? ', ' : ';')
+          mime_type << params.map do |key, val|
+            val = val.inspect if val =~ /[";,]/
+            "#{key}=#{val}"
+          end.join(', ')
+        end
+        response['Content-Type'] = mime_type
+      end
+
+      def attachment!(filename = nil, disposition = 'attachment')
+        content_disposition = disposition.to_s
+        content_disposition += "; filename=\"#{filename}\"; filename*=UTF-8''#{URI.escape(filename)}" if !filename.nil?
+        response['Content-Disposition'] = content_disposition
+      end
+
+      # Use the contents of the file at +path+ as the response body.
+      def send_file(path, opts = {})
+        begin
+          if opts[:type] or not response['Content-Type']
+            content_type opts[:type] || opts[:extension], :default => 'application/octet-stream'
+          end
+
+          disposition = opts[:disposition]
+          filename    = opts[:filename]
+          disposition = 'attachment' if disposition.nil? and filename
+          filename    = path         if filename.nil?
+
+          attachment! filename, disposition
+          last_modified opts[:last_modified] if opts[:last_modified]
+
+          file      = Rack::File.new nil
+          file.path = path
+          result    = file.serving context.env
+          result[1].each { |k,v| response.headers[k] ||= v }
+          response.headers['Content-Length'] = result[1]['Content-Length']
+          #opts[:status] &&= Integer(opts[:status])
+          #halt opts[:status] || result[0], result[2]
+          response.status = result[0]
+          response.body = result[2]
+        rescue
+          not_found 'Fichero no encontrado'
+        end
+      end
+
+      # Sugar for redirect (example:  redirect back)
+      def back
+        request.referer
+      end
+
+      # whether or not the status is set to 1xx
+      def informational?
+        response.status.between? 100, 199
+      end
+
+      # whether or not the status is set to 2xx
+      def success?
+        response.status.between? 200, 299
+      end
+
+      # whether or not the status is set to 3xx
+      def redirect?
+        response.status.between? 300, 399
+      end
+
+      # whether or not the status is set to 4xx
+      def client_error?
+        response.status.between? 400, 499
+      end
+
+      # whether or not the status is set to 5xx
+      def server_error?
+        response.status.between? 500, 599
+      end
+
+      # whether or not the status is set to 404
+      def not_found?
+        response.status == 404
+      end
+
+
+      class NotFound < NameError #:nodoc:
+        def http_status; 404 end
+      end
+
+
+    end
+  end
+end

data/lib/tzispa/helpers/security.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Tzispa
+  module Helpers
+    module Security
+
+
+      def secret(length)
+        alfanb = ['!', '$', '%', '&', '@', '#', '=', '_' '+', '-', '*', '/', '?', ':', ';', '.', ',',
+                   ('a'..'z'), ('0'..'9'), ('A'..'Z')].map { |i| i.to_a }.flatten
+        (0...length-1).map { alfanb[rand(alfanb.length)] }.join
+      end
+
+      def uuid
+        sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
+          # 32 bits for "time_low"
+          rand(0..0xffff), rand(0..0xffff),
+
+          # 16 bits for "time_mid"
+          rand(0..0xffff),
+
+          # 16 bits for "time_hi_and_version",
+          #3 four most significant bits holds version number 4
+          rand(0..0x0fff) | 0x4000,
+
+          # 16 bits, 8 bits for "clk_seq_hi_res",
+          # 8 bits for "clk_seq_low",
+          # two most significant bits holds zero and one for variant DCE1.1
+          rand(0..0x3fff) | 0x8000,
+
+          # 48 bits for "node"
+          rand(0..0xffff), rand(0..0xffff), rand(0..0xffff)
+        )
+      end
+
+      def sign_array(astr, salt=nil)
+        sign, i = String.new, 0
+        astr.each { |s|
+          i = i + 1
+          sign << "#{"_"*i}#{s}"
+        }
+        sign << "**#{salt}"
+        Digest::SHA1.hexdigest sign
+      end
+
+      def hash_password(password, salt)
+        Digest::MD5::hexdigest "#{password}::#{salt}"
+      end
+
+      def hash_password?(hashed, pwd, salt)
+        hashed == hash_password(pwd, salt)
+      end
+
+
+      class Identity
+
+        attr_reader :id, :token
+
+        def initialize(id, secret)
+          @id = id
+          @token = generate_token id, secret
+        end
+
+        def valid?(secret)
+          @token == Identity.generate_token(@id, secret)
+        end
+
+        private
+
+        def self.generate_token(value, salt)
+          Digest::SHA1.hexdigest "___#{value}_#{salt}__token__"
+        end
+
+      end
+
+
+    end
+  end
+end

data/lib/tzispa/helpers/text.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'bigdecimal'
+require 'i18n'
+require "unicode_utils"
+
+module Tzispa
+  module Helpers
+    module Text
+
+      def remove_words(sentence, removable)
+        sentence.split.delete_if{|x| removable.include?(UnicodeUtils.downcase x)}.join(' ')
+      end
+
+      def remove_phrases(text, removable)
+        removable.each { |phrase|
+          text.slice! phrase
+        }
+        text
+      end
+
+      def remove_parenthesized_text(text)
+        text.gsub(/\([^\)]*\)/, '')
+      end
+
+      def synonymize(sentence, synonyms)
+        sentence.gsub(/[[:alnum:]]+/) {|word|
+          dwword = UnicodeUtils.downcase word
+          synonyms.has_key?(dwword) ? synonyms[dwword] : word
+        }
+      end
+
+      def strip_to_nil(str, transform = nil)
+        sstr = str.strip if str and not str.strip.empty?
+        case transform
+          when :upcase then
+             UnicodeUtils.upcase(sstr)
+          when :downcase then
+             UnicodeUtils.downcase(sstr)
+          when :titlecase then
+             UnicodeUtils.titlecase(sstr)
+          else sstr
+        end
+      end
+
+      def split_to_array(str, separator=';')
+        str.split(separator) if str
+      end
+
+      def join_to_nil(ary, separator)
+        ary.join(separator) if ary and not ary.empty?
+      end
+
+      def str_to_bool(str, strue=nil)
+        strue ? (strue == str) : (str == 'yes' || str == 'true')
+      end
+
+      def str_to_date(str, format=nil)
+        begin
+          Date.strptime(str, format || I18n.t('date.formats.default')) if str
+        rescue
+          nil
+        end
+      end
+
+      def str_to_datetime(str, format=nil)
+        begin
+          result = DateTime.strptime(str, format || I18n.t('time.formats.default'))
+        rescue
+          result = nil
+        end
+        result
+      end
+
+      def amount(number, options = {})
+        if number.nil? && options[:nil_as_dash] != false
+          '–'
+        elsif number.zero? && options[:zero_as_dash]
+          '–'
+        else
+          precision = options[:precision]
+          if precision
+            options[:minimum_precision] = precision
+            options[:maximum_precision] = precision
+          end
+
+          number = number.round if options[:round]
+          separator = options.fetch(:separator, I18n.t('number.currency.format.separator'))
+          delimiter = options.fetch(:delimiter, I18n.t('number.currency.format.delimiter')).to_s
+          minimum_precision = options[:minimum_precision] || 0
+          str = number.is_a?(BigDecimal) ? number.to_s('F').sub(/\.0+\z/, "") : number.to_s.sub(/\.0+\z/, "")
+          str =~ /\A(\-?)(\d+)(?:\.(\d+))?\z/ or raise "Could not parse number: #{number}"
+          sign = $1
+          integer = $2
+          fraction = ($3 || '')
+
+          if options[:maximum_precision]
+            fraction = fraction[0, options[:maximum_precision]] if options[:maximum_precision]
+          end
+
+          if minimum_precision > 0
+            if fraction.length > 0 || minimum_precision > 0
+              fraction = "#{fraction}#{'0' * [0, minimum_precision - fraction.length].max}"
+            end
+          end
+
+          # the following two lines appear to be the most performant way to add a delimiter to every thousands place in the number
+          integer_size = integer.size
+          (1..((integer_size-1) / 3)).each {|x| integer[integer_size-x*3,0] = delimiter}
+          str = integer.chomp(delimiter)
+
+          # add fraction
+          str << "#{separator}#{fraction}" if fraction.length > 0
+
+          # restore sign
+          str = "#{sign}#{str}"
+          # add unit if given
+          if options[:unit]
+            unless options[:unit_separator] == false
+              str << options.fetch(:unit_separator, ' ')
+            end
+            str << options[:unit]
+          end
+          str
+        end
+      end
+
+      def money_amount(number, options = {})
+        amount(number, options.merge(:unit => I18n.t('number.currency.format.unit'), :nil_as_dash => true, :precision => I18n.t('number.currency.format.precision')))
+      end
+
+      def price_amount(number, options = {})
+        amount(number, options.merge(:nil_as_dash => true, :precision => I18n.t('number.currency.format.precision')))
+      end
+
+
+    end
+  end
+end

data/lib/tzispa/helpers/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Tzispa
+  module Helpers
+
+    VERSION  = '0.1.3'
+    NAME     = 'Tzispa Helpers'
+    GEM_NAME = 'tzispa_helpers'
+
+  end
+end

data/lib/tzispa/helpers.rb

@@ -0,0 +1,16 @@
+module Tzispa
+  module Helpers
+
+    require 'tzispa/helpers/version'
+    require 'tzispa/helpers/crawler'
+    require 'tzispa/helpers/html'
+    require 'tzispa/helpers/mail'
+    require 'tzispa/helpers/mime'
+    require 'tzispa/helpers/pattern'
+    require 'tzispa/helpers/request'
+    require 'tzispa/helpers/response'
+    require 'tzispa/helpers/security'
+    require 'tzispa/helpers/text'
+
+  end
+end

data/lib/tzispa_helpers.rb

@@ -0,0 +1,7 @@
+module Tzispa
+  module Helpers
+
+    require 'tzispa/helpers'
+    
+  end
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: tzispa_helpers
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Juan Antonio Piñero
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-26 00:00:00.000000000 Z
+dependencies:
+- !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: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: unicode_utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: htmlentities
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: reverse_markdown
+  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: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+description: Module Helpers for Tzispa framework
+email:
+- japinero@area-integral.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- lib/tzispa/helpers.rb
+- lib/tzispa/helpers/crawler.rb
+- lib/tzispa/helpers/html.rb
+- lib/tzispa/helpers/mail.rb
+- lib/tzispa/helpers/mime.rb
+- lib/tzispa/helpers/pattern.rb
+- lib/tzispa/helpers/request.rb
+- lib/tzispa/helpers/response.rb
+- lib/tzispa/helpers/security.rb
+- lib/tzispa/helpers/text.rb
+- lib/tzispa/helpers/version.rb
+- lib/tzispa_helpers.rb
+homepage: https://www.area-integral.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Helpers for Tzispa
+test_files: []