netshade-oembed_links 0.0.3

data/README

@@ -0,0 +1,68 @@
+This is the oembed_links gem.  It allows you to easily parse text and
+query configured providers for embedding information on the links
+inside the text. A sample configuration file for configuring the
+library has been included (oembed_links_example.yml), though you
+may also configure the library programmatically (see rdocs).
+
+
+
+To get started quickly (in irb):
+
+require 'oembed_links'
+OEmbed.register({:method => "NetHTTP"},
+                {:flickr => "http://www.flickr.com/services/oembed/",
+                 :vimeo => "http://www.vimeo.com/api/oembed.{format}"},
+                {:flickr => { :format => "xml", :schemes => ["http://www.flickr.com/photos/*"]},
+                 :vimeo => { :format => "json", :schemes => ["http://www.vimeo.com/*"]}})
+
+# Simple transformation
+OEmbed.transform("This is my flickr URL http://www.flickr.com/photos/bees/2341623661/ and all I did was show the URL straight to the picture")
+
+# More complex transformation
+OEmbed.transform("This is my flickr URL http://www.flickr.com/photos/bees/2341623661/ and this is a vimeo URL http://www.vimeo.com/757219 wow neat") do |r, url|
+  r.audio? { |a| "It's unlikely flickr or vimeo will give me audio" }
+  r.photo? { |p| "<img src='#{p["url"]}' alt='Sweet, a photo named #{p["title"]}' />" }
+  r.from?(:vimeo) { |v| "<div class='vimeo'>#{v['html']}</div>" }
+end
+
+# Transformation to drive affiliate links to Amazon to our department and help us buy some laptops (hint)
+OEmbed.register_provider(:oohembed,
+                         "http://oohembed.com/oohembed/",
+                         "json",
+                         "http://*.amazon.(com|co.uk|de|ca|jp)/*/(gp/product|o/ASIN|obidos/ASIN|dp)/*",
+                         "http://*.amazon.(com|co.uk|de|ca|jp)/(gp/product|o/ASIN|obidos/ASIN|dp)/*")
+OEmbed.transform("Here is a link to amazon http://www.amazon.com/Complete-Aubrey-Maturin-Novels/dp/039306011X/ref=pd_bbs_sr_2 wow") do |res, url|
+    res.matches?(/amazon/) { |d|
+      unless url =~ /(&|\?)tag=[^&]+/i
+        url += ((url.index("?")) ? "&" : "?")
+        url += "tag=wwwindystarco-20"
+      end
+      <<-EOHTML
+        <div style="text-align:center;">
+          <a href='#{url}' target='_blank'>
+            <img src='#{d['thumbnail_url']}' border='0' /><br />
+            #{d['title']} #{"<br />by #{d['author']}" if d['author']}
+          </a>
+        </div>
+      EOHTML
+    }
+end
+
+
+To get started quickly in Rails:
+
+Copy the included oembed_links_example.yml file to RAILS_ROOT/config/oembed_links.yml,
+add a dependency to the gem in your environment.rb ( config.gem "oembed_links" )
+and start your server.  That's it.
+
+
+
+
+See the rdocs for much more complete examples.  The specs directory has some examples of programmatic
+use, but the test to code ratio is slim atm.
+
+Thanks to the Indianapolis Star I&D department for open sourcing this; most notably Chris Vannoy for giving the okay.
+
+
+CZ - chris.zelenak!at!!indystar.com
+

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rubygems'
+Gem::manage_gems
+require 'rake/clean'
+require 'rake/gempackagetask'
+CLEAN.include("pkg")
+
+spec = eval(File.read("oembed_links.gemspec")) # I'm going to hell, etc. etc. 
+
+task :default => [:clean, :repackage]
+
+Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_tar = true
+end
+

data/lib/oembed_links/fetchers/net_http.rb

