shin 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f2ef70e3ad1839ae50cc03c83431bd39b8cfa8a1
+  data.tar.gz: d524891b2e7af3b26a0d615b87066e0b0e4d715b
+SHA512:
+  metadata.gz: 644597661ad4e7af9ced7c8e1cad51517ad853add7b3be3e98a273384c20006cf1c55f404d7434a7eaf211bd022396abc7aa6eabebcd4b29ed59269aaf88f8fd
+  data.tar.gz: 5e3b98bb07b9c513c350db0451633ac6ea5f30e4102247ca6f5b9d9672bbc520bbcf20a1dd482ca8ca5ffa434b0dee6f3107aeccec7f289936a2a80b0837bc7f

data/README.textile

@@ -0,0 +1,23 @@
+h1. Shin Hye
+
+h2. What?
+
+Shin Hye is a Ruby library to talk to several different websites and data providers. The objective of the library is mostly just for the use of EPG.io.
+
+h2. Why?
+
+We use the data from several providers in EPG.io and we needed a library to provide this rather than using a file in lib/.
+
+h2. How?
+
+Set up the client
+<code>shin = Shin.new</code>
+
+Sometimes we need to provide an API for different cases such as review sites.
+To do this use:
+<code>shin = Shin.new moviezine: "a3ba5fd96ab238d8788c53683e7b72aa"</code>
+
+Then you can do:
+<code>shin.reviews.moviezine.find imdb: 'tt4201628'</code>
+
+And it will return the review for "Pinocchio (2014 TV Series)":http://www.imdb.com/title/tt4201628/:

data/lib/shin/base.rb

@@ -0,0 +1,16 @@
+module Shin
+  class Base
+    include HTTParty
+    include HTTParty::Icebox
+
+    def new
+      self
+    end
+
+    def get(url)
+      response = self.class.get(url).parsed_response
+      return [] unless response
+      response
+    end
+  end
+end

data/lib/shin/httparty_icebox.rb

