vimeo_ruby 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e322bad016985f2258e442017837049fd62007364cc6338ca4e705f7b573b5d
-  data.tar.gz: 12fd20df10e0df161bb757931079f9d53aeb8468795a7ffac3f20b7ea4ed2228
+  metadata.gz: 01dae6e1170aa75d17c9762587204a75c4cd6ac9c85ad26f76e9df0e2b065284
+  data.tar.gz: 349e1169f2d8a459b7cfc946d9716cf59890f9a357e05831c65669d8f9e2d52f
 SHA512:
-  metadata.gz: c0b0eb5766fa016c12d1992e3a67e063559ac3b48c53e053d04b8897ecf3f75f79ba693200b29301b032e32e145baeec2f8e15548ab099e63ac5b288818967ef
-  data.tar.gz: 5f9507375cac59c5c9ccb88f4f40cef547fadee3e680319652585a62a247df7966e54c1750380d7a92b9c7215ea3ca53948c97428ef645707c8fbfccaf2c35c0
+  metadata.gz: af42ee627547634179a17797f019d5b063c4618946ab1c8f3a7f85f8482c02871a85fce0c7e85e3bf16b0cb1ab5bf604768106f124eb4ff72fccb9f8718dfaab
+  data.tar.gz: 2def55ff87705a2692ba4823ab395a4e3582e587bcab827a43517c0ceca96a98ba408df3bc737fe06f4e556666aeb0d31cab8cf865356a9690fd995a8b648732

data/CHANGELOG.md

@@ -1,12 +1,24 @@
 ## [Unreleased]
 
+- Extract shared/mutual attributes for `vimeo_id` and `additional_info` from `VimeoRuby::User` and `VimeoRuby::Video` to parent class `VimeoRuby::Base`.
+- Use consistent style when defining class or module level methods.
+- Switch to set Authorization header with `access_token` aka `ENV["VIMEO_ACCESS_TOKEN"]` value and use for authorization when accessing public Vimeo API endpoints vs the previous basic_auth strategy.
+- Change method signature for `VimeoRuby::get_user` method, now takes kwarg of `access_token`. Rename param in `VimeoRuby::get_video` method.
+- `VimeoRuby::Base` now initializes with access_token
+- Drop `Base::access_token` method.
+- Add kwarg for access_token in `Base::get` method.
+
+## [0.4.3] - 2022-12-29
+
+- Inject `VimeoRuby::User` class in `VimeoRuby::Video::new` as default arg.
+
 ## [0.4.2] - 2022-12-29
 
-- Refactor `VimeoRuby::User#uploaded_videos` method
+- Refactor `VimeoRuby::User#uploaded_videos` method.
 
 ## [0.4.1] - 2022-12-29
 
-- Fix erroneous minor version release (yanked 0.4.0)
+- Fix erroneous minor version release (yanked 0.4.0).
 
 ## [0.4.0] - 2022-12-29
 
@@ -22,4 +34,4 @@
 
 ## [0.1.0] - 2022-12-25
 