@@ -0,0 +1,19 @@
+require 'net/http'
+
+class OEmbed
+  module Fetchers
+    class NetHTTP
+      
+      def name
+        "NetHTTP"
+      end
+
+      def fetch(url)
+        Net::HTTP.get(URI.parse(url))
+      end
+      
+    end
+  end
+end
+
+OEmbed.register_fetcher(OEmbed::Fetchers::NetHTTP)

data/lib/oembed_links/formatters/json.rb

@@ -0,0 +1,18 @@
+require 'json'
+
+class OEmbed
+  module Formatters
+    class JSON
+      
+      def name
+        "json"
+      end
+
+      def format(txt)
+        ::JSON.parse(txt)
+      end
+      
+    end
+  end
+end
+OEmbed.register_formatter(OEmbed::Formatters::JSON)

data/lib/oembed_links/formatters/xml.rb

@@ -0,0 +1,36 @@
+require 'libxml'
+
+class OEmbed
+  module Formatters
+    class LibXML
+      
+      def name
+        "xml"
+      end
+
+      # This is an extremely naive XML doc to hash
+      # formatter.  Cases like arrays represented in
+      # XML will not work; only strings, ints and
+      # floats will be converted.
+      def format(txt)
+        parser = LibXML::XML::Parser.string(txt)
+        doc = parser.parse
+        h = { }
+        doc.root.children.each do |node|
+          unless node.name.strip.empty?
+            c = node.content
+            if c =~ /^[0-9]+$/
+              c = c.to_i
+            elsif c=~ /^[0-9]+\.[0-9]+$/
+              c = c.to_f
+            end
+            h[node.name.strip] = c
+          end
+        end
+        return h
+      end
+      
+    end
+  end
+end
+OEmbed.register_formatter(OEmbed::Formatters::LibXML)

data/lib/oembed_links/response.rb

@@ -0,0 +1,102 @@
+# The class used to represent data returned by the server.
+#
+class OEmbed
+  class Response
+
+    def initialize(provider, url, response_object)
+      @provider = provider
+      @url = url
+      @response = response_object
+      @rendered_via_provider = @rendered_via_regex = @rendered_via_type = false
+      @rendered = nil
+    end
+
+    def to_s
+      @response["html"] || @response["url"]
+    end
+
+    # If no content has been explicitly rendered for this Response,
+    # the default representation of the data will be returned.
+    def rendered_content
+      @rendered || self.to_s
+    end
+
+    # Test if this response has been returned from
+    # the given provider_name.
+    def from?(provider_name, &block)
+      if @provider.to_s === provider_name.to_s
+        if can_render_type?(:provider)
+          @rendered_via_provider = true
+          return render_content(&block)
+        end
+      end
+    end
+
+    # Test if this response came from a URL
+    # that matches the given regex.
+    def matches?(regex, &block)
+      if @url =~ regex
+        if can_render_type?(:regex)
+          @rendered_via_regex = true
+          render_content(&block)
+        end
+      end
+    end
+
+    # Lowest priority renderer, which will execute
+    # a block regardless of conditions so long as
+    # no content has yet been rendered for this response.
+    def any?(&block)
+      if can_render_type?
+        return render_content(&block)
+      end      
+    end
+
+    # Provides the mechanism to allow .audio?, .video?
+    # and other .type? checking methods. The value of the
+    # method name will be compared against the "type" field
+    # from the returned server data.
+    def method_missing(msym, *args, &block)
+      mname = msym.to_s
+      if mname[mname.size - 1, mname.size] == "?"
+        ts = mname[0..mname.size - 2]
+        if @response["type"] == ts
+          if can_render_type?(:type)
+            @rendered_via_type = true
+            return render_content(&block)
+          end
+        end
+      else
+        raise NoMethodError.new("No such method #{msym.to_s}", msym, *args)
+      end
+    end
+
+    private
+
+    # Needlessly stupid priority for rendering.
+    def can_render_type?(type = nil)
+      if type == :provider
+        !@rendered_via_provider 
+      elsif type == :regex
+        !@rendered_via_provider && !@rendered_via_regex
+      elsif type == :type
+        !@rendered_via_provider && !@rendered_via_regex && !@rendered_via_type
+      else
+        !has_rendered?
+      end
+    end
+
+    def has_rendered?
+      !@rendered.nil?
+    end
+    
+    def render_content(&block)
+      if block_given?
+        @rendered = yield(@response)
+      else
+        @rendered = self.to_s
+      end      
+    end
+    
+  end
+end