@@ -0,0 +1,259 @@
+# = Icebox : Caching for HTTParty
+# 
+# Cache responses in HTTParty models [http://github.com/jnunemaker/httparty]
+# 
+# === Usage
+#
+#   class Foo
+#     include HTTParty
+#     include HTTParty::Icebox
+#     cache :store => 'file', :timeout => 600, :location => MY_APP_ROOT.join('tmp', 'cache')
+#   end
+#
+# Modeled after Martyn Loughran's APICache [http://github.com/newbamboo/api_cache]
+# and Ruby On Rails's caching [http://api.rubyonrails.org/classes/ActiveSupport/Cache.html]
+#
+# Author: Karel Minarik [www.karmi.cz]
+# 
+# === Notes
+# 
+# Thanks to Amit Chakradeo to point out objects have to be stored marhalled on FS
+# Thanks to Marlin Forbes to point out query parameters have to be include in the cache key
+# 
+# 
+
+require 'logger'
+require 'fileutils'
+require 'tmpdir'
+require 'pathname'
+require 'digest/md5'
+
+module HTTParty #:nodoc:
+  module Icebox
+
+    module ClassMethods
+
+      # Enable caching and set cache options
+      # Returns memoized cache object
+      #
+      # Following options are available, default values are in []:
+      #
+      # +store+::       Storage mechanism for cached data (memory, filesystem, your own) [memory]
+      # +timeout+::     Cache expiration in seconds [60]
+      # +logger+::      Path to logfile or logger instance [STDOUT]
+      # 
+      # Any additional options are passed to the Cache constructor
+      #
+      # Usage:
+      #
+      #   # Enable caching in HTTParty, in memory, for 1 minute
+      #   cache # Use default values
+      #
+      #   # Enable caching in HTTParty, on filesystem (/tmp), for 10 minutes
+      #   cache :store => 'file', :timeout => 600, :location => '/tmp/'
+      #
+      #   # Use your own cache store (see AbstractStore class below)
+      #   cache :store => 'memcached', :timeout => 600, :server => '192.168.1.1:1001'
+      #
+      def cache(options={})
+        options[:store]   ||= 'memory'
+        options[:timeout] ||= 60
+        logger = options[:logger]
+        @cache ||= Cache.new( options.delete(:store), options )
+      end
+
+    end
+
+    # When included, extend class with +cache+ method
+    # and redefine +get+ method to use cache
+    # 
+    def self.included(receiver) #:nodoc:
+      receiver.extend ClassMethods
+      receiver.class_eval do
+
+        # Get reponse from network
+        # TODO: Why alias :new :old is not working here? Returns NoMethodError
+        # 
+        def self.get_without_caching(path, options={})
+          perform_request Net::HTTP::Get, path, options
+        end
+
+        # Get response from cache, if available
+        # 
+        def self.get_with_caching(path, options={})
+          key = path.clone
+          key << options[:query].to_s if defined? options[:query]
+          
+          if cache.exists?(key) and not cache.stale?(key)
+            Cache.logger.debug "CACHE -- GET #{path}#{options[:query]}"
+            return cache.get(key)
+          else
+            Cache.logger.debug "/!\\ NETWORK -- GET #{path}#{options[:query]}"
+            response = get_without_caching(path, options)
+            cache.set(key, response) if response.code == 200
+            return response
+          end
+        end
+
+        # Redefine original HTTParty +get+ method to use cache
+        # 
+        def self.get(path, options={})
+          self.get_with_caching(path, options)
+        end
+
+      end
+    end
+
+    # === Cache container
+    # 
+    # Pass a store name ('memory', etc) to initializer
+    # 
+    class Cache
+      attr_accessor :store
+
+      def initialize(store, options={})
+        self.class.logger = options[:logger]
+        @store = self.class.lookup_store(store).new(options)
+      end
+
+      def get(key);            @store.get encode(key) unless stale?(key);        end
+      def set(key, value);     @store.set encode(key), value;                    end
+      def exists?(key);        @store.exists? encode(key);                       end
+      def stale?(key);         @store.stale?  encode(key);                       end
+
+      def self.logger; @logger || default_logger; end
+      def self.default_logger; logger = ::Logger.new(STDERR); end
+
+      # Pass a filename (String), IO object, Logger instance or +nil+ to silence the logger
+      def self.logger=(device); @logger = device.kind_of?(::Logger) ? device : ::Logger.new(device); end
+
+      private
+
+      # Return store class based on passed name
+      def self.lookup_store(name)
+        store_name = "#{name.capitalize}Store"
+        return Store::const_get(store_name)
+      rescue NameError => e
+        raise Store::StoreNotFound, "The cache store '#{store_name}' was not found. Did you loaded any such class?"
+      end
+
+      def encode(key); Digest::MD5.hexdigest(key); end
+    end
+
+
+    # === Cache stores
+    # 
+    module Store
+
+      class StoreNotFound < StandardError; end #:nodoc:
+
+      # ==== Abstract Store
+      # Inherit your store from this class
+      # *IMPORTANT*: Do not forget to call +super+ in your +initialize+ method!
+      # 
+      class AbstractStore
+        def initialize(options={})
+          raise ArgumentError, "You need to set the :timeout parameter" unless options[:timeout]
+          @timeout = options[:timeout]
+          message =  "Cache: Using #{self.class.to_s.split('::').last}"
+          message << " in location: #{options[:location]}" if options[:location]
+          message << " with timeout #{options[:timeout]} sec"
+          Cache.logger.info message unless options[:logger].nil?
+          return self
+        end
+        %w{set get exists? stale?}.each do |method_name|
+          define_method(method_name) { raise NoMethodError, "Please implement method set in your store class" }
+        end
+      end
+
+      # ===== Store objects in memory
+      #
+      Struct.new("TvdbResponse", :code, :body, :headers) { def to_s; self.body; end }
+      class MemoryStore < AbstractStore
+        def initialize(options={})
+          super; @store = {}; self
+        end
+        def set(key, value)
+          Cache.logger.info("Cache: set (#{key})")
+          @store[key] = [Time.now, value]; true
+        end
+        def get(key)
+          data = @store[key][1]
+          Cache.logger.info("Cache: #{data.nil? ? "miss" : "hit"} (#{key})")
+          data
+        end
+        def exists?(key)
+          !@store[key].nil?
+        end
+        def stale?(key)
+          return true unless exists?(key)
+          Time.now - created(key) > @timeout
+        end
+        private
+        def created(key)
+          @store[key][0]
+        end
+      end
+
+      # ===== Store objects on the filesystem
+      # 
+      class FileStore < AbstractStore
+        def initialize(options={})
+          super
+          options[:location] ||= Dir::tmpdir
+          @path = Pathname.new( options[:location] )
+          FileUtils.mkdir_p( @path )
+          self
+        end
+        def set(key, value)
+          Cache.logger.info("Cache: set (#{key})")
+          File.open( @path.join(key), 'w' ) { |file| Marshal.dump(value, file) }
+          true
+        end
+        def get(key)
+          data = Marshal.load(File.new(@path.join(key)))
+          Cache.logger.info("Cache: #{data.nil? ? "miss" : "hit"} (#{key})")
+          data
+        end
+        def exists?(key)
+          File.exists?( @path.join(key) )
+        end
+        def stale?(key)
+          return true unless exists?(key)
+          Time.now - created(key) > @timeout
+        end
+        private
+        def created(key)
+          File.mtime( @path.join(key) )
+        end
+      end
+    end
+
+  end
+end
+
+
+# Major parts of this code are based on architecture of ApiCache.
+# Copyright (c) 2008 Martyn Loughran
+# 
+# Other parts are inspired by the ActiveSupport::Cache in Ruby On Rails.
+# Copyright (c) 2005-2009 David Heinemeier Hansson
+# 
+# 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/lib/shin/play/svtplay.rb

