share_learning 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 51881b5c17d1723c09e004f02a36627054aef086
+  data.tar.gz: ff070d4da0cb833834c221eecdc5ef8f25e5bbd2
+SHA512:
+  metadata.gz: 62e1d9b8dbabc97ec0b5b664611c50fd895ba76fca95298c66c19a65897cfe503a43506f2ac3da3cef1245abfe2b33d69151cce57329b777a7e748b555751d39
+  data.tar.gz: 472b4fcb6e1f682e8eaa8f7176f0f3ca2a6f3492ab0b4203f3834881889fe1dacc4acd6cf8681a6f2ee7b75c5c38f9e9ec3775e41dcd5dee279e5db2790d7fa9

data/.gitignore

@@ -0,0 +1,9 @@
+config/
+.DS_Store
+spec/.DS_Store
+lib/.DS_Store
+spec/data/.DS_Store
+coverage/
+spec/fixtures/
+Gemfile.lock
+*.gem

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 2.3.1
+  - 2.2
+  - 2.1
+branches:
+  only:
+    - master
+script: bundle exec rake spec

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,24 @@
+MIT LICENSE
+
+Copyright (c)
+         ashleycheng <ashley830204@gmail.com>  
+			   blureze <blureze@gmail.com>
+			   meegoStar <andy19933@gmail.com>
+
+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,146 @@
+
+# share_learning
+[![Gem Version](https://badge.fury.io/rb/Share_learning.svg)](https://badge.fury.io/rb/Share_learning)
+[![Build Status](https://travis-ci.org/BlueStarAshes/Share_learning.svg?branch=master)](https://travis-ci.org/BlueStarAshes/Share_learning)   
+
+
+## Introduction
+`share_learning` is aimed to be a crowd sourcing open learning platform.
+
+It collects courses links from MOOCS like Coursera, Udacity, Udemy, etc. and relating videos links on Youtube, and lets users easily find learning resources matching their familiarity to a want-to-learn subject / topic on just one website. Users can leave suggestions, tags, and ratings to each learning resource. They can also add relating learning resource links to each subject / topic.
+
+But now it is still under construction. :sweat_smile: :beer:
+
+## Installation
+If you are working on a project, add this to your Gemfile: `gem 'share_learning'`
+
+For ad hoc installation from command line:
+
+`$ gem install share_learning`
+
+
+## Setup Youtube Credentials
+Please setup your YouTube credentials by create a project in the Google Developers Console: https://console.developers.google.com and obtain authorization credentials so your application can submit API requests. You should get a YouTube API key.
+## Usage
+
+### Coursera
+#### Command line
+To use `coursera` in command line, please type as the folling format:
+`coursera [command] [keyword]`
+
+`[command]` now includes `[title]`, and `[description]`.
+
+* `[title]`
+helps you search courses on Coursea with titles containing the `[keyword]` you give.
+
+* `[description]`
+helps you search courses on Coursea with descriptions  containing the `[keyword]` you give.
+
+
+#### In your project
+To use `coursera` in your project, `require 'share_learning'` in your code.
+
+See the following code for more detail of the usage.
+```ruby
+# Access the courses on Coursera
+courses = Coursera::CourseraCourses.find.courses
+
+# Check how many courses there are on Coursera
+total = Coursera::CourseraCourses.find.total_course_num
+
+# Access each course's title, type, ID, Slug, link, description, and photo URL
+courses.size.times do |i|
+    course = courses[i]
+    puts "Course #{sequence_number}:\n"\
+         "\tTitle: #{course[:course_name]}\n"\
+         "\tType: #{course[:course_type]}\n"\
+         "\tID: #{course[:course_id]}\n"\
+         "\tSlug: #{course[:course_slug]}\n"\
+         "\tLink: #{course[:link]}\n"\
+         "\tDescription: #{course[:description][0..100]}...\n"\
+         "\tPhoto URL: #{course[:photo_url]}\n"\
+         "\n"
+
+# Search courses with titles or descriptions containing a given keyword
+# results is an array of hash where each hash represents a course
+keyword = 'machine learning'
+results = Coursera::CourseraCourses.find.search_courses(:all, keyword)
+
+# Search courses with titles containing a given keyword
+results = Coursera::CourseraCourses.find.search_courses(:course_name, keyword)
+
+# Search courses with descriptions containing a given keyword
+results = Coursera::CourseraCourses.find.search_courses(:description, keyword)
+end
+```
+
+### Udacity
+Udacity application allows you to get the information includes title, introduction, link to the homepage and the image of the course. There are two ways to use the Udacity application:
+#### Command line
+
+BASIC USAGE: `udacity [command][feature]`  
+
+`[command]` now includes `[help]`, `[all]`, `[id]`, `[title]` and `[search]`
+ * `[help]`
+    Give the introduction of how to use it.
+ * `[all]`
+   List all the courses on Udacity.
+ * `[id]`
+   Search a particular course on Udacity with the specific course id.
+ * `[title]`
+   Search a particular course on Udacity with the specific course title.
+ * `[search]`
+   Search courses on Udacity with the keyword.
+
+`[feature]` is only needed when using the command`[id]`,`[title]` and `[search]`
+ * If you're using the command `[id]`, then `[feature]` is the course id
+ * If you're using the command `[title]`, then `[feature]` is the course title
+ * If you're using the command `[search]`, then `[feature]` is the keyword you want to search
+ * Example: `udacity id 'cs101'` or `udacity title 'Introduction to Virtual Reality'` or `udacity search 'java'`
+
+#### In your project
+
+First, `require 'Share_learning'` in your code.
+See the following example code for more usage details:
+
+```ruby
+# Access courses data
+courses = Udacity::UdacityCourse.find()
+
+# Acquire all courses information
+all_courses = courses.acquire_all_courses
+
+# Acquire course information with a given course id
+# example: courses.acquire_course_by_id('cs101')
+get_course_by_id = courses.acquire_course_by_id(course_id)
+
+
+# Acquire course information with a given course title
+# # example: courses.acquire_course_by_title('Introduction to Virtual Reality')
+get_course_by_id = courses.acquire_course_by_title(course_title)
+
+```
+
+
+
+### YouTube
+#### Command line
+* Setup environment variables: `ENV[YOUTUBE_API_KEY]`
+* USAGE: `youtube [keyword]`   
+    * `[keyword]` - helps you search and get information of playlists on YouTube.
+
+#### In your project
+* `require 'Share_learning'`     
+See the following example code for more usage details:     
+```ruby
+# Access playlists data
+playlist_data = YouTube::YouTubePlaylist.find(keyword: 'keyword')
+playlist_data.results.each.with_index do |playlist, index|
+  print "#{index + 1}. "
+  puts "Playlist on YouTube: #{playlist['title']}"
+  puts "Description: #{playlist['description']}"
+  puts "Image: #{playlist['image']}"
+  puts "URL: #{playlist['url']}"
+  puts
+end
+```

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rake/testtask'
+
+namespace :tests do
+  desc 'run all tests'
+  task all: [:spec_udacity, :spec_coursera, :spec_youtube]
+
+  task :spec_udacity do
+    sh 'ruby spec/udacity_api_spec.rb'
+    puts "\n\n"
+  end
+
+  task :spec_coursera do
+    sh 'ruby spec/coursera_api_spec.rb'
+    puts "\n\n"
+  end
+
+  task :spec_youtube do
+    sh 'ruby spec/youtube_api_spec.rb'
+    puts "\n\n"
+  end
+end
+
+desc 'delete cassette fixtures'
+task :wipe do
+  sh 'rm spec/fixtures/cassettes/*.yml' do |ok, _|
+    puts(ok ? 'Cassettes deleted' : 'No casseettes found')
+  end
+end
+
+namespace :quality do
+	desc 'run all quality checks'
+	task all: [:flog, :flay, :rubocop]
+
+	task :rubocop do
+		sh 'rubocop lib/share_learning/udacity_course.rb lib/share_learning/coursera_* lib/share_learning/youtube_playlist.rb'
+		puts "\n\n"
+	end
+
+	task :flog do
+		sh 'flog lib/share_learning/udacity_course.rb lib/share_learning/coursera_* lib/share_learning/youtube_playlist.rb'
+		puts "\n\n"
+	end
+
+	task :flay do
+		sh 'flay lib/share_learning/udacity_course.rb lib/share_learning/coursera_* lib/share_learning/youtube_playlist.rb'
+		puts "\n\n"
+	end
+end

data/bin/coursera

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), *%w(.. lib))
+require 'share_learning'
+
+def command_valid?(query)
+  %w(title description).include?(query)
+end
+
+def help
+  puts "USAGE: coursera [command] [keyword]\n\n"\
+       "[command] now includes [title], [description].\n"\
+       " - \n"\
+       " - [title]\t\t"\
+       'helps you search courses on Coursea with titles'\
+       " containing the [keyword] you give.\n"\
+       " - \n"\
+       " - [description]\t"\
+       'helps you search courses on Coursea with descriptions '\
+       "containing the [keyword] you give.\n"
+end
+
+def reject
+  help
+  exit(1)
+end
+
+def show_course(course, sequence_number)
+  puts "Course #{sequence_number}:\n"\
+       "\tTitle: #{course[:course_name]}\n"\
+       "\tType: #{course[:course_type]}\n"\
+       "\tSlug: #{course[:course_slug]}\n"\
+       "\tLink: #{course[:link]}\n"\
+       "\n"
+end
+
+def execute_command(command, keyword)
+  case command
+  when 'title'
+    method = :course_name
+  when 'description'
+    method = :description
+  end
+  reject unless keyword
+  # search_courses(search_method, keyword)
+  results = Coursera::CourseraCourses.find.search_courses(method, keyword)
+  results.size.times { |i| show_course(results[i], i + 1) }
+end
+
+command = ARGV[0]
+keyword = ARGV[1]
+keyword = keyword.downcase if keyword
+
+reject unless command_valid?(command)
+
+execute_command(command, keyword)

data/bin/udacity

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), *%w(.. lib))
+require 'share_learning'
+
+def show(course)
+  puts 'title: ' + course[:title]
+  puts 'introduction: ' + course[:intro]
+  puts 'link: ' + course[:link]
+end
+
+def help
+  puts 'USAGE: udacity [command]'
+  puts 'command: '
+  puts '  - all: show all the courses information in Udacity'
+  puts '  - id: search for a course by specific course id'
+  puts '  - title: search for a course by specific course title'
+  puts '  - search: search for courses related to the keyword'
+end
+
+def check_command_available(command)
+  case command
+  when 'help', 'all', 'id', 'title', 'search'
+  else
+    puts 'USAGE: udacity [help] [all] [id course_id] [title course_title] [search keyowrd]'
+    puts "Use 'udacity help' to see more information."
+    exit(1)
+  end
+end
+
+def check_feature_available(command, feature)
+  case command
+  when 'id'
+    unless feature
+      puts 'USAGE: udacity id [course_id]'
+      exit(1)
+    end
+  when 'title'
+    unless feature
+      puts 'USAGE: udacity title [course_title]'
+      exit(1)
+    end
+  when 'search'
+    unless feature
+      puts 'USAGE: udacity search [keyword]'
+      exit(1)
+    end
+  end
+end
+
+def action(command, feature=nil)
+  case command
+  when 'help'
+    help
+  when 'all'
+    course = Udacity::UdacityCourse.find().acquire_all_courses
+    show(course)
+  when 'id'
+    check_feature_available('id', feature)
+    course = Udacity::UdacityCourse.find().acquire_course_by_id(feature)
+    show(course)
+  when 'title'
+    check_feature_available('title', feature)
+    course = Udacity::UdacityCourse.find().acquire_course_by_title(feature)
+    show(course)
+  when 'search'
+    check_feature_available('search', feature)
+    course = Udacity::UdacityCourse.find().acquire_courses_by_keywords(feature)
+    if course.class == Array
+      course.each do |item|
+        show(item)
+        puts "\n" + "------"
+      end
+    else
+      puts 'no courses found'
+    end
+  end
+end
+
+command = ARGV[0]
+feature = ARGV[1]
+check_command_available(command)
+action(command, feature)