data/lib/oembed_links.rb

@@ -0,0 +1,307 @@
+require 'cgi'
+require 'uri'
+require 'yaml'
+require 'oembed_links/response'
+
+# The OEmbed class is the interface to class registration functions
+# such as register_provider, register_formatter, etc., as well as
+# the seat of the main .transform() function. If you are using OEmbed
+# inside a Rails application, the process of initialization will be
+# handled for you by the init.rb file.  Create a file called
+# oembed_links.yml inside your RAILS_ROOT/config directory, giving it
+# a format like:
+#
+#   :config:
+#     :method: "NetHTTP"
+#
+#   :providers:
+#     :provider_1: "http://provider1.com/oembed.{format}"
+#     :provider_2: "http://provider2.com/oembed.{format}"
+#
+#   :provider_1:
+#     :format: "json"
+#     :schemes:
+#       - "http://provider1.com/links/*/user/*"
+#       - "http://provider1.com/photos/*/user/*"
+#
+#   :provider_2:
+#     :format: "xml"
+#     :schemes:
+#       - "http://provider2.com/videos/*"
+#
+#
+# If you are not using the library in a Rails app, you can still create
+# a YAML file like above and register it using OEmbed.register_yaml_file("/path/to/file.yml")
+#
+# You  may also programmatically register information into the app using the
+# register function, which takes a hash of configuration options, a
+# provider hash, and the provider scheme hash.
+#
+# You may also register providers ad hoc using the OEmbed.register_provider
+# function.
+#
+# To transform text, use the OEmbed.transform function, like:
+#
+#  OEmbed.transform("This is my text and here's a picture http://www.flickr.com/path/to/a/photo")
+#
+#  OEmbed.transform("Same text http://youtube.com/videos/somevideo") do |r, url|
+#    r.from?(:youtube) { |vid| vid["html"] }
+#  end
+#
+#  See the OEmbed.transform function for more details.
+#
+#
+# The OEmbed library by default uses net/http, libxml and json libraries for
+# fetching network data, parsing xml and parsing json, respectively.  These
+# libraries are loaded by default.
+#
+# If you want to write your own mechanism for fetching HTTP data, parsing XML
+# data, JSON data, or some other format, see the OEmbed::Fetchers::NetHTTP and
+# OEmbed::Formatters::JSON for simple examples in terms of API.  Once your new
+# class mirrors these classes, you can register it with OEmbed by using
+# OEmbed.register_formatter(class) or OEmbed.register_fetcher(class).
+#
+# NOTE that the default formatters and fetcher are EXTREMELY naive.  There is no
+# attempt at error handling, connection timeouts, or the like. If you need richer
+# functionality you should subclass the existing formatters / fetchers and register them.
+#
+class OEmbed
+
+  # Configure OEmbed with all necessary information  - library configuration,
+  # oembed provider urls, and the supported schemes and formats of said providers.
+  #
+  # The configuration hash should follow the form:
+  # { :method => "NameOfFetcher" }
+  # Note that the name of the fetcher is NOT the classname, but the arbitrarily
+  # chosen name provided by that class' .name() method.  By default, it will
+  # be NetHTTP.
+  #
+  # The provider hash will be a hash where the keys are the symbolic names of the
+  # providers, eg. :vimeo, and the values are the URL strings used to query those providers.
+  # You may use the substring {format} inside these URLs to indicate that the
+  # given provider URL requires the format desired to be inserted at that point.
+  # Whatever format you have configured that provider for in the provider_scheme_hash
+  # will be inserted when they are queried.
+  #
+  # The provider_scheme_hash is a hash with two keys - the first key is the format
+  # key, which will either be the string "json" or the string "xml".  The other
+  # key will be the schemes key, which contains an array of supported URL schemes
+  # by the provider.
+  #
+  # It is assumed that all hashes passed in use symbols for keys.  Do not use string
+  # keys. This decision is totally arbitrary and without any technical merit.
+  #
+  # It is assumed that all provider names are symbols.  Same rules as above.
+  #
+  def self.register(config_hash = { }, provider_hash = { }, provider_scheme_hash = { })
+    @fetch_method = (config_hash[:method] || "NetHTTP")
+    @config = config_hash
+    provider_hash.each do |provider, url|
+      config = provider_scheme_hash[provider]
+      raise "No Schemes were provided for #{provider.to_s}" if config.nil? ||
+                                                               config[:schemes].nil? ||
+                                                               config[:schemes].empty?
+      self.register_provider(provider, url, config[:format] || "json", *config[:schemes])
+    end
+  end
+
+  # The configuration hash passed into register() or parsed from the YAML file
+  def self.config
+    @config
+  end
+
+  # Register a provider with OEmbed.  The provider name should be a symbol,
+  # like :flickr.  The URL should be a string representing the endpoint
+  # for that provider, and may include the {format} substring to indicate
+  # how that provider should be notified of the desired format.
+  # format is either the string "json", or the string "xml".
+  # The list of schemes is an array of strings representing the different
+  # URL schemes supported by the provider.  These strings follow the form:
+  #
+  # http://*.somedomain.*/*/*
+  #
+  # All schemes should use * to indicate variable text matched until the
+  # next non-* character or end of line.
+  def self.register_provider(provider, url, format = "json", *schemes)
+    @schemes ||= [ ]
+    @urls ||= { }
+    @formats ||= { }
+    
+    @formats[provider] = format
+    @urls[provider] = url.gsub(/\{format\}/i, format)
+    schemes.each do |scheme|
+      sanitized_scheme = scheme.gsub(/([\.\?])/) { |str| "\\#{$1}" }.gsub(/\*/, '.+?')
+      @schemes << [Regexp.new("^" + sanitized_scheme + "$"), provider]
+    end    
+  end
+
+  # Loads the YAML file at the specified path and registers
+  # its information with OEmbed.
+  def self.register_yaml_file(file)
+    y = YAML.load(File.read(file))
+    self.register(y.delete(:config),
+                  y.delete(:providers),
+                  y)
+  end
+
+  # Clear all registration information; really only valuable in testing
+  def self.clear_registrations
+    @schemes = []
+    @urls = { }
+    @formats = { }
+    @formatters = { }
+    @fetchers = { }
+    self.register_formatter(OEmbed::Formatters::LibXML)
+    self.register_formatter(OEmbed::Formatters::JSON)
+    self.register_fetcher(OEmbed::Fetchers::NetHTTP)    
+  end
+
+  # Register a new formatter.  klass is the class object of the desired formatter.
+  # A new instance of klass will be created and stored. This instance MUST
+  # respond to the methods "name" and "format".
+  def self.register_formatter(klass)
+    @formatters ||= { }
+    inst = klass.new
+    @formatters[inst.name] = inst
+  end
+
+  # Register a new fetcher. klass is the class object of the desired fetcher.
+  # A new instance of klass will be created and stored.  This instance MUST
+  # respond to the methods "name" and "fetch".
+  def self.register_fetcher(klass)
+    @fetchers ||= { }
+    inst = klass.new
+    @fetchers[inst.name] = inst
+  end
+
+  # Get the OEmbed::Response object for a given URL and provider. If you wish
+  # to pass extra attributes to the provider, provide a hash as the last attribute
+  # with keys and values representing the keys and values of the added querystring
+  # parameters.
+  def self.get_url_for_provider(url, provider, *attribs)
+    purl = @urls[provider]
+    eurl = CGI.escape(url)
+    purl += (purl.index("?")) ? "&" : "?"
+    purl += "url=#{eurl}"
+    attrib_hash = (attribs.last.is_a?(Hash)) ? attribs.last : { }
+    attrib_hash.each do |k, v|
+      purl += "&#{CGI.escape(k)}=#{CGI.escape(v)}"
+    end
+    fetcher = @fetchers[@fetch_method] || @fetchers[@fetchers.keys.first]
+    formatter = @formatters[@formats[provider]]
+    response = fetcher.fetch(purl)
+    formatter.format(response)
+  end
+
+  # Transform all URLs supported by configured providers by the passed-in
+  # block or by outputting their "html" attributes ( or "url" attributes
+  # if no "html" attribute exists ).  You may pass in a hash to specify
+  # extra parameters that should be appended to the querystrings to any
+  # matching providers (see OEmbed.get_url_for_provider).  If you pass a
+  # block to this method, that block will be executed for each URL
+  # found in txt that has a matching provider.  This block will be passed
+  # the OEmbed::Response object representing the embedding information for that
+  # url.
+  #
+  # OEmbed.transform supports two additional parameters:
+  #
+  #   use_strict:  Optionally use Ruby's stricter URI detection regex. While
+  #                this will be technically correct regex, not all URLs
+  #                use correct syntax.  If this is false, URLs will be detected
+  #                by the incredibly naive approach of finding any instance of
+  #                http:// or https://, and finding anything that is not whitespace
+  #                after that.
+  #
+  #                Example:
+  #                OEmbed.transform("all my urls are correctly formed", true)
+  #
+  #   (options hash):  This hash is used to append extra querystring parameters
+  #                to the oembed provider.  For example:
+  #                OEmbed.transform("blah", false, :max_width => 320, :max_height => 200)
+  #
+  # You may fine tune the appearance of the embedding information by using the
+  # following forms:
+  #
+  #   OEmbed.transform(some_string) do |r, url|
+  #     r.from?(:provider_name) { |content| content["html"] }
+  #     r.matches?(/some_regex_against_the_url/) { |content| content["title"] }
+  #     r.video? { |video| content["html"] }
+  #     r.audio? { |audio| content["html"] }
+  #     r.hedgehog? { |hog| content["title"] }
+  #     r.photo? { |photo| "<img src='#{photo["url"]}' title='#{photo['title']} />" }
+  #     r.any? { |anythingelse| content["title"] }
+  #   end
+  #
+  # The priority of these conditions is as follows:
+  #  The first matching block for provider (.from?(:provider_name)) takes precendence OVER
+  #  The first matching block for a URL regex (.matches?(/some_regex_against_the_url/)) takes precedence OVER
+  #  The first matching block for a type equivalent (.video?, .audio?, .hedgehog?, .photo?) takes precendence OVER
+  #  The match anything block (.any?)
+  #
+  #
+  #
+  #
+  # You do not need to specify an .any? block if you do not intend to perform any special
+  # transformations upon its data; the OEmbed::Response object will output either its html attribute
+  # (if it exists) or its url attribute.
+  #
+  # The value passed to these conditional blocks is a hash representing the data returned
+  # by the server.  The keys of all the attributes will be strings.
+  #
+  # NOTE: The type equivalent blocks (.video?, .audio?, .hedgehog?, .photo?, etc.) perform
+  # an equality test between the method name and the type returned by the OEmbed provider.
+  # You may specify any type name you wish as the method name, and its type will be checked
+  # appropriately (as shown by the obviously trivial .hedgehog? method name).
+  #
+  def self.transform(txt, use_strict = false, *attribs, &block)
+    ret = txt.dup
+
+    if use_strict
+      URI.extract(txt, "http") do |u|
+        transform_url_for_text!(u, ret, *attribs, &block)
+      end
+    else
+      simple_extract(txt) do |u|
+        transform_url_for_text!(u, ret, *attribs, &block)
+      end
+    end
+
+    return ret
+  end
+
+  private
+
+  # stupid simple copy of URI.extract to allow for looser URI detection
+  def self.simple_extract(str, &block)
+    reg = /(https?:\/\/[^\s]+)/i
+    if block_given?
+      str.scan(reg) { yield $& }
+      nil
+    else
+      result = []
+      str.scan(reg) { result.push $& }
+      result
+    end
+  end
+
+  # extraction of inner loop of .transform(), to allow for easier
+  # parameterization of OEmbed
+  def self.transform_url_for_text!(u, txt, *attribs, &block)
+    unless (vschemes = @schemes.select { |a| u =~ a[0] }).empty?
+      regex, provider = vschemes.first
+      data = get_url_for_provider(u, provider, *attribs)
+      response = OEmbed::Response.new(provider, u, data)
+      if block.nil?
+        txt.gsub!(u, response.to_s)
+      else
+        yield(response, u)
+        txt.gsub!(u, response.rendered_content)
+      end
+    end    
+  end
+  
+  
+end
+require 'oembed_links/formatters/json'
+require 'oembed_links/formatters/xml'
+require 'oembed_links/fetchers/net_http'    

