kdl 0.1.0 → 1.0.0.rc2

data/lib/kdl/types/email.rb

@@ -0,0 +1,43 @@
+require_relative './email/parser'
+
+module KDL
+  module Types
+    class Email < Value
+      attr_reader :local, :domain
+
+      def initialize(value, local:, domain:, **kwargs)
+        super(value, **kwargs)
+        @local = local
+        @domain = domain
+      end
+
+      def self.call(value, type = 'email')
+        local, domain = Parser.new(value.value).parse
+
+        new(value.value, type: type, local: local, domain: domain)
+      end
+
+    end
+    MAPPING['email'] = Email
+
+    class IDNEmail < Email
+      attr_reader :unicode_domain
+
+      def initialize(value, unicode_domain:, **kwargs)
+        super(value, **kwargs)
+        @unicode_domain = unicode_domain
+      end
+
+      def self.call(value, type = 'email')
+        local, domain, unicode_domain = Email::Parser.new(value.value, idn: true).parse
+
+        new("#{local}@#{domain}", type: type, local: local, domain: domain, unicode_domain: unicode_domain)
+      end
+
+      def unicode_value
+        "#{local}@#{unicode_domain}"
+      end
+    end
+    MAPPING['idn-email'] = IDNEmail
+  end
+end

data/lib/kdl/types/hostname/validator.rb

@@ -0,0 +1,51 @@
+require 'simpleidn'
+
+module KDL
+  module Types
+    class Hostname < Value
+      class Validator
+        PART_RGX = /^[a-z0-9_][a-z0-9_\-]{0,62}$/i
+
+        attr_reader :string
+        alias ascii string
+        alias unicode string
+
+        def initialize(string)
+          @string = string
+        end
+
+        def valid?
+          return false if @string.length > 253
+
+          @string.split('.').all? { |x| valid_part?(x) }
+        end
+
+        private
+
+        def valid_part?(part)
+          return false if part.empty?
+          return false if part.start_with?('-') || part.end_with?('-')
+
+          part =~ PART_RGX
+        end
+      end
+    end
+
+    class IDNHostname < Hostname
+      class Validator < Hostname::Validator
+        attr_reader :unicode
+
+        def initialize(string)
+          is_ascii = string.split('.').any? { |x| x.start_with?('xn--') }
+          if is_ascii
+            super(string)
+            @unicode = SimpleIDN.to_unicode(string)
+          else
+            super(SimpleIDN.to_ascii(string))
+            @unicode = string
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kdl/types/hostname.rb

@@ -0,0 +1,32 @@
+require_relative './hostname/validator'
+
+module KDL
+  module Types
+    class Hostname < Value
+      def self.call(value, type = 'hostname')
+        validator = Validator.new(value.value)
+        raise ArgumentError, "invalid hostname #{value}" unless validator.valid?
+
+        new(value.value, type: type)
+      end
+    end
+    MAPPING['hostname'] = Hostname
+
+    class IDNHostname < Hostname
+      attr_reader :unicode_value
+
+      def initialize(value, unicode_value:, **kwargs)
+        super(value, **kwargs)
+        @unicode_value = unicode_value
+      end
+
+      def self.call(value, type = 'idn-hostname')
+        validator = Validator.new(value.value)
+        raise ArgumentError, "invalid hostname #{value}" unless validator.valid?
+
+        new(validator.ascii, type: type, unicode_value: validator.unicode)
+      end
+    end
+    MAPPING['idn-hostname'] = IDNHostname
+  end
+end

data/lib/kdl/types/ip.rb

@@ -0,0 +1,32 @@
+module KDL
+  module Types
+    class IP < Value
+      def self.call(value, type = ip_type)
+        return nil unless value.is_a? ::KDL::Value::String
+
+        ip = ::IPAddr.new(value.value)
+        raise ArgumentError, "invalid #{ip_type} address" unless valid_ip?(ip)
+
+        new(ip, type: type)
+      end
+
+      def self.valid_ip?(ip)
+        ip.__send__(:"#{ip_type}?")
+      end
+    end
+
+    class IPV4 < IP
+      def self.ip_type
+        'ipv4'
+      end
+    end
+    MAPPING['ipv4'] = IPV4
+
+    class IPV6 < IP
+      def self.ip_type
+        'ipv6'
+      end
+    end
+    MAPPING['ipv6'] = IPV6
+  end
+end

data/lib/kdl/types/irl/parser.rb