data/bin/youtube

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), *%w(.. lib))
+require 'share_learning'
+
+keyword = ARGV[0] || ENV['KEYWORD']
+unless keyword
+  puts 'USAGE: share_learning [keyword]'
+  exit(1)
+end
+
+playlist_data = YouTube::YouTubePlaylist.find(keyword: keyword)
+
+playlist_data.results.each.with_index do |playlist, index|
+  print "#{index + 1}. "
+  puts "Playlist on YouTube: #{playlist['title']}"
+  puts "Description: #{playlist['description']}"
+  puts "Image: #{playlist['image']}"
+  puts "URL: #{playlist['url']}"
+  puts
+end

data/lib/share_learning/coursera_api.rb

@@ -0,0 +1,110 @@
+require 'http'
+require 'json'
+
+module Coursera
+  # This class is in charge of the work involving using Coursera API
+  class CourseraApi
+    COURSERA_CATOLOG_API_URL = 'https://api.coursera.org/api/courses.v1'.freeze
+    COURSERA_COURSE_LINK_BASE = 'https://www.coursera.org/learn/'.freeze
+    BATCH_SIZE = 100
+
+    def self.total_course_num
+      @total_course_num = retrieve_total_course_num
+    end
+
+    def self.courses
+      return @courses if @courses
+      @courses = retrieve_all_courses
+    end
+
+    def self.retrieve_total_course_num
+      return @total_course_num if @total_course_num
+      # Retrieve the total number of courses on the catlog
+      course_start_num = 0
+      course_num_limit = 0
+      query_response =
+        HTTP.get(COURSERA_CATOLOG_API_URL,
+                 params: { start: course_start_num,
+                           limit: course_num_limit })
+      JSON.parse(query_response.body.to_s)['paging']['total']
+    end
+
+    def self.retrieve_all_courses
+      # Create an dump for retrieved courses
+      retrieved_courses = {}
+      # Set the relating numbers
+      batch_start = 0
+      # Retrieve courses batch by batch
+      number_of_batches.times do
+        # Jump out the loop if we know there is not any courses left
+        break if batch_start >= @total_course_num
+
+        retrieved_courses = new_batch_merged(retrieved_courses, batch_start)
+        # Increase the course number to start with next batch
+        batch_start += BATCH_SIZE
+      end
+      retrieved_courses
+    end
+
+    def self.number_of_batches
+      result = retrieve_total_course_num / BATCH_SIZE
+      result += 1 unless (@total_course_num % BATCH_SIZE).zero?
+      result
+    end
+
+    def self.new_batch_merged(retrieved_courses, course_start)
+      # Use the API to get courses response on Coursera
+      retrieved_batch =
+        query_a_batch_of_courses(course_start)
+      # Parse the response to get the desired courses data
+      parsed_batch = parse_batch_result(course_start, retrieved_batch)
+      # Merge the parsed batch of courses
+      retrieved_courses.merge(parsed_batch)
+    end
+
+    def self.query_a_batch_of_courses(course_start)
+      # Create an API response dump
+      retrieved_batch = {}
+      query_response =
+        HTTP.get(COURSERA_CATOLOG_API_URL,
+                 params: { start: course_start,
+                           limit: BATCH_SIZE,
+                           fields: 'description,photoUrl' })
+      body_str = query_response.body.to_s
+      retrieved_batch[:courses] = JSON.parse(body_str)['elements']
+      retrieved_batch
+    end
+
+    def self.parse_batch_result(course_start, retrieved_batch)
+      # Create an parsed dump
+      parsed_courses = {}
+      count = course_start
+      retrieved_batch[:courses].each do |course|
+        parsed_courses[count] = parse_course(course)
+        count += 1
+      end
+      parsed_courses
+    end
+
+    def self.parse_course(course)
+      parsed_course = {}
+      parsed_course[:course_type] = course['courseType']
+      parsed_course[:course_id] = course['id']
+      parsed_course[:course_slug] = course['slug']
+      parsed_course[:course_name] = course['name']
+      parsed_course[:link] =
+        COURSERA_COURSE_LINK_BASE + course['slug']
+      parsed_course[:description] = course['description']
+      parsed_course[:photo_url] = course['photoUrl']
+      parsed_course
+    end
+
+    private_class_method :retrieve_total_course_num
+    private_class_method :retrieve_all_courses
+    private_class_method :number_of_batches
+    private_class_method :new_batch_merged
+    private_class_method :query_a_batch_of_courses
+    private_class_method :parse_batch_result
+    private_class_method :parse_course
+  end
+end