data/oembed_links.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+    s.name       = "oembed_links"
+    s.version    = "0.0.3"
+    s.author     = "Indianapolis Star"
+    s.email      = "bugs at indystar dot com"
+    s.homepage   = "http://www.indystar.com"
+    s.platform   = Gem::Platform::RUBY
+    s.summary    = "a library for using the OEmbed format (http://oembed.com/) to acquire embedding information for freetext"
+    s.files      = ["Rakefile", "README", "oembed_links_example.yml", "oembed_links.gemspec", "lib", "lib/oembed_links.rb", "lib/oembed_links", "lib/oembed_links/formatters", "lib/oembed_links/fetchers", "lib/oembed_links/response.rb", "lib/oembed_links/formatters/json.rb", "lib/oembed_links/formatters/xml.rb", "lib/oembed_links/fetchers/net_http.rb", "rails", "rails/init.rb", "spec", "spec/spec_helper.rb", "spec/oembed_links_spec.rb", "spec/oembed_links_test.yml" ]
+    s.require_path      = "lib"
+    s.has_rdoc          = true
+    s.extra_rdoc_files  = ['README']
+    s.add_dependency(%q<json>)
+    s.add_dependency(%q<libxml-ruby>)
+end

data/oembed_links_example.yml

@@ -0,0 +1,40 @@
+:config:
+  :method: "NetHTTP"
+
+:providers:
+  :oohembed: "http://oohembed.com/oohembed/"
+  :vimeo: "http://www.vimeo.com/api/oembed.{format}"
+  :hulu: "http://www.hulu.com/api/oembed.{format}"
+  :flickr: "http://www.flickr.com/services/oembed"
+
+:oohembed:
+  :format: "json"
+  :schemes:
+    - "http://*.amazon.(com|co.uk|de|ca|jp)/*/(gp/product|o/ASIN|obidos/ASIN|dp)/*"
+    - "http://*.amazon.(com|co.uk|de|ca|jp)/(gp/product|o/ASIN|obidos/ASIN|dp)/*"        
+    - "http://*.collegehumor.com/video:*"
+    - "http://*.funnyordie.com/videos/*"
+    - "http://video.google.com/videoplay?*"
+    - "http://*.imdb.com/title/tt*/"
+    - "http://*.metacafe.com/watch/*"
+    - "http://*.slideshare.net/*"
+    - "http://twitter.com/*/statuses/*"
+    - "http://*.wikipedia.org/wiki/*"
+    - "http://*.wordpress.com/yyyy/mm/dd/*"
+    - "http://*.youtube.com/watch*"
+
+:vimeo:
+  :format: "json"
+  :schemes:
+    - "http://www.vimeo.com/groups/*/*"
+    - "http://www.vimeo.com/*"
+
+:hulu:
+  :format: "xml"
+  :schemes:
+    - "http://www.hulu.com/watch/*"
+
+:flickr:
+  :format: "xml"
+  :schemes:
+    - "http://*.flickr.com/*"