@@ -0,0 +1,123 @@
+module KDL
+  module Types
+    class IRLReference < Value
+      class Parser
+        RGX = /^(?:(?:([a-z][a-z0-9+.\-]+)):\/\/([^@]+@)?([^\/?#]+)?)?(\/?[^?#]*)?(?:\?([^#]*))?(?:#(.*))?$/i.freeze
+        PERCENT_RGX = /%[a-f0-9]{2}/i.freeze
+
+        RESERVED_URL_CHARS = %w[! # $ & ' ( ) * + , / : ; = ? @ \[ \] %]
+        UNRESERVED_URL_CHARS = %w[A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
+                                  a b c d e f g h i j k l m n o p q r s t u v w x y z
+                                  0 1 2 3 4 5 6 7 8 9 - _ . ~].freeze
+        URL_CHARS = RESERVED_URL_CHARS + UNRESERVED_URL_CHARS
+
+        def initialize(string)
+          @string = string
+        end
+
+        def parse
+          scheme, auth, domain, path, search, hash = *parse_url
+
+          if @string.ascii_only?
+            unicode_path = Parser.decode(path)
+            unicode_search = Parser.decode(search)
+            unicode_hash = Parser.decode(hash)
+          else
+            unicode_path = path
+            path = Parser.encode(unicode_path)
+            unicode_search = search
+            search_params = unicode_search ? unicode_search.split('&').map { |x| x.split('=') } : nil
+            search = search_params ? search_params.map { |k, v| "#{Parser.encode(k)}=#{Parser.encode(v)}" }.join('&') : nil
+            unicode_hash = hash
+            hash = Parser.encode(hash)
+          end
+
+          if domain
+            validator = IDNHostname::Validator.new(domain)
+            domain = validator.ascii
+            unicode_domain = validator.unicode
+          else
+            unicode_domain = domain
+          end
+
+          unicode_value = Parser.build_uri_string(scheme, auth, unicode_domain, unicode_path, unicode_search, unicode_hash)
+          ascii_value = Parser.build_uri_string(scheme, auth, domain, path, search, hash)
+
+          [ascii_value,
+           { unicode_value: unicode_value,
+             unicode_domain: unicode_domain,
+             unicode_path: unicode_path,
+             unicode_search: unicode_search,
+             unicode_hash: unicode_hash }]
+        end
+
+        def parse_url
+          match = RGX.match(@string)
+          raise ArgumentError, "invalid IRL `#{@string}'" if match.nil?
+
+          _, *parts = *match
+          raise ArgumentError, "invalid IRL `#{@string}'" unless parts.all? { |part| Parser.valid_url_part?(part) }
+
+          parts
+        end
+
+        def self.valid_url_part?(string)
+          return true unless string
+
+          string.chars.all? do |char|
+            !char.ascii_only? || URL_CHARS.include?(char)
+          end
+        end
+
+        def self.encode(string)
+          return string unless string
+
+          string.chars
+                .map { |c| c.ascii_only? ? c : percent_encode(c) }
+                .join
+                .force_encoding('utf-8')
+        end
+
+        def self.decode(string)
+          return string unless string
+
+          string.gsub(PERCENT_RGX) do |match|
+            char = match[1, 2].to_i(16).chr
+            if RESERVED_URL_CHARS.include?(char)
+              match
+            else
+              char
+            end
+          end.force_encoding('utf-8')
+        end
+
+        def self.percent_encode(c)
+          c.bytes.map { |b| "%#{b.to_s(16)}" }.join.upcase
+        end
+
+        def self.build_uri_string(scheme, auth, domain, path, search, hash)
+          string = ''
+          string += "#{scheme}://" if scheme
+          string += auth if auth
+          string += domain if domain
+          string += path if path
+          string += "?#{search}" if search
+          string += "##{hash}" if hash
+          string
+        end
+      end
+    end
+
+    class IRL < IRLReference
+      class Parser < IRLReference::Parser
+        def parse_url
+          parts = super
+          scheme, * = parts
+          raise ArgumentError, "invalid IRL `#{@string}'" if scheme.nil? || scheme.empty?
+
+          parts
+        end
+      end
+    end
+  end
+end

data/lib/kdl/types/irl.rb

@@ -0,0 +1,46 @@
+require_relative './irl/parser'
+
+module KDL
+  module Types
+    class IRLReference < Value
+      attr_reader :unicode_value,
+                  :unicode_domain,
+                  :unicode_path,
+                  :unicode_search,
+                  :unicode_hash
+
+      def initialize(value, unicode_value:, unicode_domain:, unicode_path:, unicode_search:, unicode_hash:, **kwargs)
+        super(value, **kwargs)
+        @unicode_value = unicode_value
+        @unicode_domain = unicode_domain
+        @unicode_path = unicode_path
+        @unicode_search = unicode_search
+        @unicode_hash = unicode_hash
+      end
+
+      def self.call(value, type = 'irl-reference')
+        return nil unless value.is_a? ::KDL::Value::String
+
+        ascii_value, params = parser(value.value).parse
+
+        new(URI.parse(ascii_value), type: type, **params)
+      end
+
+      def self.parser(string)
+        IRLReference::Parser.new(string)
+      end
+    end
+    MAPPING['irl-reference'] = IRLReference
+
+    class IRL < IRLReference
+      def self.call(value, type = 'irl')
+        super(value, type)
+      end
+
+      def self.parser(string)
+        IRL::Parser.new(string)
+      end
+    end
+    MAPPING['irl'] = IRL
+  end
+end

data/lib/kdl/types/regex.rb

@@ -0,0 +1,13 @@
+module KDL
+  module Types
+    class Regex < Value
+      def self.call(value, type = 'regex')
+        return nil unless value.is_a? ::KDL::Value::String
+
+        regex = ::Regexp.new(value.value)
+        new(regex, type: type)
+      end
+    end
+    MAPPING['regex'] = Regex
+  end
+end

data/lib/kdl/types/url.rb

@@ -0,0 +1,30 @@
+module KDL
+  module Types
+    class URLReference < Value
+      def self.call(value, type = 'url-reference')
+        return nil unless value.is_a? ::KDL::Value::String
+
+        uri = parse_url(value.value)
+        new(uri, type: type)
+      end
+
+      def self.parse_url(string)
+        URI.parse(string)
+      end
+    end
+    MAPPING['url-reference'] = URLReference
+
+    class URL < URLReference
+      def self.call(value, type = 'url')
+        super(value, type)
+      end
+
+      def self.parse_url(string)
+        super.tap do |uri|
+          raise 'invalid URL' if uri.scheme.nil?
+        end
+      end
+    end
+    MAPPING['url'] = URL
+  end
+end

data/lib/kdl/types/url_template.rb

@@ -0,0 +1,328 @@
+module KDL
+  module Types
+    class URLTemplate < Value
+      UNRESERVED = /[a-zA-Z0-9\-._~]/.freeze
+      RESERVED = %r{[:/?#\[\]@!$&'()*+,;=]}.freeze
+
+      def self.call(value, type = 'url-template')
+        return nil unless value.is_a? ::KDL::Value::String
+
+        parts = Parser.parse(value.value)
+        new(parts, type: type)
+      end
+
+      def expand(variables)
+        result = value.map { |v| v.expand(variables) }.join
+        parser = IRLReference::Parser.new(result)
+        uri, * = parser.parse
+        URI(uri)
+      end
+
+      class Parser
+        def self.parse(string)
+          new(string).parse
+        end
+
+        def initialize(string)
+          @string = string
+          @index = 0
+        end
+
+        def parse
+          result = []
+          until (token = next_token).nil?
+            result << token
+          end
+          result
+        end
+
+        def next_token
+          buffer = ''
+          context = nil
+          expansion_type = nil
+          loop do
+            c = @string[@index]
+            case context
+            when nil
+              case c
+              when '{'
+                context = :expansion
+                buffer = ''
+                n = @string[@index + 1]
+                expansion_type = case n
+                                 when '+' then ReservedExpansion
+                                 when '#' then FragmentExpansion
+                                 when '.' then LabelExpansion
+                                 when '/' then PathExpantion
+                                 when ';' then ParameterExpansion
+                                 when '?' then QueryExpansion
+                                 when '&' then QueryContinuation
+                                 else StringExpansion
+                                 end
+                @index += (expansion_type == StringExpansion ? 1 : 2)
+              when nil then return nil
+              else
+                buffer = c
+                @index += 1
+                context = :literal
+              end
+            when :literal
+              case c
+              when '{', nil then return StringLiteral.new(buffer)
+              else
+                buffer << c
+                @index += 1
+              end
+            when :expansion
+              case c
+              when '}'
+                @index += 1
+                return parse_expansion(buffer, expansion_type)
+              when nil
+                raise ArgumentError, 'unterminated expansion'
+              else
+                buffer << c
+                @index += 1
+              end
+            end
+          end
+        end
+
+        def parse_expansion(string, type)
+          variables = string.split(',').map do |str|
+            case str
+            when /(.*)\*$/
+              Variable.new(Regexp.last_match(1),
+                           explode: true,
+                           allow_reserved: type.allow_reserved?,
+                           with_name: type.with_name?,
+                           keep_empties: type.keep_empties?)
+            when /(.*):(\d+)/
+              Variable.new(Regexp.last_match(1),
+                           limit: Regexp.last_match(2).to_i,
+                           allow_reserved: type.allow_reserved?,
+                           with_name: type.with_name?,
+                           keep_empties: type.keep_empties?)
+            else
+              Variable.new(str,
+                           allow_reserved: type.allow_reserved?,
+                           with_name: type.with_name?,
+                           keep_empties: type.keep_empties?)
+            end
+          end
+          type.new(variables)
+        end
+      end
+
+      class Variable
+        attr_reader :name
+
+        def initialize(name, limit: nil, explode: false, allow_reserved: false, with_name: false, keep_empties: false)
+          @name = name.to_sym
+          @limit = limit
+          @explode = explode
+          @allow_reserved = allow_reserved
+          @with_name = with_name
+          @keep_empties = keep_empties
+        end
+
+        def expand(value)
+          if @explode
+            case value
+            when Array
+              value.map { |v| prefix(encode(v)) }
+            when Hash
+              value.map { |k, v| prefix(encode(v), k) }
+            else
+              [prefix(encode(value))]
+            end
+          elsif @limit
+            [prefix(limit(value))].compact
+          else
+            [prefix(flatten(value))].compact
+          end
+        end
+
+        def limit(string)
+          return nil unless string
+
+          encode(string[0, @limit])
+        end
+
+        def flatten(value)
+          case value
+          when String
+            encode(value)
+          when Array, Hash
+            result = value.to_a
+                          .flatten
+                          .compact
+                          .map { |v| encode(v) }
+            result.empty? ? nil : result.join(',')
+          end
+        end
+
+        def encode(string)
+          return nil unless string
+
+          string.to_s
+                .chars
+                .map do |c|
+                  if UNRESERVED.match?(c) || (@allow_reserved && RESERVED.match?(c))
+                    c
+                  else
+                    IRLReference::Parser.percent_encode(c)
+                  end
+                end
+                .join
+                .force_encoding('utf-8')
+        end
+
+        def prefix(string, override = nil)
+          return nil unless string
+
+          key = override || @name
+
+          if @with_name || override
+            if string.empty? && !@keep_empties
+              encode(key)
+            else
+              "#{encode(key)}=#{string}"
+            end
+          else
+            string
+          end
+        end
+      end
+
+      class Part
+        def expand_variables(values)
+          @variables.reduce([]) do |list, variable|
+            expanded = variable.expand(values[variable.name])
+            expanded ? list + expanded : list
+          end
+        end
+
+        def separator
+          ','
+        end
+
+        def prefix
+          ''
+        end
+
+        def self.allow_reserved?
+          false
+        end
+
+        def self.with_name?
+          false
+        end
+
+        def self.keep_empties?
+          false
+        end
+      end
+
+      class StringLiteral < Part
+        def initialize(value)
+          super()
+          @value = value
+        end
+
+        def expand(*)
+          @value
+        end
+      end
+
+      class StringExpansion < Part
+        def initialize(variables)
+          super()
+          @variables = variables
+        end
+
+        def expand(values)
+          expanded = expand_variables(values)
+          return '' if expanded.empty?
+
+          prefix + expanded.join(separator)
+        end
+      end
+
+      class ReservedExpansion < StringExpansion
+        def self.allow_reserved?
+          true
+        end
+      end
+
+      class FragmentExpansion < StringExpansion
+        def prefix
+          '#'
+        end
+
+        def self.allow_reserved?
+          true
+        end
+      end
+
+      class LabelExpansion < StringExpansion
+        def prefix
+          '.'
+        end
+
+        def separator
+          '.'
+        end
+      end
+
+      class PathExpantion < StringExpansion
+        def prefix
+          '/'
+        end
+
+        def separator
+          '/'
+        end
+      end
+
+      class ParameterExpansion < StringExpansion
+        def prefix
+          ';'
+        end
+
+        def separator
+          ';'
+        end
+
+        def self.with_name?
+          true
+        end
+      end
+
+      class QueryExpansion < StringExpansion
+        def prefix
+          '?'
+        end
+
+        def separator
+          '&'
+        end
+
+        def self.with_name?
+          true
+        end
+
+        def self.keep_empties?
+          true
+        end
+      end
+
+      class QueryContinuation < QueryExpansion
+        def prefix
+          '&'
+        end
+      end
+    end
+    MAPPING['url-template'] = URLTemplate
+  end
+end