oh-my-embed 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3e9b3c0abc85a8a6452fe5b72c9ec7b09584cd6b
+  data.tar.gz: 352afe1e30344a73c37a8e4158c98187cc48d271
+SHA512:
+  metadata.gz: f9b7bd55bb85ea38c46bce13e3e86759477b0dc753175aa7a9f2d3d434eac911d3b55157a5e2bdc10d325482dfd40080516bd334272badc761a2eeae9e85fb41
+  data.tar.gz: 2966e93abe6f4ceba68a8f78922b792c2cb85324bcbc8e13a3be0066785f8746d7e78c85e093bfd0403ea5de77d6aded02c21eee1ad4624b84345095179ef337

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,9 @@
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.12.2
+addons:
+  code_climate:
+    repo_token: b79288caf70d78fded384188834e29819e9cb2fcb039592b5b825af39b612d89

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in oh-my-embed.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Axel Wahlen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,164 @@
+OhMyEmbed
+=================
+VERSION BADGE
+[![Build Status](https://travis-ci.org/dino115/oh-my-embed.svg?branch=master)](https://travis-ci.org/dino115/oh-my-embed)
+[![Code Climate](https://codeclimate.com/github/dino115/oh-my-embed/badges/gpa.svg)](https://codeclimate.com/github/dino115/oh-my-embed)
+[![Test Coverage](https://codeclimate.com/github/dino115/oh-my-embed/badges/coverage.svg)](https://codeclimate.com/github/dino115/oh-my-embed/coverage)
+[![Dependency Status](https://gemnasium.com/badges/github.com/dino115/oh-my-embed.svg)](https://gemnasium.com/github.com/dino115/oh-my-embed)
+
+Simple gem to interact with oembed providers. Read specs at http://www.oembed.com
+
+** WORK IN PROGRESS, not finshed yet **
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'oh-my-embed'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install oh-my-embed
+
+## Build in providers
+
+- Youtube
+- Slideshare
+- Instagram
+- Twitter
+- Facebook (Posts)
+- Facebook (Videos)
+- Flickr
+- SoundCloud
+- Kickstarter
+- Spotify
+
+If you need some other providers feel free to add them via pull request or build it for your application only by using the `OhMyEmbed::Provider` base class.
+See the custom provider section for more informations.
+
+## Usage
+
+### Basics
+First of all you have to create a `OhMyEmbed::Crawler` object and register your desired providers.
+You can use all build-in providers, select only a few or mix them up with your custom providers.
+
+```ruby
+# Crawler with all build-in providers (includes all classes you added to the OhMyEmbed::Providers module)
+crawler = OhMyEmbed::Crawler.new(all: true)
+
+# Crawler with specific providers
+crawler = OhMyEmbed::Crawler.new(:youtube, :slideshare)
+
+# Crawler with custom providers
+crawler = OhMyEmbed::Crawler.new(:youtube, MyProvider)
+
+# Crawler with all build-in and a custom provider
+crawler = OhMyEmbed::Crawler.new(MyProvider, all: true)
+```
+
+Now you can crawl for your embed code easily with the `fetch` method and get an `OhMyEmbed::Response` object.
+
+```ruby
+result = crawler.fetch('https://www.youtube.com/watch?v=EErY75MXYXI')
+
+# with additional options, piped as parameter to the endpoint
+result = crawler.fetch('https://www.youtube.com/watch?v=EErY75MXYXI', autoplay: 1)
+```
+
+You also can also ask if the url matches an registered url schema or get the provider.
+
+```ruby
+# check if url is embeddable
+crawler.embeddable?('https://www.youtube.com/watch?v=EErY75MXYXI') # => true
+
+# get the provider class
+crawler.provider_for('https://www.youtube.com/watch?v=EErY75MXYXI') # => OhMyEmbed::Providers::Youtube
+```
+
+If you want use only a single provider, then you can perform your fetch action directly on the provider too.
+
+```ruby
+OhMyEmbed::Providers::Youtube.fetch('https://www.youtube.com/watch?v=EErY75MXYXI')
+```
+
+### Response handling
+With a response object you have access to all oembed fields, described in http://oembed.com/#section2
+
+To access the raw response you can use the the `attribute` method.
+
+```ruby
+response.attributes # return all raw attributes as hash
+response.attribute(:thumbnail_url) # get a single attribute from the raw response
+```
+
+A response object provides an easy interface to the different response types and provider specific fields. (i.e. slideshare provides a thumbnail field instead of thumbnail_url)
+
+ ```ruby
+ response.type # [Symbol] one of :photo, :video, :link, :rich
+ response.provider # [OhMyEmbed::Provider]
+ response.provider_name # [String] Provider name from response or readable class name
+ response.provider_url # [String|nil]
+ response.url # [String] The provided url or original url
+ response.author # [Hash|nil] { name: [String], url: [String] }
+ response.thumbnail # [Hash|nil] { url: [String|nil], width: [Float], height: [Float] }
+ response.embed # [Hash] { html: [String|nil] Some html embed code, url: [String|nil], width: [Float|nil], height: [Float|nil] }
+ ```
+
+### Error handling
+The gem can raise the following errors. All of them are subclasses of a generic `OhMyEmbed::Error` class.
+
+- *OhMyEmbed::UnknownProvider* when you try to register an unknown provider
+- *OhMyEmbed::ProviderNotFound* when no provider matches the schema of given content url
+- *OhMyEmbed::NotFound* when the endpoint returns with 404 not found
+- *OhMyEmbed::PermissionDenied* when the endpoint returns with 401 unauthorized
+- *OhMyEmbed::FormatNotSupported* when the endpoint returns with 501 not implemented
+- *OhMyEmbed::ParseError* when the parser failed, i.e. the responded json is malformed
+
+### Custom providers
+You can create your own provider class by extending the `OhMyEmbed::Provider` base class.
+
+```ruby
+class MyProvider < OhMyEmbed::Provider
+  # The oembed endpoint must be specified
+  self.endpoint = 'https://www.example.com/oembed'
+
+  # The oembed url schemes must be specified, they are used for easy lookup
+  self.schemes = [
+    '//example.com/content/*'
+  ]
+
+  # Optional you can define the provider name, if not specified, the name will extracted from the class name
+  self.provider_name = 'My Provider'
+
+  # Optional you can use a custom mapping for the response, if your provider doesn't stick to the specification :(
+  # this merges with the default mapping, so you must only set the divergent mapping
+  self.custom_mapping = {
+    'thumbnail.url' => 'thumbnail'
+  }
+end
+```
+
+## Format
+Currently the gem supports only json as response format.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/dino115/oh-my-embed. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'oh_my_embed'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+require 'irb/completion'
+require 'irb/ext/history'
+
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/oh_my_embed.rb

@@ -0,0 +1,52 @@
+require 'active_support/all'
+
+Dir.glob(File.join(__dir__, 'oh_my_embed', '*.rb'), &method(:require))
+Dir.glob(File.join(__dir__, 'oh_my_embed', '{providers}', '*.rb'), &method(:require))
+
+module OhMyEmbed
+  # All OhMyEmbed errors inherits from a generic OhMyEmbed::Error class
+  #
+  # - OhMyEmbed::UnknownProvider
+  # - OhMyEmbed::ProviderNotFound
+  # - OhMyEmbed::NotFound
+  # - OhMyEmbed::PermissionDenied
+  # - OhMyEmbed::FormatNotSupported
+  # - OhMyEmbed::ParseError
+  class Error < StandardError; end
+
+  class UnknownProvider < OhMyEmbed::Error # nodoc #
+    def self.new(provider)
+      super("Can't register unknown provider '#{provider}'")
+    end
+  end
+
+  class ProviderNotFound < OhMyEmbed::Error # nodoc #
+    def self.new(url)
+      super("No provider found for given content_url (#{url}). Do you have registered the associated provider?")
+    end
+  end
+
+  class NotFound < OhMyEmbed::Error # nodoc #
+    def self.new(url)
+      super("No embed code for this content (#{url}) found")
+    end
+  end
+
+  class PermissionDenied < OhMyEmbed::Error # nodoc #
+    def self.new(url)
+      super("You don't have permissions to access the embed code for this content (#{url})")
+    end
+  end
+
+  class FormatNotSupported < OhMyEmbed::Error # nodoc #
+    def self.new(provider_name)
+      super("The provider '#{provider_name}' doesn't support json")
+    end
+  end
+
+  class ParseError < OhMyEmbed::Error # nodoc #
+    def self.new(provider_name, url, data_string)
+      super("Parsing failed for content (#{data_string}); Provider: #{provider_name}; URL: #{url}")
+    end
+  end
+end

data/lib/oh_my_embed/crawler.rb

@@ -0,0 +1,77 @@
+module OhMyEmbed
+  class Crawler
+    attr_reader :providers
+
+    # Initialize the OhMyEmbed::Crawler
+    #
+    # @param *providers [Symbol|OhMyEmbed::Provider|Hash] the providers to register or options as the last argument
+    def initialize(*providers)
+      @providers = Set.new
+
+      options = providers.extract_options!
+
+      register_all_build_in_providers if options[:all]
+      providers.each do |provider|
+        register provider
+      end
+    end
+
+    # Register a provider
+    #
+    # @param provider [Symbol|OhMyEmbed::Provider]
+    # @raise [OhMyEmbed::UnknownProvider] if you try to register an unknown provider
+    def register(provider)
+      if provider.is_a? Symbol
+        begin
+          provider = OhMyEmbed::Providers.const_get(provider.to_s.classify)
+        rescue NameError
+          raise OhMyEmbed::UnknownProvider.new(provider)
+        end
+      end
+
+      @providers.add provider
+    end
+
+    # Register all build in providers for this crawler
+    #
+    def register_all_build_in_providers
+      build_in_providers.each do |provider|
+        register provider
+      end
+    end
+
+    # Fetch the embed response for the given content_url
+    #
+    # @param [String] content_url
+    # @return [OhMyEmbed::Response]
+    def fetch(content_url)
+      provider = self.provider_for(content_url)
+      provider.fetch(content_url)
+    end
+
+    # Get the provider for given content_url
+    #
+    # @param [String] content_url
+    # @raise [OhMyEmbed::UnknownProvider] if no registered provider matches the given context_url
+    # @return [OhMyEmbed::Provider]
+    def provider_for(content_url)
+      @providers.find{ |provider| provider.regex =~ content_url } || raise(OhMyEmbed::ProviderNotFound.new(content_url))
+    end
+
+    # Check if any provider matches the given content_url
+    #
+    # @param [String] content_url
+    # @return [true|false]
+    def embeddable?(content_url)
+      @providers.any?{ |provider| provider.regex =~ content_url }
+    end
+
+    # Select all provider constants from the OhMyEmbed::Providers module
+    #
+    # @return [Array<Symbol>]
+    def build_in_providers
+      OhMyEmbed::Providers.constants
+        .select { |c| OhMyEmbed::Providers.const_get(c) < OhMyEmbed::Provider }
+    end
+  end
+end

data/lib/oh_my_embed/provider.rb

@@ -0,0 +1,116 @@
+module OhMyEmbed
+  ##
+  # Provider
+  class Provider
+    class_attribute :provider_name
+    class_attribute :endpoint
+    class_attribute :schemes
+    class_attribute :custom_mapping
+
+    self.provider_name = nil
+    self.endpoint = nil
+    self.custom_mapping = {}
+    self.schemes = []
+
+    def self.default_mapping
+      {
+        'type' => 'type',
+        'provider_name' => 'provider_name',
+        'provider_url' => 'provider_url',
+        'url' => 'url',
+        'title' => 'title',
+        'author.name' => 'author_name',
+        'author.url' => 'author_url',
+        'thumbnail.url' => 'thumbnail_url',
+        'thumbnail.width' => 'thumbnail_width',
+        'thumbnail.height' => 'thumbnail_height',
+        'embed.html' => 'html',
+        'embed.width' => 'width',
+        'embed.height' => 'height',
+      }
+    end
+
+    # Fetch the embed result for the provider content
+    #
+    # @param [String] url
+    # @param [Hash] params
+    #
+    # @raise [OhMyEmbed::Error] on request timeout
+    # @raise [OhMyEmbed::PermissionDenied] on request status 401
+    # @raise [OhMyEmbed::NotFound] on request status 404
+    # @raise [OhMyEmbed::FormatNotSupported] on request status 501
+    # @raise [OhMyEmbed::ParseError] on parsing error
+    #
+    # @return [OhMyEmbed::Response]
+    def self.fetch(url, params = {})
+      uri = URI.parse(self.endpoint)
+      uri.query = URI.encode_www_form(params.merge({
+        url: url,
+        format: 'json',
+      }))
+
+      connection = Net::HTTP.new(uri.host, uri.port)
+      connection.use_ssl = (uri.port == URI::HTTPS::DEFAULT_PORT)
+
+      begin
+        response = connection.get(uri.request_uri)
+      rescue Timeout::Error
+        raise OhMyEmbed::Error.new('Request timed out')
+      end
+
+      case response
+        when Net::HTTPUnauthorized
+          raise OhMyEmbed::PermissionDenied.new(url)
+        when Net::HTTPNotFound
+          raise OhMyEmbed::NotFound.new(url)
+        when Net::HTTPNotImplemented
+          raise OhMyEmbed::FormatNotSupported.new(self.name)
+        when Net::HTTPOK
+          begin
+            response_data = JSON.parse(response.body)
+          rescue
+            raise OhMyEmbed::ParseError.new(self.name, url, response.body)
+          end
+      end
+
+      OhMyEmbed::Response.new(self, url, response_data)
+    end
+
+    # Get a union regex to match the providers url schemes
+    #
+    # @return [Regexp]
+    def self.regex
+      @_regex ||= begin
+        regexes = self.schemes.map(&method(:regexify))
+        Regexp.union regexes
+      end
+    end
+
+    # Create a regular expression from an url schema, does nothing if the schema is already a Regexp
+    #
+    # @param [String|Regexp] schema
+    # @return [Regexp]
+    def self.regexify(schema)
+      if schema.is_a? Regexp
+        schema
+      else
+        schema = "(https:|http:)#{schema}" unless schema.start_with?('http')
+        Regexp.new("^#{schema.gsub('.', '\.').gsub('*', '(.*?)')}$", Regexp::IGNORECASE)
+      end
+    end
+
+    # Get the mapping hash, defaults merged with the custom mapping
+    #
+    # @return [Hash]
+    def self.mapping
+      @_mapping ||= self.default_mapping.merge(self.custom_mapping)
+    end
+
+    # Get the provider name
+    #
+    # @return [String]
+    def self.provider_name
+      instance_variable_get('@provider_name') || self.name.split('::').last
+    end
+  end
+end