data/lib/share_learning/coursera_courses.rb

@@ -0,0 +1,59 @@
+require_relative 'coursera_api'
+
+module Coursera
+  # This class is for Coursera courses
+  class CourseraCourses
+    attr_reader :total_course_num, :courses
+
+    def initialize(total_course_num, courses)
+      @total_course_num = total_course_num
+      @courses = courses
+    end
+
+    def self.find
+      total_course_num = CourseraApi.total_course_num
+      courses = CourseraApi.courses
+      new(total_course_num, courses)
+    end
+
+    def course_matched?(course, method, keyword)
+      available_methods = [:course_name, :description]
+      result = false
+      available_methods.each do |m|
+        next unless method == :all || m == method
+        result = true if course[m].downcase.include?(keyword)
+      end
+      result
+    end
+
+    def search_courses(method, keyword)
+      matched_courses = []
+      @courses.size.times do |i|
+        course = courses[i]
+        matched_courses.push(course) if course_matched?(course, method, keyword)
+      end
+      matched_courses
+    end
+
+    def print_all_courses
+      puts "#{@total_course_num} courses:"
+      @courses.size.times do |i|
+        print_course(@courses[i], i)
+      end
+    end
+
+    def print_course(course, sequence_number)
+      puts "Course #{sequence_number}:\n"\
+           "\tTitle: #{course[:course_name]}\n"\
+           "\tType: #{course[:course_type]}\n"\
+           "\tID: #{course[:course_id]}\n"\
+           "\tSlug: #{course[:course_slug]}\n"\
+           "\tLink: #{course[:link]}\n"\
+           "\tDescription: #{course[:description][0..100]}...\n"\
+           "\tPhoto URL: #{course[:photo_url]}\n"\
+           "\n"
+    end
+
+    private :print_course
+  end
+end