@@ -0,0 +1,152 @@
+## SVT Play doesn't have an open API so let's parse their HTML
+require 'date'
+require 'time'
+
+module Shin
+  module Play
+    class Svtplay
+      
+      def new
+        self
+      end
+      
+      # Get episodes for a slug
+      def episodes(params={})
+        # Response
+        response = Base.get('http://www.svtplay.se/' + params[:slug].to_s + '/hela-program?' + URI.encode_www_form(params))
+        raise HTTPError, "The response didn't have a 200 HTTP Code. It had #{response.code}." unless response.code == 200
+        
+        # Nokogiri parse
+        @main_noko = Nokogiri::HTML response.body rescue nil
+        
+        # Can't be nil
+        if @main_noko != nil
+          # Title
+          @title = @main_noko.css('div.play_gridpage__header-wrapper > h1 > a.play_link.play_link--discreet').text.strip rescue nil
+          @next_page = @main_noko.css('div.play_gridpage__pagination').css('a')[0]['href'][/\?sida\=(\d+)/, 1].to_i rescue nil
+          
+          # Data
+          @array = {next_page: @next_page, results: []}
+          
+          # Multiple episodes
+          @main_noko.css('div#gridpage-content > article').map do |e|
+            @video_id = e.css('a')[0]['href'][/\/video\/(\d+)\//, 1].to_i rescue nil
+            @url = "http://www.svtplay.se" + e.css('a')[0]['href'] rescue nil
+            @desc = e.css('a')[0]['title'] rescue nil
+            @season = e['data-season'].to_i rescue nil
+            @episode = e['data-title'][/Avsnitt\s+(\d+)/, 1].to_i rescue nil
+            @image = e.css('a img')[0]['src'].gsub("ALTERNATES/small", "ALTERNATES/extralarge") rescue nil
+            
+            # Parse published_to
+            if pto = e['data-available']
+              # Days
+              if dayz = pto[/(\d+)\s+dag/, 1].to_i
+                @published_to = Time.parse("23:59", Date.today + dayz) rescue nil
+              else
+                @published_to = nil
+              end
+            end
+              
+      
+            # subtitle
+            if @episode > 0
+              @subtitle = e['data-title'].gsub(@title + " - ", '').gsub("Avsnitt " + @episode.to_s + ':', '').gsub("Avsnitt " + @episode.to_s, '').strip
+            else
+              @subtitle = e['data-title'].gsub(@title + " - ", '').strip
+            end
+            
+            @array[:results] << {id: @video_id, image: @image, season: @season, episode: @episode, subtitle: @subtitle, url: @url, description: @desc, published_to: @published_to}
+          end
+        else
+          raise NotValid, "Nokogiri failed to parse the HTML."
+        end
+        
+        @array.to_hashugar
+      end
+      
+      # Programs
+      def programs
+        # Response
+        response = Base.get('http://www.svtplay.se/program')
+        raise HTTPError, "The response didn't have a 200 HTTP Code. It had #{response.code}." unless response.code == 200
+        
+        # Nokogiri parse
+        @main_noko = Nokogiri::HTML response.body rescue nil
+        
+        # Foreach programs
+        @array = []
+        
+        # Cant be nil
+        if @main_noko != nil
+          @main_noko.css('ul.play_alphabetic-list > li > ul > li').map do |p|
+            sluge = p.css('a')[0]['href'].strip.gsub("/", '')
+            titlee = p.css('a').text
+            @array << {slug: sluge, title: titlee}
+          end
+          
+        else
+          raise NotValid, "Nokogiri failed to parse the HTML."
+        end
+
+        @array.to_hashugar
+      end
+      
+      # Video
+      def video(params={})
+        # Response
+        response = Base.get('http://www.svtplay.se/video/' + params[:id].to_s)
+        raise HTTPError, "The response didn't have a 200 HTTP Code. It had #{response.code}." unless response.code == 200
+        
+        # Nokogiri parse
+        @main_noko = Nokogiri::HTML response.body rescue nil
+        
+        # Cant be nil
+        if @main_noko != nil
+          # Title
+          @title = @main_noko.css("h1.play_video-area-aside__title")[0].text.strip
+          
+          # Subtitle data
+          submeta = @main_noko.css("h2.play_video-area-aside__sub-title")[0].text.strip.gsub("\n", ' ').squeeze(' ') rescue nil
+          if !submeta.nil?
+            @season = submeta[/S.song\s+(\d+)/, 1].to_i rescue nil
+            @episode = submeta[/Avsnitt\s+(\d+)/, 1].to_i rescue nil
+          end
+          
+          # Desc
+          @desc = @main_noko.css('p.play_video-area-aside__info-text')[0].text.strip rescue nil
+          
+          # Player data
+          playerdata = @main_noko.css("a.play_js-svtplayer")[0]
+          @published_on = Time.at(playerdata['data-popularity-publish-date'].to_i/1000) rescue nil
+          if playerdata['data-expires-timestamp'] != nil
+            @published_to = Time.at(playerdata['data-expires-timestamp'].to_i/1000) rescue nil
+          else
+            @published_to = nil
+          end
+          @url = playerdata['data-popularity-url'] rescue nil
+          @length = (playerdata['data-length'].to_i)/60 rescue nil
+          @image = @main_noko.css('meta[property="og:image"]')[0]['content'].gsub("ALTERNATES/medium", "ALTERNATES/extralarge") rescue nil
+          
+          # Add subtitle from playerdata
+          if submeta != nil and @episode > 0
+            @subtitle = playerdata['data-title'].gsub(@title + " - ", '').gsub("Avsnitt " + @episode.to_s + ':', '').gsub("Avsnitt " + @episode.to_s, '').strip
+            
+            @subtitle = nil if @subtitle == ""
+          else
+            @subtitle = playerdata['data-title'].gsub(@title + " - ", '').strip
+            @subtitle = nil if @subtitle == ""
+          end
+          
+          { id: params[:id].to_i, title: @title, image: @image, season: @season, episode: @episode, subtitle: @subtitle, length: @length, published_on: @published_on, published_to: @published_to, url: @url, description: @desc }.to_hashugar
+        else
+          raise NotValid, "Nokogiri failed to parse the HTML."
+        end
+      end
+      
+      
+      # Errors
+      class NotValid         < StandardError; end
+      class HTTPError        < StandardError; end
+    end
+  end
+end

data/lib/shin/play/viki.rb

@@ -0,0 +1,104 @@
+## Viki provides an open API with embeds urls etc
+## - Required options is app (id)
+
+require 'oj'
+
+module Shin
+  module Play
+    class Viki
+      
+      def new
+        self
+      end
+      
+      # Fix these before running
+      def before(params={})
+        raise MissingArgument, "You are missing the argument 'viki_app_id' which is required to use this source." unless Shin.get[:viki_app_id] != nil
+        
+        # Timestamp
+        params[:t] = Time.now.to_i
+        
+        "?app=" + Shin.get[:viki_app_id] + "&" + URI.encode_www_form(params)
+      end
+      
+      # All <category>, params can be page=num, per_page=num etc.
+      def all(category, params={})
+        query = before(params)
+        raise NotValid, "Not a valid category. Please check again." unless ["films", "series", "news", "artists"].include?(category)
+        
+        # Response
+        response = Base.get('http://api.viki.io/v5/' + category + '.json' + query)
+        data = Oj.load(response.body) rescue nil
+        ret = {more: data['more'], response: []}
+        
+        # Multiple
+        if data != nil
+          data['response'].each do |r|
+            ret[:results] << r
+          end
+        end
+        
+        
+        ret.to_hashugar
+      end
+      
+      # Search (params can be everything on the docs)
+      def search(params={})
+        query = before(params)
+        
+        # Response
+        response = Base.get('http://api.viki.io/v5/search.json' + query)
+        data = Oj.load(response.body) rescue nil
+        ret = {more: data['more'], response: []}
+        
+        # Multiple
+        if !data.empty? and data != nil
+          data['response'].each do |r|
+            ret[:results] << r
+          end
+        end
+        
+        
+        ret.to_hashugar
+      end
+      
+      # Info (can be series id, movie id, video etc)
+      def info(params={})
+        id = params[:id]
+        query = before(params)
+        
+        # Response
+        response = Base.get('http://api.viki.io/v5/containers/' + id.to_s + '.json' + query)
+        data = Oj.load(response.body) rescue nil
+        
+        data.to_hashugar
+      end
+      
+      # Episodes
+      def episodes(params={})
+        id = params[:id]
+        query = before(params)
+        
+        # Response
+        response = Base.get('http://api.viki.io/v5/containers/' + id.to_s + '/episodes.json' + query)
+        data = Oj.load(response.body) rescue nil
+        ret = {more: data['more'], response: []}
+        
+        # Multiple
+        if !data.empty? and data != nil
+          data['response'].each do |r|
+            ret[:results] << r
+          end
+        end
+        
+        ret.to_hashugar
+      end
+      
+      
+      # Errors
+      class NotValid         < StandardError; end
+      class MissingArgument  < StandardError; end
+      class HTTPError        < StandardError; end
+    end
+  end
+end

data/lib/shin/play.rb

@@ -0,0 +1,29 @@
+require_relative 'play/svtplay'
+require_relative 'play/viki'
+#require_relative 'play/tv4play'
+#require_relative 'play/urplay'
+#require_relative 'play/viaplay'
+#require_relative 'play/netflix'
+#require_relative 'play/viasat'
+#require_relative 'play/headweb'
+#require_relative 'play/film2home'
+#require_relative 'play/plejmo'
+
+module Shin
+  module Play
+    class << self
+      # I don't know why I need this
+      def new
+        self
+      end
+      
+      def svtplay
+        @svtplay ||= Svtplay.new
+      end
+      
+      def viki
+        @viki ||= Viki.new
+      end
+    end
+  end
+end

data/lib/shin/reviews/kritiker.rb

@@ -0,0 +1,33 @@
+## Kritiker provides a private API for people they allow.
+## - Needed argument is IMDB ID
+## - Required options is kritiker_token
+
+require 'oj'
+
+module Shin
+  module Reviews
+    class Kritiker
+      
+      def new
+        self
+      end
+      
+      def find(h = {})
+        raise MissingArgument, "You are missing the argument 'imdb' or 'kritiker_token' which is required to use this source." unless h[:imdb] != "" and Shin.get[:kritiker_token] == ""
+        
+        # We got the needed things
+        response = Base.get('http://api.kritiker.se/film/?imdb='+h[:imdb]+'&token='+Shin.get[:kritiker_token])
+
+        data = Oj.load(response.body) rescue nil
+        raise NotJSON, "Returned data isn't JSON. Couldn't parse it." if data == nil
+
+        year = data['datum'][/^(\d\d\d\d)/, 1].to_i unless data['datum'][/^(\d\d\d\d)/, 1].to_i == 0
+        {name: data['titel'], year: year, title: nil, rating: data['medelbetyg'].gsub(",", ".").to_f, url: data['kritiker'], votes: data['antalrecensioner'].to_i}.to_hashugar
+      end
+      
+      class NotJSON          < StandardError; end
+      class MissingArgument  < StandardError; end
+      class HTTPError        < StandardError; end
+    end
+  end
+end

data/lib/shin/reviews/moviezine.rb

@@ -0,0 +1,32 @@
+## This Call is using the Film2home site's API. So only use this if you got approved by MZ to use the data.
+## As they are very strict about it. I will move this to their API url when they get back to me sometime.
+## - Needed agruments are imdb_id (only int, but it auto removes "tt")
+
+module Shin
+  module Reviews
+    class Moviezine
+      
+      def new
+        self
+      end
+      
+      # Currently IMDB ID is the only way
+      def find(h = {})
+        raise MissingArgument, "You are missing the argument 'imdb' which is required to use this source." unless h[:imdb] != ""
+        
+        # We got the needed things
+        imdb_id_int = h[:imdb].gsub(/^tt/, "")
+        response = Base.get('https://www.film2home.se/Services/MovieZine.svc/GetReview?imdbId='+imdb_id_int.to_s)
+        
+        # Raise error if it didn't have a correct http code.
+        raise HTTPError, "The response didn't have a 200 HTTP Code. It had #{response.code}." unless response.code == 200
+        
+        data = response.parsed_response
+        {name: nil, year: nil, title: data['Title'], rating: data['Rating'].to_i, url: data['Url'], votes: nil}.to_hashugar
+      end
+      
+      class MissingArgument  < StandardError; end
+      class HTTPError        < StandardError; end
+    end
+  end
+end

data/lib/shin/reviews/russin.rb

@@ -0,0 +1,46 @@
+## Russin.nu provides this API for non-commercial usage and only if you link it back.
+## - Needed argument is title and optional is year.
+
+module Shin
+  module Reviews
+    class Russin
+      
+      def new
+        self
+      end
+      
+      def find(h = {})
+        # Search can either have title and year or only title
+        if h[:year] != ""
+          response = Base.get('http://www.russin.nu/api.php?soktitel='+URI.encode(h[:title])+"&year="+h[:year].to_s)
+        elsif h[:title] != ""
+          response = Base.get('http://www.russin.nu/api.php?soktitel='+URI.encode(h[:title]))
+        else
+          raise MissingArgument, "You are missing the argument 'title' which is required to use this source."
+        end
+       
+        # Raise error if it didn't have a correct http code.
+        raise HTTPError, "The response didn't have a 200 HTTP Code. It had #{response.code}." unless response.code == 200
+        
+        # Data, it can be multiple reviews for a single movie from different reviewers
+        doc = Nokogiri::XML(response.body)
+          
+        doc.remove_namespaces!
+        data = []
+        doc.xpath("//data/russinrecension").each do |review|
+          movie_title, movie_year = review.xpath('./filmtitel').text.split(", ")
+          title = review.xpath('./rubrik').text
+          rating = review.xpath('./betyg').text
+          url = review.xpath('./url').text
+          
+          data << {name: movie_title, year: movie_year.to_i, title: title, rating: rating.to_i, url: url, votes: nil}
+        end
+        
+        data.to_hashugar
+      end
+      
+      class MissingArgument  < StandardError; end
+      class HTTPError        < StandardError; end
+    end
+  end
+end

data/lib/shin/reviews.rb

@@ -0,0 +1,26 @@
+require_relative 'reviews/russin'
+require_relative 'reviews/moviezine'
+require_relative 'reviews/kritiker'
+
+module Shin
+  module Reviews
+    class << self
+      # I don't know why I need this
+      def new
+        self
+      end
+      
+      def russin
+        @russin ||= Russin.new
+      end
+      
+      def moviezine
+        @moviezine ||= Moviezine.new
+      end
+      
+      def kritiker
+        @kritiker ||= Kritiker.new
+      end
+    end
+  end
+end

data/lib/shin/version.rb

@@ -0,0 +1,3 @@
+module Shin
+  VERSION = "0.0.1"
+end

data/lib/shin.rb

@@ -0,0 +1,43 @@
+require_relative 'shin/version'
+require 'json'
+require 'nokogiri'
+require 'httparty'
+require 'hashugar'
+
+require_relative 'shin/httparty_icebox'
+require_relative 'shin/base'
+require_relative 'shin/reviews'
+require_relative 'shin/play'
+
+module Shin
+  class Error < RuntimeError
+  end
+end
+
+module Shin
+  def self.new(*a)
+    Shin.new(*a)
+  end
+  class Shin
+    #attr_accessor :options
+    def initialize(args={})
+      @@options = args
+    end
+    
+    def self.get
+      @@options ||= {}
+    end
+    
+    def base
+      @base ||= Base.new
+    end
+    
+    def play
+      @play ||= Play.new
+    end
+    
+    def reviews
+      @reviews ||= Reviews.new
+    end
+  end
+end

data/shin.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "shin/version"
+
+Gem::Specification.new do |s|
+  s.name               = "shin"
+  s.version            = Shin::VERSION
+  s.platform           = Gem::Platform::RUBY
+  s.licenses           = ['GPL 2.0']
+
+  s.authors 		= ["Joakim Nylen"]
+  s.date 		= %q{2015-02-23}
+  s.email		= %q{me@jnylen.nu}
+  s.files       	= `git ls-files`.split($/)
+  s.test_files  	= s.files.grep(%r{^(test|spec|features)/})
+  s.homepage 		= %q{https://github.com/jnylen/shin}
+  s.require_paths 	= ["lib"]
+  s.summary 		= "Shin provides a way to fetch data from various places."
+  s.description 	= "Shin provides a way to fetch data for various places such as SVTPlay, Viasat Image, DFI, SFI etc."
+
+  # We need these for all
+  s.add_dependency(%q<nokogiri>, ["~> 1.5"])
+  s.add_runtime_dependency 'oj', '~> 2.11', '>= 2.11.1'
+  s.add_runtime_dependency 'httparty', '~> 0.6', '>= 0.6.1'
+  s.add_runtime_dependency 'hashugar', '~> 1.0', '>= 1.0.0'
+end
+

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: shin
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Joakim Nylen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.11.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.11.1
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+- !ruby/object:Gem::Dependency
+  name: hashugar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description: Shin provides a way to fetch data for various places such as SVTPlay,
+  Viasat Image, DFI, SFI etc.
+email: me@jnylen.nu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.textile
+- lib/shin.rb
+- lib/shin/base.rb
+- lib/shin/httparty_icebox.rb
+- lib/shin/play.rb
+- lib/shin/play/svtplay.rb
+- lib/shin/play/viki.rb
+- lib/shin/reviews.rb
+- lib/shin/reviews/kritiker.rb
+- lib/shin/reviews/moviezine.rb
+- lib/shin/reviews/russin.rb
+- lib/shin/version.rb
+- shin.gemspec
+homepage: https://github.com/jnylen/shin
+licenses:
+- GPL 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Shin provides a way to fetch data from various places.
+test_files: []