-- Initial release
+- Initial release.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    vimeo_ruby (0.4.2)
+    vimeo_ruby (0.5.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,4 +1,4 @@
-# VimeoRuby 0.4.2
+# VimeoRuby 0.5.0
 
 Welcome to VimeoRuby!
 
@@ -25,14 +25,12 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 First, make sure you have a Vimeo account and have access to the following credentials from your Vimeo [My Apps dashboard](https://developer.vimeo.com/apps):
 
-`access_token`, `client_identifier`, and `client_secret`
+`access_token`
 
-Once you have access to these, assign them to the following environment variables accordingly:
+Once you have a valid `access_token`, assign it to the following environment variable:
 
 ```ruby
 VIMEO_ACCESS_TOKEN=<access_token_value>
-VIMEO_CLIENT_IDENTIFIER=<client_identifier_value>
-VIMEO_CLIENT_SECRET=<client_secrete_value
 ```
 
 Now you should be ready to continue onward and experiment with this first iteration of the gem interface.
@@ -41,23 +39,26 @@ Currently there are two main classes the you should use to interface with the Vi
 
 ### Working with the VimeoRuby::User class
 
-For example, should you want to find a particular Vimeo user by their `vimeo_id`, you can make the following call:
+For example, to get the currently authenticated user:
 ```ruby
-vimeo_user = VimeoRuby::User.get_user(<vimeo_id>) # Makes http request to the Vimeo API
+vimeo_user = VimeoRuby::User.get_user(access_token: <access_token>) # Makes http request to the Vimeo API
 #=> #<VimeoRuby::User:0x000000011230df50
 ```
+Upon successfully retrieving the authenticated user, the users `access_token` will be stored on the `VimeoRuby::User` instance (`vimeo_user` in the above example code) and
+accessible for future requests via an `attr_reader` like so: `vimeo_user.access_token`
 
 Alternatively, you can call the `get_user` method on the `VimeoRuby` module itself if you wish for something a bit shorter:
 ```ruby
-vimeo_user = VimeoRuby.get_user(<vimeo_id>) # Makes http request to the Vimeo API
+vimeo_user = VimeoRuby.get_user(access_token: <access_token>) # Makes http request to the Vimeo API
 #=> #<VimeoRuby::User:0x000000011230df50
 ```
 
 With the `VimeoRuby::User` instance that was returned from the successful call we can see what methods are available by running the preceeding and the following code in an irb session with the gem loaded:
 ```ruby
 vimeo_user.methods.sort - Object.methods
-=>  [:additional_info,
-     :available_for_hire,
+=>  [:access_token,                                       
+     :additional_info,                                    
+     :available_for_hire,                                 
      :available_for_hire?,
      :base_uri,
      :bio,
@@ -66,12 +67,13 @@ vimeo_user.methods.sort - Object.methods
      :location,
      :profile_link,
      :uploaded_videos,
+     :video_collection,
      :vimeo_id]
 ```
 
 We can then take the `vimeo_user` that we currently have stored and retrieve a collection of all of the users uploaded videos with the following:
 ```ruby
-uploaded_video_collection = vimeo_user.uploaded_videos # Makes http request to the Vimeo API
+uploaded_video_collection = vimeo_user.uploaded_videos # Makes http request to the Vimeo API only if the `vimeo_user.video_collection` value is nil or if query_params have been supplied.
 # => #<VimeoRuby::User::UploadedVideoCollection:0x00000001130e98b8
 ```
 
@@ -100,11 +102,9 @@ vimeo_video = VimeoRuby.get_video(<vimeo_id>) # Makes http request to the Vimeo
 
 ## Development
 
-At the moment, you will need to create a Vimeo account to obtain your own `access_token`, `client_identifier`, and `client_secret` if you wish to work on building out an interface to any of the Vimeo API endpoints.
+At the moment, you will need to create a Vimeo account to obtain your own `access_token` if you wish to work on building out an interface to any of the Vimeo API endpoints.
 Will be working on a solution to remedy this step in the future but for now, after obtaining these, set the values to the following env vars on your local machine accordingly:
 - `VIMEO_ACCESS_TOKEN`
-- `VIMEO_CLIENT_IDENTIFIER`
-- `VIMEO_CLIENT_SECRET`
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 

data/lib/vimeo_ruby/base.rb

@@ -3,15 +3,19 @@ require "net/http"
 
 module VimeoRuby
   class Base
+    attr_reader :access_token, :vimeo_id, :additional_info
+
+    def initialize(access_token: nil, vimeo_id: nil, remaining_attrs: {})
+      @access_token = access_token
+      @vimeo_id = extract_vimeo_id_from_uri(vimeo_id)
+      @additional_info = OpenStruct.new(remaining_attrs)
+    end
+
     class << self
       def base_uri
         "https://api.vimeo.com"
       end
 
-      def access_token
-        ENV["VIMEO_ACCESS_TOKEN"]
-      end
-
       def client_identifier
         ENV["VIMEO_CLIENT_IDENTIFIER"]
       end
@@ -20,13 +24,13 @@ module VimeoRuby
         ENV["VIMEO_CLIENT_SECRET"]
       end
 
-      def get(uri, query_params: {})
+      def get(uri, query_params: {}, access_token: nil)
         uri = URI.parse(uri)
         uri.query = URI.encode_www_form(query_params)
 
         Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |https|
           request = Net::HTTP::Get.new(uri)
-          request.basic_auth(client_identifier, client_secret)
+          request["Authorization"] = "bearer #{access_token}"
 
           response = https.request(request)
           JSON.parse(response.body)

data/lib/vimeo_ruby/user.rb

@@ -1,9 +1,8 @@
 module VimeoRuby
   class User < Base
-    attr_reader :vimeo_id, :video_collection, :available_for_hire, :bio, :can_work_remotely, :location, :name, :profile_link, :additional_info
+    attr_reader :video_collection, :available_for_hire, :bio, :can_work_remotely, :location, :name, :profile_link
 
-    def initialize(attrs: {})
-      @vimeo_id = extract_vimeo_id_from_uri(attrs.delete("uri"))
+    def initialize(access_token: nil, attrs: {})
       @available_for_hire = attrs.delete("available_for_hire")
       @bio = attrs.delete("bio")
       @can_work_remotely = attrs.delete("can_work_remotely")
@@ -11,12 +10,15 @@ module VimeoRuby
       @name = attrs.delete("name")
       @profile_link = attrs.delete("link")
       @video_collection = nil
-      @additional_info = OpenStruct.new(attrs)
+      vimeo_uri_with_id = attrs.delete("uri")
+      super(access_token: access_token, vimeo_id: vimeo_uri_with_id, remaining_attrs: attrs)
     end
 
-    def self.get_user(user_id)
-      user_info = get("#{base_uri}/users/#{user_id}")
-      new(attrs: user_info)
+    class << self
+      def get_user(access_token: nil)
+        user_info = get("#{base_uri}/me", access_token: access_token)
+        new(access_token: access_token, attrs: user_info)
+      end
     end
 
     def base_uri
@@ -42,7 +44,8 @@ module VimeoRuby
     private
 
     def retrieve_video_collection(query_params)
-      uploaded_videos_response = self.class.get("#{base_uri}/users/#{vimeo_id}/videos", query_params: query_params)
+      uploaded_videos_response = self.class.get("#{base_uri}/me/videos", query_params: query_params, access_token: access_token)
+
       uploaded_videos = uploaded_videos_response["data"]
       UploadedVideoCollection.new(uploaded_videos)
     end

data/lib/vimeo_ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module VimeoRuby
-  VERSION = "0.4.2"
+  VERSION = "0.5.0"
 end

data/lib/vimeo_ruby/video.rb

@@ -1,9 +1,8 @@
 module VimeoRuby
   class Video < Base
-    attr_reader :vimeo_id, :description, :duration, :embed_html, :link, :name, :player_embed_url, :type, :user, :additional_info
+    attr_reader :description, :duration, :embed_html, :link, :name, :player_embed_url, :type, :user
 
-    def initialize(attrs: {})
-      @vimeo_id = extract_vimeo_id_from_uri(attrs.delete("uri"))
+    def initialize(attrs: {}, user_class: VimeoRuby::User)
       @description = attrs.delete("description")
       @duration = attrs.delete("duration")
       @embed_html = attrs.delete("embed").delete("html")
@@ -11,13 +10,16 @@ module VimeoRuby
       @name = attrs.delete("name")
       @player_embed_url = attrs.delete("player_embed_url")
       @type = attrs.delete("type")
-      @user = VimeoRuby::User.new(attrs: attrs.delete("user"))
-      @additional_info = OpenStruct.new(attrs)
+      @user = user_class.new(attrs: attrs.delete("user"))
+      vimeo_uri_with_id = attrs.delete("uri")
+      super(vimeo_id: vimeo_uri_with_id, remaining_attrs: attrs)
     end
 
-    def self.get_video(video_id)
-      video_info = get("#{base_uri}/videos/#{video_id}")
-      new(attrs: video_info)
+    class << self
+      def get_video(video_id)
+        video_info = get("#{base_uri}/videos/#{video_id}")
+        new(attrs: video_info)
+      end
     end
   end
 end

data/lib/vimeo_ruby.rb

@@ -10,11 +10,13 @@ require "vimeo_ruby/video"
 module VimeoRuby
   class Error < StandardError; end
 
-  def self.get_user(vimeo_id)
-    User.get_user(vimeo_id)
-  end
+  class << self
+    def get_user(access_token: nil)
+      User.get_user(access_token: access_token)
+    end
 
-  def self.get_video(vimeo_id)
-    Video.get_video(vimeo_id)
+    def get_video(video_id)
+      Video.get_video(video_id)
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vimeo_ruby
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Collin Jilbert