Consolidated the changes from many of the forks

.gitignore

@@ -7,3 +7,5 @@
 build
 dist
 *.egg-info
+
+/.idea/

CONTRIBUTORS.txt

@@ -4,4 +4,8 @@ Jannis Leidel <jannis@leidel.info>
 Nathan Borror
 Thejaswi Puthraya
 Brian Rosner
-Jonathan Stasiak
+Jonathan Stasiak
+Simon Meers
+Thomas Ashelford
+Jiří Suchan
+Aram Dulyan

oembed/core.py

@@ -1,21 +1,31 @@
+import gzip
+import logging
+import os
 import re
 import urllib2
-import gzip
+import urlparse
+try:
+    import json
+except ImportError:
+    from django.utils import simplejson as json
+try:
+    from urlparse import parse_qs
+except ImportError:
+    # (copied to urlparse from cgi in 2.6)
+    from cgi import parse_qs
 from heapq import heappush, heappop
 try:
     from cStringIO import StringIO
 except ImportError:
     from StringIO import StringIO
-try:
-    import simplejson
-except ImportError:
-    from django.utils import simplejson
+
 from django.conf import settings
 from django.utils.http import urlencode
 from django.utils.safestring import mark_safe
-from oembed.models import ProviderRule, StoredOEmbed
 from django.template.loader import render_to_string
-import logging
+
+from .models import ProviderRule, StoredOEmbed
+
 logger = logging.getLogger("oembed core")
 
 END_OVERRIDES = (')', ',', '.', '>', ']', ';')
@@ -64,28 +74,28 @@ def match_compare(x, y):
     prev_end = 0
     iter_dict = dict((r, r.finditer(text)) for r in regex_list)
 
-    # a heapq containing matches
+    # A heapq containing matches
     matches = []
 
-    # bootstrap the search with the first hit for each iterator
+    # Bootstrap the search with the first hit for each iterator
     for regex, iterator in iter_dict.items():
         try:
             match = iterator.next()
             heappush(matches, (match.start(), match))
         except StopIteration:
             iter_dict.pop(regex)
 
-    # process matches, revisiting each iterator from which a match is used
+    # Process matches, revisiting each iterator from which a match is used
     while matches:
-        # get the earliest match
+        # Get the earliest match
         start, match = heappop(matches)
         end = match.end()
         if start > prev_end:
-            # yield the text from current location to start of match
+            # Yield the text from current location to start of match
             yield (-1, text[prev_end:start])
-        # yield the match
+        # Yield the match
         yield (regex_list.index(match.re), text[start:end])
-        # get the next match from the iterator for this match
+        # Get the next match from the iterator for this match
         if match.re in iter_dict:
             try:
                 newmatch = iter_dict[match.re].next()
@@ -94,25 +104,71 @@ def match_compare(x, y):
                 iter_dict.pop(match.re)
         prev_end = end
 
-    # yield text from end of last match to end of text
+    # Yield text from end of last match to end of text
     last_bit = text[prev_end:]
     if len(last_bit) > 0:
         yield (-1, last_bit)
 
-def replace(text, max_width=MAX_WIDTH, max_height=MAX_HEIGHT):
+def build_url(endpoint, url, max_width, max_height):
+    # Split up the URL and extract GET parameters as a dictionary
+    split_url = urlparse.urlsplit(endpoint)
+    params = parse_qs(split_url[3])
+    params.update({
+        'url': url,
+        'maxwidth': max_width,
+        'maxheight': max_height,
+        'format': FORMAT,
+        })
+    # Put the URL back together with the new params and return it
+    params = urlencode(params, doseq=1)
+    return urlparse.urlunsplit(split_url[:3] + (params,) + split_url[4:])
+
+def fetch_dict(url, max_width=None, max_height=None):
+    """
+    Returns the response from the oEmbed provider as a dictionary for the 
+    give oEmbeddable URL.
+
+    Returns None if URL could not be matched to an oEmbed provider.
+
+    This does not take advantage of the StoredOEmbed cache, since the cached
+    objects don't contain all the information from the JSON. If you find
+    yourself using this function a lot, consider rolling you own caching.
+    """
+    if not max_width:
+        max_width = MAX_WIDTH
+    if not max_height:
+        max_height = MAX_HEIGHT
+    rule = None
+    for provider in ProviderRule.objects.only('regex'):
+        if re.match(provider.regex, url):
+            rule = provider
+            break
+    if rule is not None:
+        oembedurl = build_url(rule.endpoint, url, max_width, max_height)
+        # Fetch the link and parse the JSON.
+        return json.loads(fetch(oembedurl))
+
+def replace(text, max_width=None, max_height=None, template_dir='oembed'):
     """
     Scans a block of text, replacing anything matched by a ``ProviderRule``
     pattern with an OEmbed html snippet, if possible.
 
-    Templates should be stored at oembed/{format}.html, so for example:
+    Templates should be stored at {template_dir}/{format}.html, so for example:
 
         oembed/video.html
+        or
+        oembed/inline/video.html
 
     These templates are passed a context variable, ``response``, which is a 
     dictionary representation of the response.
     """
