workato-connector-sdk 0.1.0

data/lib/workato/extension/currency.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Workato
+  module Extension
+    module Currency
+      def to_currency(options = {})
+        ActiveSupport::NumberHelper::NumberToCurrencyConverter(self, options)
+      end
+    end
+  end
+end
+
+String.include(Workato::Extension::Currency)
+Integer.include(Workato::Extension::Currency)
+Float.include(Workato::Extension::Currency)

data/lib/workato/extension/date.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Workato
+  module Extension
+    module Date
+      def yweek
+        cweek
+      end
+    end
+  end
+end
+
+Date.include(Workato::Extension::Date)
+DateTime.include(Workato::Extension::Date)

data/lib/workato/extension/enumerable.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Enumerable
+  def where(options = {})
+    obj = first
+    list = if obj.is_a?(::Hash)
+             self
+           else
+             []
+           end
+    Workato::Extension::Array::ArrayWhere.new(list, options || {})
+  end
+
+  def format_map(format)
+    if format.blank?
+      return self
+    end
+
+    map do |val|
+      format % (Array(val).map { |v| v.is_a?(HashWithIndifferentAccess) ? v.symbolize_keys : v })
+    end
+  end
+
+  def smart_join(separator)
+    transform_select do |val|
+      val = val.strip if val.is_a?(::String)
+      val.presence
+    end.join(separator)
+  end
+
+  def pluck(*keys)
+    if keys.many?
+      map { |element| keys.map { |key| element.respond_to?(:dig) ? element.dig(*key) : element[key] } }
+    else
+      map { |element| element.respond_to?(:dig) ? element.dig(*keys.first) : element[keys.first] }
+    end
+  end
+
+  def transform_find(&block)
+    each do |*items|
+      result = block.call(*items)
+      return result if result
+    end
+    nil
+  end
+
+  private
+
+  def transform_select(&block)
+    map do |*items|
+      result = block.call(*items)
+      result || nil
+    end.reject(&:nil?)
+  end
+end

data/lib/workato/extension/extra_chain_cert.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'rest-client'
+require 'net/http'
+
+module Workato
+  module Extension
+    module ExtraChainCert
+      module Net
+        module HTTP
+          attr_accessor :extra_chain_cert
+
+          def self.included(base)
+            ssl_ivnames = base.const_get('SSL_IVNAMES', false)
+            ssl_ivnames << :@extra_chain_cert unless ssl_ivnames.include?(:@extra_chain_cert)
+
+            ssl_attributes = base.const_get('SSL_ATTRIBUTES', false)
+            ssl_attributes << :extra_chain_cert unless ssl_attributes.include?(:extra_chain_cert)
+          end
+        end
+      end
+
+      ::Net::HTTP.include Net::HTTP
+
+      module RestClient
+        module Request
+          attr_accessor :extra_chain_cert
+
+          def net_http_object(hostname, port)
+            net = super(hostname, port)
+            net.extra_chain_cert = extra_chain_cert if extra_chain_cert
+            net
+          end
+        end
+      end
+
+      ::RestClient::Request.prepend RestClient::Request
+    end
+  end
+end

data/lib/workato/extension/hash.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Workato
+  module Extension
+    module Hash
+      def encode_www_form
+        ::URI.encode_www_form(self)
+      end
+    end
+  end
+end
+
+Hash.include(Workato::Extension::Hash)

data/lib/workato/extension/integer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Workato
+  module Extension
+    module Integer
+      def is_int? # rubocop:disable Naming/PredicateName
+        true
+      end
+
+      def to_time
+        ::Time.zone.at(self)
+      end
+    end
+  end
+end
+
+Integer.include(Workato::Extension::Integer)

data/lib/workato/extension/nil_class.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Workato
+  module Extension
+    module NilClass
+      def is_int? # rubocop:disable Naming/PredicateName
+        false
+      end
+
+      def is_number? # rubocop:disable Naming/PredicateName
+        false
+      end
+    end
+  end
+end
+
+NilClass.include(Workato::Extension::NilClass)