data/lib/share_learning/share_learning_version.rb

@@ -0,0 +1,3 @@
+module ShareLearning
+  VERSION = '0.2.0'.freeze
+end

data/lib/share_learning/udacity_api.rb

@@ -0,0 +1,29 @@
+require 'http'
+require 'json'
+
+module Udacity
+  # Service for all Udacity API calls
+  class UdacityAPI
+    UDACITY_URL = 'https://www.udacity.com/public-api/v0/courses'.freeze
+
+    # get all courses info in json format through RESTful API
+    def self.acquire_json_response
+      response = HTTP.get(URI.parse(UDACITY_URL))
+      JSON.parse(response)
+    end
+
+    # get total courses number
+    def self.total_course_num
+      @total_course_num = retrieve_total_course_num
+    end
+
+    def self.retrieve_total_course_num
+      return @total_course_num if @total_course_num
+
+      # Retrieve the total number of courses on the catlog
+      json_resp = acquire_json_response
+      puts json_resp.class
+      @total_course_num = json_resp['courses'].size
+    end
+  end
+end

data/lib/share_learning/udacity_course.rb

@@ -0,0 +1,101 @@
+require 'http'
+require 'json'
+require_relative 'udacity_api'
+
+module Udacity
+  # Service for all Udacity API calls
+  class UdacityCourse
+    attr_reader :json_response, :total_course_num
+
+    def initialize(udacity_api, data, total_course_num)
+      @udacity_api = udacity_api
+      @json_response = data
+      @total_course_num = total_course_num
+    end
+
+    def create_hash(title, intro, link, image)
+      { title: title, intro: intro, link: link, image: image }
+    end
+
+    # get all courses information
+    def acquire_all_courses
+      course_array = []
+      @json_response['courses'].each do |course|
+        h = create_hash(course['title'], course['summary'], \
+                        course['homepage'], course['image'])
+        course_array.push(h)
+      end
+      course_array
+    end
+
+    # get course information by course id
+    def acquire_course_by_id(id)
+      acquire_course_info('key', id)
+    end
+
+    # get course information by course title
+    def acquire_course_by_title(title)
+      acquire_course_info('title', title)
+    end
+
+    # get course information
+    def acquire_course_info(key, value)
+      @json_response['courses'].each do |course|
+        next unless course[key] == value
+        h = create_hash(course['title'], course['summary'], \
+                        course['homepage'], course['image'])
+        return h
+      end
+    end
+
+    def substring?(title, summary, keyword)
+      ((title.include? keyword) || (summary.include? keyword))
+    end
+
+    def append_course(course_array, course)
+      h = create_hash(course['title'], course['summary'], \
+                      course['homepage'], course['image'])
+      course_array.push(h)
+      course_array
+    end
+
+    def acquire_courses_by_keywords(keyword)
+      course_array = []
+      @json_response['courses'].each do |course|
+        next unless substring?(course['title'].downcase, \
+                               course['summary'].downcase, keyword.downcase)
+
+        course_array = append_course(course_array, course)
+      end
+
+      return 'no courses found' if course_array.empty?
+      course_array # return course_array if it is not empty
+    end
+
+    # # get courses by skill levels ('', 'beginner', 'intermediate', 'advanced')
+    # def acquire_courses_by_level(level)
+    #   course_array = []
+    #   @json_response['courses'].each do |course|
+    #     next unless course['level'] == level
+    #     h = create_hash(course['title'], course['summary'], \
+    #                     course['homepage'], course['image'])
+    #     course_array.push(h)
+    #   end
+    #   course_array
+    # end
+
+    # # get courses by tracks (return a list of course id)
+    # def acquire_courses_by_tracks(track_name)
+    #   @json_response['tracks'].each do |track|
+    #     next unless track['name'] == track_name
+    #     return track['courses'].inspect
+    #   end
+    # end
+
+    def self.find
+      course_data = UdacityAPI.acquire_json_response
+      total_course_num = UdacityAPI.total_course_num
+      new(UdacityAPI, course_data, total_course_num)
+    end
+  end
+end

