uri_parser 0.0.1

data/ext/uri_parser/url_util.h

@@ -0,0 +1,222 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLEURL_SRC_URL_UTIL_H__
+#define GOOGLEURL_SRC_URL_UTIL_H__
+
+#include <string>
+
+#include "string16.h"
+#include "url_common.h"
+#include "url_parse.h"
+#include "url_canon.h"
+
+namespace url_util {
+
+// Init ------------------------------------------------------------------------
+
+// Initialization is NOT required, it will be implicitly initialized when first
+// used. However, this implicit initialization is NOT threadsafe. If you are
+// using this library in a threaded environment and don't have a consistent
+// "first call" (an example might be calling "AddStandardScheme" with your
+// special application-specific schemes) then you will want to call initialize
+// before spawning any threads.
+//
+// It is OK to call this function more than once, subsequent calls will simply
+// "noop", unless Shutdown() was called in the mean time. This will also be a
+// "noop" if other calls to the library have forced an initialization
+// beforehand.
+GURL_API void Initialize();
+
+// Cleanup is not required, except some strings may leak. For most user
+// applications, this is fine. If you're using it in a library that may get
+// loaded and unloaded, you'll want to unload to properly clean up your
+// library.
+GURL_API void Shutdown();
+
+// Schemes --------------------------------------------------------------------
+
+// Adds an application-defined scheme to the internal list of "standard" URL
+// schemes. This function is not threadsafe and can not be called concurrently
+// with any other url_util function. It will assert if the list of standard
+// schemes has been locked (see LockStandardSchemes).
+GURL_API void AddStandardScheme(const char* new_scheme);
+
+// Sets a flag to prevent future calls to AddStandardScheme from succeeding.
+//
+// This is designed to help prevent errors for multithreaded applications.
+// Normal usage would be to call AddStandardScheme for your custom schemes at
+// the beginning of program initialization, and then LockStandardSchemes. This
+// prevents future callers from mistakenly calling AddStandardScheme when the
+// program is running with multiple threads, where such usage would be
+// dangerous.
+//
+// We could have had AddStandardScheme use a lock instead, but that would add
+// some platform-specific dependencies we don't otherwise have now, and is
+// overkill considering the normal usage is so simple.
+GURL_API void LockStandardSchemes();
+
+// Locates the scheme in the given string and places it into |found_scheme|,
+// which may be NULL to indicate the caller does not care about the range.
+//
+// Returns whether the given |compare| scheme matches the scheme found in the
+// input (if any). The |compare| scheme must be a valid canonical scheme or
+// the result of the comparison is undefined.
+GURL_API bool FindAndCompareScheme(const char* str,
+                                   int str_len,
+                                   const char* compare,
+                                   url_parse::Component* found_scheme);
+GURL_API bool FindAndCompareScheme(const char16* str,
+                                   int str_len,
+                                   const char* compare,
+                                   url_parse::Component* found_scheme);
+inline bool FindAndCompareScheme(const std::string& str,
+                                 const char* compare,
+                                 url_parse::Component* found_scheme) {
+  return FindAndCompareScheme(str.data(), static_cast<int>(str.size()),
+                              compare, found_scheme);
+}
+inline bool FindAndCompareScheme(const string16& str,
+                                 const char* compare,
+                                 url_parse::Component* found_scheme) {
+  return FindAndCompareScheme(str.data(), static_cast<int>(str.size()),
+                              compare, found_scheme);
+}
+
+// Returns true if the given string represents a standard URL. This means that
+// either the scheme is in the list of known standard schemes.
+GURL_API bool IsStandard(const char* spec,
+                         const url_parse::Component& scheme);
+GURL_API bool IsStandard(const char16* spec,
+                         const url_parse::Component& scheme);
+
+// TODO(brettw) remove this. This is a temporary compatibility hack to avoid
+// breaking the WebKit build when this version is synced via Chrome.
+inline bool IsStandard(const char* spec, int spec_len,
+                       const url_parse::Component& scheme) {
+  return IsStandard(spec, scheme);
+}
+
+// URL library wrappers -------------------------------------------------------
+
+// Parses the given spec according to the extracted scheme type. Normal users
+// should use the URL object, although this may be useful if performance is
+// critical and you don't want to do the heap allocation for the std::string.
+//
+// As with the url_canon::Canonicalize* functions, the charset converter can
+// be NULL to use UTF-8 (it will be faster in this case).
+//
+// Returns true if a valid URL was produced, false if not. On failure, the
+// output and parsed structures will still be filled and will be consistent,
+// but they will not represent a loadable URL.
+GURL_API bool Canonicalize(const char* spec,
+                           int spec_len,
+                           url_canon::CharsetConverter* charset_converter,
+                           url_canon::CanonOutput* output,
+                           url_parse::Parsed* output_parsed);
+GURL_API bool Canonicalize(const char16* spec,
+                           int spec_len,
+                           url_canon::CharsetConverter* charset_converter,
+                           url_canon::CanonOutput* output,
+                           url_parse::Parsed* output_parsed);
+
+// Resolves a potentially relative URL relative to the given parsed base URL.
+// The base MUST be valid. The resulting canonical URL and parsed information
+// will be placed in to the given out variables.
+//
+// The relative need not be relative. If we discover that it's absolute, this
+// will produce a canonical version of that URL. See Canonicalize() for more
+// about the charset_converter.
+//
+// Returns true if the output is valid, false if the input could not produce
+// a valid URL.
+GURL_API bool ResolveRelative(const char* base_spec,
+                              int base_spec_len,
+                              const url_parse::Parsed& base_parsed,
+                              const char* relative,
+                              int relative_length,
+                              url_canon::CharsetConverter* charset_converter,
+                              url_canon::CanonOutput* output,
+                              url_parse::Parsed* output_parsed);
+GURL_API bool ResolveRelative(const char* base_spec,
+                              int base_spec_len,
+                              const url_parse::Parsed& base_parsed,
+                              const char16* relative,
+                              int relative_length,
+                              url_canon::CharsetConverter* charset_converter,
+                              url_canon::CanonOutput* output,
+                              url_parse::Parsed* output_parsed);
+
+// Replaces components in the given VALID input url. The new canonical URL info
+// is written to output and out_parsed.
+//
+// Returns true if the resulting URL is valid.
+GURL_API bool ReplaceComponents(
+    const char* spec,
+    int spec_len,
+    const url_parse::Parsed& parsed,
+    const url_canon::Replacements<char>& replacements,
+    url_canon::CharsetConverter* charset_converter,
+    url_canon::CanonOutput* output,
+    url_parse::Parsed* out_parsed);
+GURL_API bool ReplaceComponents(
+    const char* spec,
+    int spec_len,
+    const url_parse::Parsed& parsed,
+    const url_canon::Replacements<char16>& replacements,
+    url_canon::CharsetConverter* charset_converter,
+    url_canon::CanonOutput* output,
+    url_parse::Parsed* out_parsed);
+
+// String helper functions ----------------------------------------------------
+
+// Compare the lower-case form of the given string against the given ASCII
+// string.  This is useful for doing checking if an input string matches some
+// token, and it is optimized to avoid intermediate string copies.
+//
+// The versions of this function that don't take a b_end assume that the b
+// string is NULL terminated.
+GURL_API bool LowerCaseEqualsASCII(const char* a_begin,
+                                   const char* a_end,
+                                   const char* b);
+GURL_API bool LowerCaseEqualsASCII(const char* a_begin,
+                                   const char* a_end,
+                                   const char* b_begin,
+                                   const char* b_end);
+GURL_API bool LowerCaseEqualsASCII(const char16* a_begin,
+                                   const char16* a_end,
+                                   const char* b);
+
+// Unescapes the given string using URL escaping rules.
+GURL_API void DecodeURLEscapeSequences(const char* input, int length,
+                                       url_canon::CanonOutputW* output);
+
+}  // namespace url_util
+
+#endif  // GOOGLEURL_SRC_URL_UTIL_H__