data/rails/init.rb

@@ -0,0 +1,7 @@
+require 'oembed_links'
+
+yaml_file = File.join(RAILS_ROOT, "config", "oembed_links.yml")
+if File.exists?(yaml_file)
+  OEmbed::register_yaml_file(yaml_file)
+end
+

data/spec/oembed_links_spec.rb

@@ -0,0 +1,128 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe OEmbed, "registration tasks" do
+  include SpecHelper
+  
+  before(:each) do
+    OEmbed.clear_registrations
+    clear_urls
+  end
+
+  it "should default to NetHTTP if no method is specified in configuration" do
+    OEmbed.register()
+    OEmbed.instance_variable_get("@fetch_method").should == "NetHTTP"
+  end
+  
+  it "should throw an error if you provide provider URLs but no scheme or format information" do
+    lambda { OEmbed.register({ }, { :fake => "http://fake" })}.should raise_error
+  end
+
+  it "should throw an error if you don't provide any scheme urls for registration" do
+    lambda { OEmbed.register({ }, { :fake => "http://fake" }, { :fake => { :format => "json", :schemes => []}})}.should raise_error
+  end
+
+  it "should default to json format if none is specified" do
+    OEmbed.register({ }, { :fake => "http://fake" }, { :fake => { :schemes => ["http://fake/*"]}})
+    OEmbed.instance_variable_get("@formats")[:fake].should == "json"
+  end
+
+  it "should support loading a configuration via YAML" do
+    OEmbed.register_yaml_file(File.join(File.dirname(__FILE__), "oembed_links_test.yml"))
+    OEmbed.instance_variable_get("@urls").size.should == 3
+  end
+
+  it "should support ad hoc addition of providers" do
+    OEmbed.register_yaml_file(File.join(File.dirname(__FILE__), "oembed_links_test.yml"))
+    OEmbed.instance_variable_get("@urls").size.should == 3
+    OEmbed.register_provider(:test4, "http://test4/oembed.{format}", "xml", "http://test4.*/*", "http://test4.*/foo/*")
+    OEmbed.instance_variable_get("@urls").size.should == 4
+  end
+
+  it "should support adding new fetchers" do
+    
+    OEmbed.register_fetcher(FakeFetcher)
+    OEmbed.register({ :method => "fake_fetcher"},
+                    { :fake => "http://fake" },
+                    { :fake => {
+                        :format => "json",
+                        :schemes => "http://fake/*"
+                      }})
+    OEmbed.transform("http://fake/bar/baz").should == "fakecontent"
+  end
+  
+  it "should support adding new formatters" do
+    OEmbed.register_formatter(FakeFormatter)
+    OEmbed.register({ :method => "fake_fetcher"},
+                    { :fake => "http://fake" },
+                    { :fake => {
+                        :format => "fake_formatter",
+                        :schemes => "http://fake/*"
+                      }})
+    url_provides("")    
+    OEmbed.transform("http://fake/bar/baz").should == "http://fakesville"
+  end
+
+end
+
+describe OEmbed, "transforming functions" do
+  include SpecHelper
+  before(:each) do
+    OEmbed.clear_registrations
+    clear_urls
+    url_provides({
+     "html" => "foo",
+     "type" => "video"
+    }.to_json)
+    OEmbed.register_yaml_file(File.join(File.dirname(__FILE__), "oembed_links_test.yml"))
+  end
+
+  it "should always give priority to provider conditional blocks" do
+    OEmbed.transform("http://test1.net/foo") do |r, url|
+      r.any? { |a| "any" }
+      r.video? { |v| "video" }
+      r.from?(:test1) { |t| "test1" }
+      r.matches?(/./) { |m| "regex" }
+    end.should == "test1"
+  end
+
+  it "should always give priority regex conditional blocks over all others except provider" do
+    OEmbed.transform("http://test1.net/foo") do |r, url|
+      r.any? { |a| "any" }
+      r.video? { |v| "video" }
+      r.matches?(/./) { |m| "regex" }
+    end.should == "regex"
+    OEmbed.transform("http://test1.net/foo") do |r, url|
+      r.matches?(/./) { |m| "regex" }
+      r.any? { |a| "any" }
+      r.video? { |v| "video" }      
+    end.should == "regex"
+  end
+
+  it "should recognize the type of content and handle the conditional block appropriately" do
+    OEmbed.transform("http://test1.net/foo") do |r, url|
+      r.any? { |a| "any" }
+      r.video? { |v| "video" }
+    end.should == "video"
+    url_provides({
+     "html" => "bar",
+     "type" => "hedgehog"
+    }.to_json)
+    OEmbed.transform("http://test1.net/foo") do |r, url|
+      r.video? { |v| "video" }
+      r.hedgehog? { |v| "hedgey"}
+    end.should == "hedgey"    
+  end
+
+  it "should still output the content of a url if no transforming blocks match it" do
+    OEmbed.transform("http://test1.net/foo") do |r, url|
+      r.audio? { |a| "audio" }
+      r.hedgehog? { |v| "hedgey"}
+      r.from?(:test2) { |t| "test2" }
+      r.matches?(/baz/) { |m| "regex" }
+    end.should == "foo" 
+  end
+  
+  
+end
+
+