+    if not max_width:
+        max_width = MAX_WIDTH
+    if not max_height:
+        max_height = MAX_HEIGHT
+
     rules = list(ProviderRule.objects.all())
-    patterns = [re.compile(r.regex, re.I) for r in rules] # Compiled patterns from the rules
+    patterns = [re.compile(r.regex, re.I | re.U) for r in rules] # Compiled patterns from the rules
     parts = [] # The parts that we will assemble into the final return value.
     indices = [] # List of indices of parts that need to be replaced with OEmbed stuff.
     indices_rules = [] # List of indices into the rules in order for which index was gotten by.
@@ -138,9 +194,10 @@ def replace(text, max_width=MAX_WIDTH, max_height=MAX_HEIGHT):
             if to_append:
                 parts.append(to_append)
                 index += 1
-    # Now we fetch a list of all stored patterns, and put it in a dictionary 
+    # Now we fetch a list of all stored patterns, and put it in a dictionary
     # mapping the URL to to the stored model instance.
-    for stored_embed in StoredOEmbed.objects.filter(match__in=urls, max_width=max_width, max_height = max_height):
+    for stored_embed in StoredOEmbed.objects.filter(
+            match__in=urls, max_width=max_width, max_height=max_height):
         stored[stored_embed.match] = stored_embed
     # Now we're going to do the actual replacement of URL to embed.
     for i, id_to_replace in enumerate(indices):
@@ -152,24 +209,23 @@ def replace(text, max_width=MAX_WIDTH, max_height=MAX_HEIGHT):
             parts[id_to_replace] = stored[part].html
         except KeyError:
             try:
-                # Build the URL based on the properties defined in the OEmbed spec.
-                sep = "?" in rule.endpoint and "&" or "?"
-                q = urlencode({"url": part,
-                               "maxwidth": max_width,
-                               "maxheight": max_height,
-                               "format": FORMAT})
-                url = u"%s%s%s" % (rule.endpoint, sep, q)
+                url = build_url(rule.endpoint, part, max_width, max_height)
                 # Fetch the link and parse the JSON.
-                resp = simplejson.loads(fetch(url))
+                json_string = fetch(url)
+                resp = json.loads(json_string)
                 # Depending on the embed type, grab the associated template and
                 # pass it the parsed JSON response as context.
-                replacement = render_to_string('oembed/%s.html' % resp['type'], {'response': resp})
+                replacement = render_to_string(
+                    os.path.join(template_dir, '{0}.html'.format(resp['type'])),
+                    {'response': resp, 'match': part, }
+                )
                 if replacement:
                     stored_embed = StoredOEmbed.objects.create(
                         match = part,
                         max_width = max_width,
                         max_height = max_height,
                         html = replacement,
+                        json = json_string,
                     )
                     stored[stored_embed.match] = stored_embed
                     parts[id_to_replace] = replacement
@@ -182,4 +238,4 @@ def replace(text, max_width=MAX_WIDTH, max_height=MAX_HEIGHT):
             except urllib2.HTTPError:
                 parts[id_to_replace] = part
     # Combine the list into one string and return it.
-    return mark_safe(u''.join(parts))
+    return mark_safe(u''.join(parts).replace('http://','//'))

oembed/fields.py

@@ -0,0 +1,31 @@
+import re
+
+from django.core import exceptions
+from django.db import models
+
+from .models import ProviderRule
+
+class OEmbedField(models.URLField):
+    """
+    A URL pointing to an oEmbed provider.
+
+    See http://www.oembed.com/ for information on providers
+    """
+
+    description = "A URL pointing to an oEmbed provider"
+
+    def validate(self, value, model_instance):
+        for pattern in ProviderRule.objects.values_list('regex', flat=True):
+            if re.match(pattern, value):
+                return
+        raise exceptions.ValidationError('Not a valid oEmbed link')
+
+
+try:
+    from south.modelsinspector import add_introspection_rules
+except ImportError:
+    pass # No south, nevermind
+else:
+    # Tell south to treat OEmbedFields just like URLFields
+    rules = ['^%s\.OEmbedField' % (__name__.replace('.','\.'),)]
+    add_introspection_rules([], rules)