data/lib/uri_parser.rb

@@ -0,0 +1,28 @@
+require 'uri_parser/version'
+require 'uri_parser/uri_parser'
+require 'cgi'
+
+class URIParser
+  alias normalized uri
+
+  def path_and_query
+    @path_and_query ||= if query.empty?
+      path
+    else
+      "#{path}?#{query}"
+    end
+  end
+
+  def query_params
+    @query_params ||= begin
+      k_v_pairs = query.split('&')
+
+      {}.tap do |hash|
+        k_v_pairs.each do |kv|
+          key, value = kv.split('=')
+          hash[CGI.unescape(key)] = CGI.unescape(value)
+        end
+      end
+    end
+  end
+end

data/lib/uri_parser/version.rb

@@ -0,0 +1,3 @@
+class URIParser
+  VERSION = "0.0.1"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+require 'rspec'
+Dir['./spec/support/**/*.rb'].each { |f| require f }
+
+require 'uri_parser'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.debug = true
+
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+end

data/spec/uri_parser_spec.rb

@@ -0,0 +1,54 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+describe URIParser do
+  def self.describe_parsed(url, &block)
+    describe ".new('#{url}')" do
+      subject { described_class.new(url) }
+      module_eval(&block)
+    end
+  end
+
+  describe '#normalized' do
+    it 'is an alias for #uri' do
+      uri = URIParser.new('http://foo.com')
+      uri.normalized.should == 'http://foo.com/'
+    end
+  end
+
+  describe_parsed 'http://example.com/foo/bar?a=b&c=d' do
+    its(:scheme) { should == 'http' }
+    its(:host) { should == 'example.com' }
+    its(:path) { should == '/foo/bar' }
+    its(:query) { should == 'a=b&c=d' }
+    its(:valid?) { should be_true }
+    its(:uri) { should == 'http://example.com/foo/bar?a=b&c=d' }
+    its(:path_and_query) { should == '/foo/bar?a=b&c=d' }
+    its(:query_params) { should == { 'a' => 'b', 'c' => 'd' } }
+  end
+
+  describe_parsed '@#4ioasfajdkshfas' do
+    its(:valid?) { should be_false }
+  end
+
+  describe_parsed 'http://руцентр.рф/Iñtërnâtiônàlizætiøn!?i18n=true' do
+    its(:valid?) { should be_true }
+    its(:scheme) { should == 'http' }
+    its(:host) { should == 'xn--e1aqhcjdv.xn--p1ai' }
+    its(:path) { should == '/I%C3%B1t%C3%ABrn%C3%A2ti%C3%B4n%C3%A0liz%C3%A6ti%C3%B8n!' }
+    its(:query) { should == 'i18n=true' }
+    its(:uri) { should == 'http://xn--e1aqhcjdv.xn--p1ai/I%C3%B1t%C3%ABrn%C3%A2ti%C3%B4n%C3%A0liz%C3%A6ti%C3%B8n!?i18n=true' }
+  end
+
+  describe_parsed 'http://subdomain.bar.com' do
+    its(:host) { should == 'subdomain.bar.com' }
+    its(:path) { should == '/' }
+    its(:query) { should == '' }
+    its(:path_and_query) { should == '/' }
+  end
+
+  describe_parsed 'http://domain.com?a param=a value' do
+    its(:uri) { should == 'http://domain.com/?a%20param=a%20value' }
+    its(:query_params) { should == { 'a param' => 'a value' } }
+  end
+end