data/lib/share_learning/youtube_api.rb

@@ -0,0 +1,26 @@
+require 'http'
+require 'json'
+
+module YouTube
+  # using YouTube API to get playlists
+  class YouTubeAPI
+    max_results = 8 # number of videos that should be returned
+    YouTube_URL = 'https://www.googleapis.com/youtube/v3/search?part=snippet&type=playlist&order=relevance&maxResults=' + max_results.to_s
+
+    def self.config=(credentials)
+      @config ? @config.update(credentials) : @config = credentials
+    end
+
+    def self.config
+      return @config if @config
+      @config = { api_key: ENV['YOUTUBE_API_KEY'] } # export YOUTUBE_API_KEY=....
+    end
+
+    # Retrieve the search results
+    def self.get_playlist(keyword)
+      search_response =
+        HTTP.get(YouTube_URL + '&q=' + keyword.split().join('+') + '&key=' + config[:api_key])
+      JSON.parse(search_response)
+    end
+  end
+end

data/lib/share_learning/youtube_playlist.rb

@@ -0,0 +1,33 @@
+require_relative 'youtube_api' 
+
+module YouTube
+  # Playlist on Youtube
+  class YouTubePlaylist
+    attr_reader :results
+
+    def initialize(data: nil)
+      @results = load_data(data)
+    end
+
+    def self.find(keyword:)
+      playlists = YouTube::YouTubeAPI.get_playlist(keyword)
+      new(data: playlists)
+    end
+
+    private
+
+    # Get information of playlists 
+    def load_data(playlists)
+      results = []
+      playlists['items'].each do |playlist|
+        title = playlist['snippet']['title']
+        des = playlist['snippet']['description']
+        image = playlist['snippet']['thumbnails']['high']['url']
+        playlistId = playlist['id']['playlistId']
+        url = 'https://www.youtube.com/channel/' + playlistId
+        results.push({'title' => title, 'description' => des, 'image' => image, 'url' => url})
+      end
+      results
+    end
+  end
+end

