uri_template 0.4.0 → 0.5.0

data/lib/uri_template/rfc6570/expression.rb

@@ -0,0 +1,374 @@
+# -*- encoding : utf-8 -*-
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the Affero GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#    (c) 2011 - 2012 by Hannes Georg
+#
+
+require 'uri_template/rfc6570'
+
+class URITemplate::RFC6570
+
+    # @private
+  class Expression < Token
+
+    include URITemplate::Expression
+
+    attr_reader :variables
+
+    def initialize(vars)
+      @variable_specs = vars
+      @variables = vars.map(&:first)
+      @variables.uniq!
+    end
+
+    PREFIX = ''.freeze
+    SEPARATOR = ','.freeze
+    PAIR_CONNECTOR = '='.freeze
+    PAIR_IF_EMPTY = true
+    LIST_CONNECTOR = ','.freeze
+    BASE_LEVEL = 1
+
+    CHARACTER_CLASS = CHARACTER_CLASSES[:unreserved]
+
+    NAMED = false
+    OPERATOR = ''
+
+    def level
+      if @variable_specs.none?{|_,expand,ml| expand || (ml > 0) }
+        if @variable_specs.size == 1
+          return self.class::BASE_LEVEL
+        else
+          return 3
+        end
+      else
+        return 4
+      end
+    end
+
+    def expands?
+      @variable_specs.any?{|_,expand,_| expand }
+    end
+
+    def arity
+      @variable_specs.size
+    end
+
+    def expand( vars )
+      result = []
+      @variable_specs.each{| var, expand , max_length |
+        unless vars[var].nil?
+          result.push(*expand_one(var, vars[var], expand, max_length))
+        end
+      }
+      if result.any?
+        return (self.class::PREFIX + result.join(self.class::SEPARATOR))
+      else
+        return ''
+      end
+    end
+
+    def extract(position,matched)
+      name, expand, max_length = @variable_specs[position]
+      if matched.nil?
+        return [[ name , extracted_nil ]]
+      end
+      if expand
+        it = URITemplate::RegexpEnumerator.new(self.class.hash_extractor(max_length), :rest => :raise)
+        if position == 0
+          matched = "#{self.class::SEPARATOR}#{matched}"
+        end
+        splitted = it.each(matched)\
+          .map do |match|
+            raise match.inspect if match.kind_of? String
+            [ decode(match[1]), decode(match[2], false) ]
+          end
+        return after_expand(name, splitted)
+      end
+
+      return [ [ name, decode( matched ) ] ]
+    end
+
+    def to_s
+      return '{' + self.class::OPERATOR + @variable_specs.map{|name,expand,max_length| name + (expand ? '*': '') + (max_length > 0 ? (':' + max_length.to_s) : '') }.join(',') + '}'
+    end
+
+  private
+
+    def expand_one( name, value, expand, max_length)
+      if length_limited?(max_length)
+        if value.kind_of?(Array) or value.kind_of?(Hash)
+          raise InvalidValue::LengthLimitInapplicable.new(name,value)
+        end
+      end
+      if value.kind_of?(Hash) or Utils.pair_array?(value)
+        return transform_hash(name, value, expand, max_length)
+      elsif value.kind_of? Array
+        return transform_array(name, value, expand, max_length)
+      else
+        return self_pair(name, value, max_length)
+      end
+    end
+
+    def length_limited?(max_length)
+      max_length > 0
+    end
+
+    def extracted_nil
+      nil
+    end
+
+  protected
+
+    module ClassMethods
+
+      def hash_extractors
+        @hash_extractors ||= Hash.new{|hsh, key| hsh[key] = generate_hash_extractor(key) }
+      end
+
+      def hash_extractor(max_length)
+        return hash_extractors[max_length]
+      end
+
+      def generate_hash_extractor(max_length)
+        source = regex_builder
+        source.push('\\A')
+        source.escaped_separator
+        source.capture do
+          source.character_class('+').reluctant
+        end
+        source.group do
+          source.escaped_pair_connector
+          source.capture do
+            source.character_class(max_length,0).reluctant
+          end
+        end.length('?')
+        source.lookahead do
+          source.push '\\z'
+          source.push '|'
+          source.escaped_separator
+          source.push '[^'
+            source.escaped_separator
+          source.push ']'
+        end
+        return Regexp.new( source.join , Utils::KCODE_UTF8)
+      end
+
+      def regex_builder
+        RegexBuilder.new(self)
+      end
+
+    end
+
+    extend ClassMethods
+
+    def escape(x)
+      Utils.escape_url(Utils.object_to_param(x))
+    end
+
+    def unescape(x)
+      Utils.unescape_url(x)
+    end
+
+    def regex_builder
+      self.class.regex_builder
+    end
+
+    SPLITTER = /^(,+)|([^,]+)/
+
+    COMMA = ",".freeze
+
+    def decode(x, split = true)
+      if x.nil?
+        return extracted_nil
+      elsif split
+        result = []
+        # Add a comma if the last character is a comma
+        # seems weird but is more compatible than changing
+        # the regex.
+        x += COMMA if x[-1..-1] == COMMA
+        URITemplate::RegexpEnumerator.new(SPLITTER, :rest => :raise).each(x) do |match|
+          if match[1]
+            next if match[1].size == 1
+            result << match[1][0..-3]
+          elsif match[2]
+            result << unescape(match[2])
+          end
+        end
+        case(result.size)
+          when 0 then ''
+          when 1 then result.first
+          else result
+        end
+      else
+        unescape(x)
+      end
+    end
+
+    def cut(str,chars)
+      if chars > 0
+        md = Regexp.compile("\\A#{self.class::CHARACTER_CLASS[:class]}{0,#{chars.to_s}}", Utils::KCODE_UTF8).match(str)
+        return md[0]
+      else
+        return str
+      end
+    end
+
+    def pair(key, value, max_length = 0, &block)
+      ek = key
+      if block
+        ev = value.map(&block).join(self.class::LIST_CONNECTOR) 
+      else
+        ev = escape(value)
+      end
+      if !self.class::PAIR_IF_EMPTY and ev.size == 0
+        return ek
+      else
+        return ek + self.class::PAIR_CONNECTOR + cut( ev, max_length )
+      end
+    end
+
+    def transform_hash(name, hsh, expand , max_length)
+      if expand
+        hsh.map{|key,value| pair(escape(key),value) }
+      elsif hsh.none? && !self.class::NAMED
+        []
+      else
+        [ self_pair(name,hsh){|key,value| escape(key)+self.class::LIST_CONNECTOR+escape(value)} ]
+      end
+    end
+
+    def transform_array(name, ary, expand , max_length)
+      if expand
+        ary.map{|value| self_pair(name,value) }
+      elsif ary.none? && !self.class::NAMED
+        []
+      else
+        [ self_pair(name, ary){|value| escape(value) } ]
+      end
+    end
+  end
+
+  require 'uri_template/rfc6570/expression/named'
+  require 'uri_template/rfc6570/expression/unnamed'
+
+  class Expression::Basic < Expression::Unnamed
+  end
+
+  class Expression::Reserved < Expression::Unnamed
+
+    CHARACTER_CLASS = CHARACTER_CLASSES[:unreserved_reserved_pct]
+    OPERATOR = '+'.freeze
+    BASE_LEVEL = 2
+
+    def escape(x)
+      Utils.escape_uri(Utils.object_to_param(x))
+    end
+
+    def unescape(x)
+      Utils.unescape_uri(x)
+    end
+
+    def scheme?
+      true
+    end
+
+    def host?
+      true
+    end
+
+  end
+
+  class Expression::Fragment < Expression::Unnamed
+
+    CHARACTER_CLASS = CHARACTER_CLASSES[:unreserved_reserved_pct]
+    PREFIX = '#'.freeze
+    OPERATOR = '#'.freeze
+    BASE_LEVEL = 2
+
+    def escape(x)
+      Utils.escape_uri(Utils.object_to_param(x))
+    end
+
+    def unescape(x)
+      Utils.unescape_uri(x)
+    end
+
+  end
+
+  class Expression::Label < Expression::Unnamed
+
+    SEPARATOR = '.'.freeze
+    PREFIX = '.'.freeze
+    OPERATOR = '.'.freeze
+    BASE_LEVEL = 3
+
+  end
+
+  class Expression::Path < Expression::Unnamed
+
+    SEPARATOR = '/'.freeze
+    PREFIX = '/'.freeze
+    OPERATOR = '/'.freeze
+    BASE_LEVEL = 3
+
+    def starts_with_slash?
+      true
+    end
+
+  end
+
+  class Expression::PathParameters < Expression::Named
+
+    SEPARATOR = ';'.freeze
+    PREFIX = ';'.freeze
+    NAMED = true
+    PAIR_IF_EMPTY = false
+    OPERATOR = ';'.freeze
+    BASE_LEVEL = 3
+
+  end
+
+  class Expression::FormQuery < Expression::Named
+
+    SEPARATOR = '&'.freeze
+    PREFIX = '?'.freeze
+    NAMED = true
+    OPERATOR = '?'.freeze
+    BASE_LEVEL = 3
+
+  end
+
+  class Expression::FormQueryContinuation < Expression::Named
+
+    SEPARATOR = '&'.freeze
+    PREFIX = '&'.freeze
+    NAMED = true
+    OPERATOR = '&'.freeze
+    BASE_LEVEL = 3
+
+  end
+
+  # @private
+  OPERATORS = {
+    ''  => Expression::Basic,
+    '+' => Expression::Reserved,
+    '#' => Expression::Fragment,
+    '.' => Expression::Label,
+    '/' => Expression::Path,
+    ';' => Expression::PathParameters,
+    '?' => Expression::FormQuery,
+    '&' => Expression::FormQueryContinuation
+  }
+
+end