data/spec/oembed_links_test.yml

@@ -0,0 +1,26 @@
+:config:
+  :method: "NetHTTP"
+
+:providers:
+  :test1: "http://test1/dude/{format}/"
+  :test2: "http://test2.{format}"
+  :test3: "http://test3"
+
+
+:test1:
+  :format: "json"
+  :schemes:
+    - "http://test1.*/*"
+    - "http://test1/*/test/*"
+
+:test2:
+  :format: "xml"
+  :schemes:
+    - "http://test2.*/*/stuff/*"
+    - "http://test2/foo/bar/*"
+
+:test3:
+  :format: "json"
+  :schemes:
+    - "http://test3/foo/*"
+

data/spec/spec_helper.rb

@@ -0,0 +1,62 @@
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+require 'oembed_links'
+
+module SpecHelper
+  
+  def url_provides(content)
+    Net::HTTP.fake_content(content)
+  end
+
+  def clear_urls
+    Net::HTTP.clear_fakes
+  end
+  
+end
+
+require 'net/http'
+module Net
+  class HTTP
+    
+    def self.fake_content(content)
+      @content = content
+    end
+    
+
+    def self.clear_fakes
+      @content = nil
+    end
+    
+    def self.get(uri)
+      return @content
+    end
+    
+  end
+end
+
+
+require 'json'
+class FakeFetcher
+  def name
+    "fake_fetcher"
+  end
+
+  def fetch(url)
+    {
+      "url" => "fakecontent"
+    }.to_json
+  end
+end
+
+class FakeFormatter
+  def name
+    "fake_formatter"
+  end
+
+  def format(txt)
+    {
+      "url" => "http://fakesville"
+    }
+  end
+end
+
+

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: netshade-oembed_links
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Indianapolis Star
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-08 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: libxml-ruby
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: bugs at indystar dot com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- Rakefile
+- README
+- oembed_links_example.yml
+- oembed_links.gemspec
+- lib
+- lib/oembed_links.rb
+- lib/oembed_links
+- lib/oembed_links/formatters
+- lib/oembed_links/fetchers
+- lib/oembed_links/response.rb
+- lib/oembed_links/formatters/json.rb
+- lib/oembed_links/formatters/xml.rb
+- lib/oembed_links/fetchers/net_http.rb
+- rails
+- rails/init.rb
+- spec
+- spec/spec_helper.rb
+- spec/oembed_links_spec.rb
+- spec/oembed_links_test.yml
+has_rdoc: true
+homepage: http://www.indystar.com
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: a library for using the OEmbed format (http://oembed.com/) to acquire embedding information for freetext
+test_files: []
+