data/lib/share_learning.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+files = Dir.glob(File.join(File.dirname(__FILE__), 'share_learning/*.rb'))
+files.each { |lib| require_relative lib }

data/share_learning.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'share_learning/share_learning_version'
+
+Gem::Specification.new do |s|
+  s.name        =  'share_learning'
+  s.version     =  ShareLearning::VERSION
+
+  s.summary     =  'Gets learning resource from Coursera, Udacity, and Youtube.'
+  s.description =  'Extracts course\'s titles, descriptions, images and links '\
+                   'from Coursera and Udacity. '\
+                   'And searches relating resource on Youtube.'
+  s.authors     =  ['ashleycheng, blureze, meegoStar']
+  s.email       =  ['ashley830204@gmail.com', 'blureze@gmail.com', 'andy19933@gmail.com']
+
+  s.files       =  `git ls-files`.split("\n")
+  s.test_files  =  `git ls-files -- spec/*`.split("\n")
+  s.executables << 'udacity' << 'coursera' << 'youtube'
+
+  s.add_runtime_dependency 'http', '~> 2.0'
+
+  s.add_development_dependency 'minitest', '~> 5.9'
+  s.add_development_dependency 'minitest-rg', '~> 5.2'
+  s.add_development_dependency 'rake', '~> 11.2'
+  s.add_development_dependency 'vcr', '~> 3.0'
+  s.add_development_dependency 'webmock', '~> 2.1'
+  s.add_development_dependency 'simplecov', '~> 0.12'
+  s.add_development_dependency 'flog', '~> 4.4'
+  s.add_development_dependency 'flay', '~> 2.8'
+  s.add_development_dependency 'rubocop', '~> 0.44'
+  s.homepage    =  'https://github.com/BlueStarAshes/share_learning'
+  s.license     =  'MIT'
+end

data/spec/coursera_api_spec.rb

@@ -0,0 +1,48 @@
+require_relative 'coursera_api_spec_helper'
+
+describe 'Coursera API specifications' do
+  VCR.configure do |c|
+    c.cassette_library_dir = CASSETTES_FOLDER
+    c.hook_into :webmock
+  end
+
+  before do
+    VCR.insert_cassette CASSETTE_FILE, record: :new_episodes
+  end
+
+  after do
+    VCR.eject_cassette
+  end
+
+  it 'should be able to retrieve how many the courses are on the
+      Coursera catlog' do
+    coursera_courses = Coursera::CourseraCourses.find
+    coursera_courses.total_course_num.must_be :>=, 0
+  end
+
+  it 'should be able to retrieve correct number of all courses' do
+    coursera_courses = Coursera::CourseraCourses.find
+    coursera_courses.courses.size.must_equal coursera_courses.total_course_num
+  end
+
+  it 'should be able to search related courses with the given keyword' do
+    keyword = 'machine learning'
+
+    matched_courses =
+      Coursera::CourseraCourses.find.search_courses(:all, keyword)
+    matched_courses.count.must_be :>, 0
+
+    matched_courses_by_title =
+      Coursera::CourseraCourses.find.search_courses(:course_name, keyword)
+    matched_courses_by_title.count.must_be :>, 0
+
+    matched_courses_by_description =
+      Coursera::CourseraCourses.find.search_courses(:description, keyword)
+    matched_courses_by_description.count.must_be :>, 0
+
+    matched_courses.count.must_be :>=, matched_courses_by_title.count
+    matched_courses.count.must_be :>=, matched_courses_by_description.count
+    sum = matched_courses_by_title.count + matched_courses_by_description.count
+    matched_courses.count.must_be :<=, sum
+  end
+end

data/spec/coursera_api_spec_helper.rb

@@ -0,0 +1,13 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'minitest/autorun'
+require 'minitest/rg'
+require 'vcr'
+require 'webmock'
+
+require_relative '../lib/share_learning/coursera_courses.rb'
+
+FIXTURE_FOLDER = 'spec/fixtures'.freeze
+CASSETTES_FOLDER = "#{FIXTURE_FOLDER}/cassettes".freeze
+CASSETTE_FILE = 'coursera_api'.freeze

data/spec/data/course_test_data.json

@@ -0,0 +1,17 @@
+{
+	"get_course_by_id":
+		{
+			"title": "Intro to Computer Science",
+			"intro": "In this introduction to computer programming course, you’ll learn and practice key computer science concepts by building your own versions of popular web applications. You’ll learn Python, a powerful, easy-to-learn, and widely used programming language, and you’ll explore computer science basics, as you build your own search engine and social network.",
+			"link": "https://www.udacity.com/course/intro-to-computer-science--cs101?utm_medium=referral&utm_campaign=api",
+			"image": "https://lh5.ggpht.com/ITepKi-2pz4Q6lrLfv6QDNViEGIfxyupzgQwx1YgS4L8m3MFITBKWDpaZb_VoAP-zV3bEEoIbFY7mauj8HM=s0#w=1724&h=1060"
+		}
+	,
+	"get_course_by_title":
+		{
+			"title": "Intro to Java Programming",
+			"intro": "In this introductory course, you'll learn and practice essential computer science concepts using the Java programming language. You'll learn about Object Oriented Programming, a technique that allows you to use code written by other programmers in your own programs. You'll put your new Java programming skills to the test by solving real-world problems faced by software engineers.",
+			"link": "https://www.udacity.com/course/intro-to-java-programming--cs046?utm_medium=referral&utm_campaign=api",
+			"image": "https://lh4.ggpht.com/9ytiUdz0QYHwuMJFTXcNXZn4FctGW6Zszm7Aj5s7mXHHXsapIKYPL08vPWeghAjF2QmuhPiYCU2Q3kNeW7w=s0#w=1725&h=1060"
+		}
+}