data/lib/uri_template/rfc6570/regex_builder.rb

@@ -0,0 +1,117 @@
+# -*- encoding : utf-8 -*-
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the Affero GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#    (c) 2011 - 2012 by Hannes Georg
+#
+
+require 'uri_template/rfc6570'
+
+class URITemplate::RFC6570
+
+  class RegexBuilder
+
+    def initialize(expression_class)
+      @expression_class = expression_class
+      @source = []
+    end
+
+    def <<(arg)
+      @source << arg
+      self
+    end
+
+    def push(*args)
+      @source.push(*args)
+      self
+    end
+
+    def escaped_pair_connector
+      self << Regexp.escape(@expression_class::PAIR_CONNECTOR)
+    end
+
+    def escaped_separator
+      self << Regexp.escape(@expression_class::SEPARATOR)
+    end
+
+    def escaped_prefix
+      self << Regexp.escape(@expression_class::PREFIX)
+    end
+
+    def join
+      return @source.join
+    end
+
+    def length(*args)
+      self << format_length(*args)
+    end
+
+    def character_class_with_comma(max_length=0, min = 0)
+      self << @expression_class::CHARACTER_CLASS[:class_with_comma] << format_length(max_length, min)
+    end
+
+    def character_class(max_length=0, min = 0)
+      self << @expression_class::CHARACTER_CLASS[:class] << format_length(max_length, min)
+    end
+
+    def reluctant
+      self << '?'
+    end
+
+    def group(capture = false)
+      self << '('
+      self << '?:' unless capture
+      yield
+      self << ')'
+    end
+
+    def negative_lookahead
+      self << '(?!'
+      yield
+      self << ')'
+    end
+
+    def lookahead
+      self << '(?='
+      yield
+      self << ')'
+    end
+
+    def capture(&block)
+      group(true, &block)
+    end
+
+    def separated_list(first = true, length = 0, min = 1, &block)
+      if first
+        yield
+        min -= 1
+      end
+      self.push('(?:').escaped_separator
+      yield
+      self.push(')').length(length, min)
+    end
+
+  private
+
+    def format_length(len, min = 0)
+      return len if len.kind_of? String
+      return '{'+min.to_s+','+len.to_s+'}' if len.kind_of?(Numeric) and len > 0
+      return '*' if min == 0
+      return '+' if min == 1
+      return '{'+min.to_s+',}'
+    end
+
+
+  end
+
+end