data/uri_parser.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "uri_parser/version"
+
+Gem::Specification.new do |s|
+  s.name        = "uri_parser"
+  s.version     = URIParser::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = %w[Myron Marston]
+  s.email       = %w[myron.marston@gmail.com]
+  s.homepage    = "https://github.com/seomoz/uri_parser"
+  s.summary     = "A fast URI parser and normalizer"
+  s.description = "Parses and normalizes URIs very quickly, using Google's URI canonicalization library"
+
+  s.rubyforge_project = "uri_parser"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.extensions    = ["ext/uri_parser/extconf.rb"]
+  s.require_paths = ["lib"]
+  s.required_ruby_version = '>= 1.9.2'
+
+  s.add_development_dependency 'rspec', '~> 2.5'
+  s.add_development_dependency 'rake-compiler', '~> 0.7.6'
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: uri_parser
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Myron
+- Marston
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-03-24 00:00:00.000000000 -07:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2152411480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :development
+  prerelease: false
+  version_requirements: *2152411480
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: &2152411020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.6
+  type: :development
+  prerelease: false
+  version_requirements: *2152411020
+description: Parses and normalizes URIs very quickly, using Google's URI canonicalization
+  library
+email:
+- myron.marston@gmail.com
+executables: []
+extensions:
+- ext/uri_parser/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- Rakefile
+- ext/uri_parser/basictypes.h
+- ext/uri_parser/extconf.h
+- ext/uri_parser/extconf.rb
+- ext/uri_parser/logging.h
+- ext/uri_parser/scoped_ptr.h
+- ext/uri_parser/string16.cc
+- ext/uri_parser/string16.h
+- ext/uri_parser/uri_parser.cc
+- ext/uri_parser/url_canon.h
+- ext/uri_parser/url_canon_etc.cc
+- ext/uri_parser/url_canon_fileurl.cc
+- ext/uri_parser/url_canon_host.cc
+- ext/uri_parser/url_canon_icu.cc
+- ext/uri_parser/url_canon_icu.h
+- ext/uri_parser/url_canon_internal.cc
+- ext/uri_parser/url_canon_internal.h
+- ext/uri_parser/url_canon_internal_file.h
+- ext/uri_parser/url_canon_ip.cc
+- ext/uri_parser/url_canon_ip.h
+- ext/uri_parser/url_canon_mailtourl.cc
+- ext/uri_parser/url_canon_path.cc
+- ext/uri_parser/url_canon_pathurl.cc
+- ext/uri_parser/url_canon_query.cc
+- ext/uri_parser/url_canon_relative.cc
+- ext/uri_parser/url_canon_stdstring.h
+- ext/uri_parser/url_canon_stdurl.cc
+- ext/uri_parser/url_common.h
+- ext/uri_parser/url_file.h
+- ext/uri_parser/url_parse.cc
+- ext/uri_parser/url_parse.h
+- ext/uri_parser/url_parse_file.cc
+- ext/uri_parser/url_parse_internal.h
+- ext/uri_parser/url_util.cc
+- ext/uri_parser/url_util.h
+- lib/uri_parser.rb
+- lib/uri_parser/version.rb
+- spec/spec_helper.rb
+- spec/uri_parser_spec.rb
+- uri_parser.gemspec
+has_rdoc: true
+homepage: https://github.com/seomoz/uri_parser
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: uri_parser
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: A fast URI parser and normalizer
+test_files:
+- spec/spec_helper.rb
+- spec/uri_parser_spec.rb