data/spec/udacity_api_spec.rb

@@ -0,0 +1,64 @@
+require_relative 'udacity_api_spec_helper.rb'
+
+describe 'Udacity course' do
+  VCR.configure do |c|
+    c.cassette_library_dir = CASSETTES_FOLDER
+    c.hook_into :webmock
+  end
+
+  before do
+    VCR.insert_cassette CASSETTE_FILE, record: :new_episodes
+
+    @udacity_api = Udacity::UdacityAPI
+  end
+
+  after do
+    VCR.eject_cassette
+  end
+
+  it 'should get json response successfully' do
+    udacity = Udacity::UdacityAPI.acquire_json_response
+    udacity.nil?.must_equal false
+  end
+
+  it 'should get all courses successfully' do
+    udacity = Udacity::UdacityCourse.find()
+    all_courses = udacity.acquire_all_courses
+    all_courses.nil?.must_equal false
+  end
+
+  it 'should get course by id successfully' do
+    udacity = Udacity::UdacityCourse.find()
+    course = udacity.acquire_course_by_id('cs101')
+    course.must_equal (UDACITY_RESULT[:get_course_by_id])
+  end
+
+  it 'should get course by title successfully' do
+    udacity = Udacity::UdacityCourse.find()
+    course = udacity.acquire_course_by_title('Intro to Java Programming')
+    course.must_equal (UDACITY_RESULT[:get_course_by_title])  
+  end
+
+  it 'should get course by keywords successfully' do
+    udacity = Udacity::UdacityCourse.find()
+    course = udacity.acquire_courses_by_keywords('Java Programming')
+    course.nil?.must_equal false
+  end
+
+  it 'should get the number of course successfully' do
+    udacity = Udacity::UdacityCourse.find()
+    udacity.total_course_num.must_be :>=, 0
+  end
+
+  # it 'should get courses by level successfully' do
+  #   udacity = Udacity::UdacityCourse.find()
+  #   course = udacity.acquire_courses_by_level('beginner')
+  #   course.nil?.must_equal false
+  # end
+
+  # it 'should get courses by tracks successfully' do
+  #   udacity = Udacity::UdacityCourse.find()
+  #   course = udacity.acquire_courses_by_tracks('Data Science')
+  #   course.nil?.must_equal false
+  # end
+end

data/spec/udacity_api_spec_helper.rb

@@ -0,0 +1,18 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'minitest/autorun'
+require 'minitest/rg'
+require 'json'
+require 'yaml'
+require 'vcr'
+require 'webmock'
+
+require_relative '../lib/share_learning/udacity_api.rb'
+require_relative '../lib/share_learning/udacity_course.rb'
+
+FIXTURES_FOLDER = 'spec/fixtures'
+CASSETTES_FOLDER = "#{FIXTURES_FOLDER}/cassettes"
+CASSETTE_FILE = 'udacity_api'
+RESULT_FILE = "#{FIXTURES_FOLDER}/udacity_api_results.json"
+UDACITY_RESULT = JSON.parse(File.read(RESULT_FILE), :symbolize_names => true)

data/spec/udacity_exe_spec.rb

@@ -0,0 +1,51 @@
+require_relative 'udacity_exe_spec_helper.rb'
+
+describe 'Udacity executable files' do
+  VCR.configure do |c|
+    c.cassette_library_dir = CASSETTES_FOLDER
+    c.hook_into :webmock
+  end
+
+  before do
+    VCR.insert_cassette CASSETTE_FILE, record: :new_episodes
+  end
+
+  after do
+    VCR.eject_cassette
+  end
+
+  it 'should support help instruction' do
+    result = help
+    result.must_equal (UDACITY_RESULT['help'])
+  end
+
+  it 'should get all courses successfully' do
+    result = action('all')
+    result.nil?.must_equal false
+  end
+
+  it 'should get course by id successfully' do
+    result = action('id', 'cs101')
+    result.must_equal (UDACITY_RESULT['get_course_by_id'])
+  end
+
+  it 'should get course by title successfully' do
+    result = action('title', 'Intro to Java Programming')
+    result.must_equal (UDACITY_RESULT['get_course_by_title'])  
+  end
+
+  it 'should throw error message when given wrong command' do
+    result = check_command_available('ttt')
+    result.must_equal (UDACITY_RESULT['error_command'])
+  end
+
+  it 'should throw error message when given wrong feature for id' do
+    result = check_feature_available('ttt')
+    result.must_equal (UDACITY_RESULT['error_feature']['id'])
+  end
+
+  it 'should throw error message when given wrong feature for title' do
+    result = check_feature_available('ttt')
+    result.must_equal (UDACITY_RESULT['error_feature']['title'])
+  end
+end