data/lib/workato/extension/object.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Workato
+  module Extension
+    module Object
+      # rubocop:disable Naming/PredicateName
+      def is_true?(null_true: false)
+        if is_a?(::String)
+          return true if (self =~ (/\A(true|t|yes|y|1)\Z/i)).present?
+          return false if (self =~ (/\A(false|f|no|n|0)\Z/i)).present?
+          raise "Can't convert empty string to boolean" if blank?
+
+          raise "Can't convert string value #{self} to boolean"
+        elsif is_a?(::Integer)
+          return true if self == 1
+          return false if zero?
+
+          raise "Can't convert number value #{self} to boolean"
+        elsif is_a?(::TrueClass)
+          true
+        elsif is_a?(::FalseClass)
+          false
+        elsif is_a?(::NilClass)
+          null_true == true
+        else
+          raise "Can't convert type #{self.class.name} to boolean"
+        end
+      end
+
+      def is_not_true?(null_not_true: true)
+        !is_true?(null_true: !null_not_true)
+      end
+      # rubocop:enable Naming/PredicateName
+    end
+  end
+end
+
+Object.include(Workato::Extension::Object)

data/lib/workato/extension/phone.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Workato
+  module Extension
+    module Phone
+      def to_phone(options = {})
+        ActiveSupport::NumberHelper::NumberToPhoneConverter(self, options).to_s
+      end
+    end
+  end
+end
+
+String.include(Workato::Extension::Phone)
+Integer.include(Workato::Extension::Phone)