data/spec/udacity_exe_spec_helper.rb

@@ -0,0 +1,16 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'minitest/autorun'
+require 'minitest/rg'
+require 'yaml'
+require 'vcr'
+require 'webmock'
+
+require 'udacity'
+
+FIXTURES_FOLDER = 'spec/fixtures'.freeze
+CASSETTES_FOLDER = "#{FIXTURES_FOLDER}/cassettes".freeze
+CASSETTE_FILE = 'udacity_exe'.freeze
+RESULT_FILE = "#{FIXTURES_FOLDER}/udacity_exe_results.yml".freeze
+UDACITY_RESULT = YAML.load(File.read(RESULT_FILE))

data/spec/youtube_api_spec.rb

@@ -0,0 +1,23 @@
+require_relative 'youtube_api_spec_helper.rb'
+
+describe 'YouTube API' do
+  VCR.configure do |c|
+    c.cassette_library_dir = CASSETTES_FOLDER
+    c.hook_into :webmock
+
+    c.filter_sensitive_data('<API_KEY>') { ENV['YOUTUBE_API_KEY'] }
+  end
+
+  before do
+    VCR.insert_cassette CASSETTE_FILE, record: :new_episodes
+  end
+
+  after do
+    VCR.eject_cassette
+  end
+
+  it 'should get playlist by keyword' do
+    courses = YouTube::YouTubePlaylist.find(keyword: 'machine learning')
+    courses.results.count.must_be :>=, 0
+  end
+end

data/spec/youtube_api_spec_helper.rb

@@ -0,0 +1,21 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'minitest/autorun'
+require 'minitest/rg'
+require 'yaml'
+require 'json'
+require 'vcr'
+require 'webmock'
+
+require_relative '../lib/share_learning'
+
+FIXTURES_FOLDER = 'fixtures'.freeze
+CASSETTES_FOLDER = "#{FIXTURES_FOLDER}/cassettes".freeze
+CASSETTE_FILE = 'youtube_api'.freeze
+
+# read credentials from a Yaml file into environment variables
+if File.file?('../config/credentials.yml')
+  credentials = YAML.load(File.read('../config/credentials.yml'))
+  ENV['YOUTUBE_API_KEY'] = credentials[:api_key]
+end

metadata

@@ -0,0 +1,226 @@
+--- !ruby/object:Gem::Specification
+name: share_learning
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- ashleycheng, blureze, meegoStar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+- !ruby/object:Gem::Dependency
+  name: minitest-rg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.2'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: flog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+- !ruby/object:Gem::Dependency
+  name: flay
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.44'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.44'
+description: Extracts course's titles, descriptions, images and links from Coursera
+  and Udacity. And searches relating resource on Youtube.
+email:
+- ashley830204@gmail.com
+- blureze@gmail.com
+- andy19933@gmail.com
+executables:
+- udacity
+- coursera
+- youtube
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/coursera
+- bin/udacity
+- bin/youtube
+- lib/share_learning.rb
+- lib/share_learning/coursera_api.rb
+- lib/share_learning/coursera_courses.rb
+- lib/share_learning/share_learning_version.rb
+- lib/share_learning/udacity_api.rb
+- lib/share_learning/udacity_course.rb
+- lib/share_learning/youtube_api.rb
+- lib/share_learning/youtube_playlist.rb
+- share_learning.gemspec
+- spec/coursera_api_spec.rb
+- spec/coursera_api_spec_helper.rb
+- spec/data/course_test_data.json
+- spec/udacity_api_spec.rb
+- spec/udacity_api_spec_helper.rb
+- spec/udacity_exe_spec.rb
+- spec/udacity_exe_spec_helper.rb
+- spec/youtube_api_spec.rb
+- spec/youtube_api_spec_helper.rb
+homepage: https://github.com/BlueStarAshes/share_learning
+licenses:
+- MIT
+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.6.8
+signing_key: 
+specification_version: 4
+summary: Gets learning resource from Coursera, Udacity, and Youtube.
+test_files:
+- spec/coursera_api_spec.rb
+- spec/coursera_api_spec_helper.rb
+- spec/data/course_test_data.json
+- spec/udacity_api_spec.rb
+- spec/udacity_api_spec_helper.rb
+- spec/udacity_exe_spec.rb
+- spec/udacity_exe_spec_helper.rb
+- spec/youtube_api_spec.rb
+- spec/youtube_api_spec_helper.rb