data/lib/workato/extension/string.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module Workato
+  module Extension
+    module String
+      HUMAN_DATE_FP = { '%d' => 'DD', '%m' => 'MM', '%Y' => 'YYYY' }.freeze
+      HUMAN_DATE_FORMAT = %w[%d %m %Y].permutation(3).each_with_object({}) do |fmt, r|
+        %w[/ -].each do |s|
+          v = fmt.join(s)
+          k = fmt.map { |fp| HUMAN_DATE_FP[fp] }.join(s)
+          r[k] = v
+        end
+      end
+      TO_COUNTRY_METHODS = %w[alpha2 alpha3 name number].freeze
+      TO_CURRENCY_METHODS = %w[code name symbol].freeze
+      TO_STATE_METHODS = %w[code name].freeze
+
+      def is_int? # rubocop:disable Naming/PredicateName
+        present? && (self !~ /\D/)
+      end
+
+      def is_number? # rubocop:disable Naming/PredicateName
+        return false if blank?
+
+        match?(/^\d+$/) ||
+          begin
+            Float(self)
+          rescue StandardError
+            false
+          end.present?
+      end
+
+      def split_strip_compact(pattern, parts = 0)
+        split(pattern, parts).map(&:strip).select(&:present?)
+      end
+
+      def strip_tags
+        Loofah::Helpers.strip_tags(self)
+      end
+
+      def to_time(form = :local, format: nil)
+        if format.present?
+          format = HUMAN_DATE_FORMAT[format] if HUMAN_DATE_FORMAT.key?(format)
+          time = ::Time.strptime(self, format)
+          form == :utc ? time.utc : time.getlocal
+        else
+          super form
+        end
+      end
+
+      def quote
+        gsub("'", "''")
+      end
+
+      def to_date(format: nil)
+        if format.present?
+          format = HUMAN_DATE_FORMAT[format] if HUMAN_DATE_FORMAT.key?(format)
+          ::Date.strptime(self, format)
+        else
+          super()
+        end
+      end
+
+      def transliterate(replacement = '?')
+        I18n.transliterate(self, replacement)
+      end
+
+      def labelize(*acronyms)
+        acronyms.unshift(/^id$/i, /^ur[il]$/i)
+        split(/_+ # snake_case => Snake case
+              |
+              (?<!\d)(?=\d)|(?<=\d)(?!\d) # concatenated42numbers => Concatenated 42 numbers
+              |
+              (?<![A-Z])(?=[A-Z]) # camelCase => Camel case
+              |
+              (?<=[A-Z0-9])(?=[A-Z][^A-Z0-9_] # MIXEDCase => Mixed case
+             )/x).select(&:present?).map.with_index do |word, i|
+          if /^[A-Z]+$/ =~ word
+            word
+          elsif acronyms.any? { |pattern| pattern =~ word }
+            word.upcase
+          elsif i.zero?
+            word.humanize
+          else
+            word.downcase
+          end
+        end.join(' ')
+      end
+
+      def to_hex
+        unpack('H*')[0]
+      end
+
+      def base64
+        encode_base64
+      end
+
+      alias encode_hex to_hex
+
+      def decode_hex
+        Binary.new([self].pack('H*'))
+      end
+
+      def encode_base64
+        Base64.strict_encode64(self)
+      end
+
+      def decode_base64
+        Binary.new(Base64.decode64(self))
+      end
+
+      def encode_urlsafe_base64
+        Base64.urlsafe_encode64(self)
+      end
+
+      def encode_url
+        ::ERB::Util.url_encode(self)
+      end
+
+      def decode_urlsafe_base64
+        Binary.new(Base64.urlsafe_decode64(self))
+      end
+
+      def encode_sha256
+        Binary.new(::Digest::SHA256.digest(self))
+      end
+
+      def hmac_sha256(key)
+        digest = ::OpenSSL::Digest.new('sha256')
+        Binary.new(::OpenSSL::HMAC.digest(digest, key, self))
+      end
+
+      def hmac_sha512(key)
+        digest = ::OpenSSL::Digest.new('sha512')
+        Binary.new(::OpenSSL::HMAC.digest(digest, key, self))
+      end
+
+      def md5_hexdigest
+        ::Digest::MD5.hexdigest(self)
+      end
+
+      def sha1
+        Binary.new(::Digest::SHA1.digest(self))
+      end
+
+      def hmac_sha1(key)
+        digest = ::OpenSSL::Digest.new('sha1')
+        Binary.new(::OpenSSL::HMAC.digest(digest, key, self))
+      end
+
+      def hmac_md5(key)
+        digest = ::OpenSSL::Digest.new('md5')
+        Binary.new(::OpenSSL::HMAC.digest(digest, key, self))
+      end
+
+      def from_xml
+        XML.parse_xml_to_hash self
+      end
+
+      TO_COUNTRY_METHODS.each do |suffix|
+        define_method("to_country_#{suffix}") do
+          to_country.try(suffix)
+        end
+      end
+
+      TO_CURRENCY_METHODS.each do |suffix|
+        define_method("to_currency_#{suffix}") do
+          to_currency_obj.try(suffix)
+        end
+      end
+
+      TO_STATE_METHODS.each do |suffix|
+        define_method("to_state_#{suffix}") do |country_name = 'US'|
+          to_state(country_name).try(:[], suffix)
+        end
+      end
+
+      protected
+
+      def to_country
+        TO_COUNTRY_METHODS.transform_find do |attr|
+          ISO3166::Country.send("find_country_by_#{attr}", self)
+        end
+      end
+
+      def to_currency_obj
+        ISO4217::Currency.from_code(self) || to_country.try(:currency)
+      end
+
+      def to_state(country_name = 'US')
+        country_name = country_name.presence || 'US'
+        country = country_name.to_country
+        return nil if country.blank?
+
+        state = upcase
+        country.states.transform_find do |code, data|
+          name = data['name'].upcase
+          other_names = Array(data['names']).map(&:upcase)
+          if code == state || name == state || other_names.include?(state)
+            {
+              code: code,
+              name: name
+            }.with_indifferent_access
+          end
+        end
+      end
+    end
+
+    class Binary < ::String
+      TITLE_LENGTH = 16
+      SUMMARY_LENGTH = 128
+
+      def initialize(str)
+        super(str)
+        force_encoding(Encoding::ASCII_8BIT)
+      end
+
+      def to_s
+        self
+      end
+
+      def binary?
+        true
+      end
+
+      def base64
+        Base64.strict_encode64(self)
+      end
+
+      def as_string(encoding)
+        String.new(self, encoding: encoding).encode(encoding, invalid: :replace, undef: :replace)
+      end
+
+      def as_utf8
+        as_string('utf-8')
+      end
+
+      # representation in event title
+      def title
+        if length.positive?
+          "0x#{byteslice(0, TITLE_LENGTH).unpack1('H*')}#{bytesize > TITLE_LENGTH ? '…' : ''}"
+        else
+          ''
+        end
+      end
+
+      def sha1
+        Binary.new(::Digest::SHA1.digest(self))
+      end
+
+      def summary
+        if length.positive?
+          left = "0x#{byteslice(0, SUMMARY_LENGTH).unpack1('H*')}"
+          right = bytesize > SUMMARY_LENGTH ? "…(#{bytesize - SUMMARY_LENGTH} bytes more)" : ''
+          "#{left}#{right}"
+        else
+          ''
+        end
+      end
+
+      def self.from_base64(base64str)
+        new(Base64.strict_decode64(base64str))
+      end
+    end
+  end
+end
+
+String.include(Workato::Extension::String)