bitly4r 0.1.0 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8526b72584f4eeb4175cf447451f8aeb5db38d3d4285a98b710dc7d113147762
+  data.tar.gz: ab0137814f7761acf5c19c4eff4653d84e81a2f3276be962cd0edba94d44489d
+SHA512:
+  metadata.gz: 6c170ec3149dc568e58b0efec03e55566d3fa53a6df8620eb241f0c583735daf8c777b15b3128a11b95887fd69f58e2dae40b2e67d3c0584cb0e7828bfa0c616
+  data.tar.gz: 87f9651ee1d6154015f2420950c6934f0bdb42c3b5208fcab516310d24f2e8b6894c2f88deaadc216bceabef3a83a2834b8920e13bfceb4cf52d9b6c5508915f

data/CHANGELOG

@@ -1,3 +1,15 @@
+= 0.2.0
+
+    * upgrade to bit.ly API version 4.0.0
+    * upgrade to Ruby 3
+    * remove login + password + api_key, replace with Authentication Token (token)
+    * the 'stats' and 'errors' methods are obsolete
+    * a `TOKEN` environment variable must be passed to the Test Suite
+
+= 0.1.1
+
+    * the build never included 'bitly4r.gemspec'
+
 = 0.1.0
 
 	* Initial gem release of 0.1 coebase.

data/README.rdoc

@@ -2,6 +2,7 @@
 
 A Ruby API for the http://bit.ly URL-shortening service
 
+
 == SimpleClient
 
 This example uses a simpler construction and invocation technique.
@@ -10,17 +11,19 @@ For when you just need the URLs, and not any additional data.
    require 'rubygems'
    require 'bitly4r'
 
-   login, api_key = 'bitlyapidemo', 'R_0da49e0a9118ff35f52f629d2d71bf07'
+   access_token = ENV['TOKEN']
    long_url = 'http://rubyforge.org/'
 
-   client = Bitly4R.Keyed(login, api_key)
+   client = Bitly4R.Token(access_token)
 
    # shorten
    short_url = client.shorten(long_url)
+   puts "short_url = #{short_url}"
 
    # re-expand
    raise 'what the?' unless (long_url == client.expand(short_url))
 
+
 == Client
 
 This example uses a full-fledged construction and invocation technique.
@@ -29,36 +32,39 @@ The URLs are returned by the <tt>to_s</tt> methods of the Response objects, and
    require 'rubygems'
    require 'bitly4r'
 
-   login, api_key = 'bitlyapidemo', 'R_0da49e0a9118ff35f52f629d2d71bf07'
+   access_token = ENV['TOKEN']
    long_url = 'http://rubyforge.org/'
 
-   client = Bitly4R::Client.new(:login => login, :api_key => api_key)
+   client = Bitly4R::Client.new(:token => access_token)
 
    # shorten
    short_url = client.shorten(long_url).to_s
+   puts "short_url = #{short_url}"
 
    # re-expand
    raise 'aww, cmon!' unless (long_url == client.expand(short_url).to_s)
 
+
 == Support
 
+This Client uses version 4.0.0 of the API (eg. '/v4/*').
+It supports Access Token credentials.
+
 This gem supports the following API commands:
 
-* shorten
-* expand
-* info
-* stats
-* errors
+* `POST /v4/shorten`
+* `POST /v4/expand`
+* `GET /v4/bitlinks/:bitlink`
 
 For more information, see the API documentation:
 
-* http://code.google.com/p/bitly-api/wiki/ApiDocumentation
+* http://cantremember.github.io/bitly4r/
 
 == Contributing
 
 === Issue Tracking and Feature Requests
 
-* http://bitly4r.rubyforge.org
+* https://github.com/cantremember/bitly4r
 
 == Community
 

data/Rakefile

@@ -6,33 +6,30 @@ task :default => :test
 
 # SPECS ===============================================================
 
-desc 'Run specs with story style output'
-task :spec do
-  sh 'specrb --specdox -Ilib:test test/*_test.rb'
-end
-
 desc 'Run specs with unit test style output'
 task :test => FileList['test/*_test.rb'] do |t|
-  suite = t.prerequisites.map{|f| "-r#{f.chomp('.rb')}"}.join(' ')
-  sh "ruby -Ilib:test #{suite} -e ''", :verbose => false
+	suite = t.prerequisites.join(' ')
+	sh "ruby -Ilib:test #{suite}", :verbose => false
 end
 
 # PACKAGING ============================================================
 
 # Load the gemspec using the same limitations as github
 def spec
-  @spec ||=
-    begin
-      require 'rubygems/specification'
-      data = File.read('sinatra.gemspec')
-      spec = nil
-      Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
-      spec
-    end
+	@spec ||=
+		begin
+			require 'rubygems/specification'
+			data = File.read('bitly4r.gemspec')
+			spec = nil
+			#	OS X didn't like SAFE = 2
+			#		(eval):25:in `glob': Insecure operation - glob
+			Thread.new { spec = eval("$SAFE = 2\n#{data}") }.join
+			spec
+		end
 end
 
 def package(ext='')
-  "dist/sinatra-#{spec.version}" + ext
+	"dist/bitly4r-#{spec.version}" + ext
 end
 
 desc 'Build packages'
@@ -40,123 +37,85 @@ task :package => %w[.gem .tar.gz].map {|e| package(e)}
 
 desc 'Build and install as local gem'
 task :install => package('.gem') do
-  sh "gem install #{package('.gem')}"
+	sh "gem install #{package('.gem')}"
 end
 
 directory 'dist/'
 
-file package('.gem') => %w[dist/ sinatra.gemspec] + spec.files do |f|
-  sh "gem build sinatra.gemspec"
-  mv File.basename(f.name), f.name
+file package('.gem') => %w[dist/ bitly4r.gemspec] + spec.files do |f|
+	sh "gem build bitly4r.gemspec"
+	mv File.basename(f.name), f.name
 end
 
 file package('.tar.gz') => %w[dist/] + spec.files do |f|
-  sh "git archive --format=tar HEAD | gzip > #{f.name}"
+	sh "git archive --format=tar HEAD | gzip > #{f.name}"
 end
 
-# Rubyforge Release / Publish Tasks ==================================
+# Release / Publish Tasks ==================================
 
 desc 'Publish website to rubyforge'
-task 'publish:doc' => 'doc/api/index.html' do
-  sh 'scp -rp doc/* rubyforge.org:/var/www/gforge-projects/sinatra/'
-end
 
-task 'publish:gem' => [package('.gem'), package('.tar.gz')] do |t|
-  sh <<-end
-    rubyforge add_release sinatra sinatra #{spec.version} #{package('.gem')} &&
-    rubyforge add_file    sinatra sinatra #{spec.version} #{package('.tar.gz')}
-  end
+# https://guides.rubygems.org/publishing/#publishing-to-rubygemsorg
+task 'publish:gem' => [package('.gem')] do |t|
+	sh <<-end
+		gem push #{package('.gem')}
+	end
 end
 
 # Website ============================================================
-# Building docs requires HAML and the hanna gem:
-#   gem install mislav-hanna --source=http://gems.github.com
+# Building docs
 
-task 'doc'     => ['doc:api','doc:site']
+=begin
+NOTE:  i honestly don't know how `rake doc` is working
+  but it does!
 
-desc 'Generate Hanna RDoc under doc/api'
-task 'doc:api' => ['doc/api/index.html']
+Manual process for publish to Github Pages
+  http://cantremember.github.io/bitly4r/
 
-file 'doc/api/index.html' => FileList['lib/**/*.rb','README.rdoc'] do |f|
-  rb_files = f.prerequisites
-  sh((<<-end).gsub(/\s+/, ' '))
-    hanna --charset utf8 \
-          --fmt html \
-          --inline-source \
-          --line-numbers \
-          --main README.rdoc \
-          --op doc/api \
-          --title 'Sinatra API Documentation' \
-          #{rb_files.join(' ')}
-  end
-end
-CLEAN.include 'doc/api'
+```bash
+# no outstanding Git changes, then ...
+rake doc
 
-def rdoc_to_html(file_name)
-  require 'rdoc/markup/to_html'
-  rdoc = RDoc::Markup::ToHtml.new
-  rdoc.convert(File.read(file_name))
-end
+git checkout gh-pages
+cp -r doc/* .
+git add .
 
-def haml(locals={})
-  require 'haml'
-  template = File.read('doc/template.haml')
-  haml = Haml::Engine.new(template, :format => :html4, :attr_wrapper => '"')
-  haml.render(Object.new, locals)
-end
+# commit & push
+```
+=end
 
-desc 'Build website HTML and stuff'
-task 'doc:site' => ['doc/index.html', 'doc/book.html']
+task 'doc'     => ['doc:api']
 
-file 'doc/index.html' => %w[README.rdoc doc/template.haml] do |file|
-  File.open(file.name, 'w') do |file|
-    file << haml(:title => 'Sinatra', :content => rdoc_to_html('README.rdoc'))
-  end
-end
-CLEAN.include 'doc/index.html'
+desc 'Generate RDoc under doc/api'
+task 'doc:api' => ['doc/api/index.html']
 
-file 'doc/book.html' => ['book/output/sinatra-book.html'] do |file|
-  File.open(file.name, 'w') do |file|
-    book_content = File.read('book/output/sinatra-book.html')
-    file << haml(:title => 'Sinatra Book', :content => book_content)
-  end
+file 'doc/api/index.html' => FileList['lib/**/*.rb','README.rdoc','CHANGELOG','LICENSE'] do |f|
+	rb_files = f.prerequisites
+	sh((<<-end).gsub(/\s+/, ' '))
+		rdoc --line-numbers --inline-source --title Bitly4R --main README.rdoc
+			#{rb_files.join(' ')}
+	end
 end
-CLEAN.include 'doc/book.html'
-
-file 'book/output/sinatra-book.html' => FileList['book/**'] do |f|
-  unless File.directory?('book')
-    sh 'git clone git://github.com/cschneid/sinatra-book.git book'
-  end
-  sh((<<-SH).strip.gsub(/\s+/, ' '))
-    cd book &&
-    git fetch origin &&
-    git rebase origin/master &&
-    thor book:build
-  SH
-end
-CLEAN.include 'book/output/sinatra-book.html'
-
-desc 'Build the Sinatra book'
-task 'doc:book' => ['book/output/sinatra-book.html']
+CLEAN.include 'doc/api'
 
 # Gemspec Helpers ====================================================
 
-file 'sinatra.gemspec' => FileList['{lib,test,images}/**','Rakefile'] do |f|
-  # read spec file and split out manifest section
-  spec = File.read(f.name)
-  parts = spec.split("  # = MANIFEST =\n")
-  fail 'bad spec' if parts.length != 3
-  # determine file list from git ls-files
-  files = `git ls-files`.
-    split("\n").
-    sort.
-    reject{ |file| file =~ /^\./ }.
-    reject { |file| file =~ /^doc/ }.
-    map{ |file| "    #{file}" }.
-    join("\n")
-  # piece file back together and write...
-  parts[1] = "  s.files = %w[\n#{files}\n  ]\n"
-  spec = parts.join("  # = MANIFEST =\n")
-  File.open(f.name, 'w') { |io| io.write(spec) }
-  puts "updated #{f.name}"
+file 'bitly4r.gemspec' => FileList['{lib,test}/**','Rakefile'] do |f|
+	# read spec file and split out manifest section
+	spec = File.read(f.name)
+	parts = spec.split("# = MANIFEST =\n")
+	fail 'bad spec' if parts.length != 3
+	# determine file list from git ls-files
+	files = `git ls-files`.
+		split("\n").
+		sort.
+		reject{ |file| file =~ /^\./ }.
+		reject { |file| file =~ /^doc/ }.
+		map{ |file| "    #{file}" }.
+		join("\n")
+	# piece file back together and write...
+	parts[1] = "  s.files = %w[\n#{files}\n  ]\n"
+	spec = parts.join("# = MANIFEST =\n")
+	File.open(f.name, 'w') { |io| io.write(spec) }
+	puts "updated #{f.name}"
 end

data/bitly4r.gemspec

@@ -0,0 +1,43 @@
+Gem::Specification.new do |s|
+    s.required_ruby_version = '>= 3.0'
+
+    s.name = 'bitly4r'
+    s.version = '0.2.0'
+    # s.date = "2023-04-30"
+
+    s.description = "Bitly4R : A Ruby API for the http://bit.ly URL-shortening service"
+    s.summary     = "#{s.name} #{s.version}"
+
+    s.homepage = "http://wiki.cantremember.com/Bitly4R"
+    s.authors = ["Dan Foley"]
+    s.email = 'admin@cantremember.com'
+    s.license = 'WTFPL'
+
+        # = MANIFEST =
+  s.files = %w[
+    CHANGELOG
+    LICENSE
+    README.rdoc
+    Rakefile
+    bitly4r.gemspec
+    container
+    lib/bitly4r.rb
+    lib/bitly4r/client.rb
+    lib/bitly4r/definitions.rb
+    lib/bitly4r/objects.rb
+    test/client_test.rb
+    test/definitions_test.rb
+    test/objects_test.rb
+    test/test_helper.rb
+  ]
+# = MANIFEST =
+
+    s.files += Dir.glob('lib/**/*.rb')
+    # s.test_files = Dir.glob('test/**/*.rb')
+
+    s.require_paths = %w{lib}
+
+    #    only because there ain't no spaces in the title ...
+    s.rdoc_options = %w{ --line-numbers --inline-source --title Bitly4R --main README.rdoc }
+    s.extra_rdoc_files = %w{ README.rdoc CHANGELOG LICENSE }
+end

data/container

@@ -0,0 +1,5 @@
+#!/bin/bash
+docker run  --name bitly4r --rm  --privileged \
+  --mount type=bind,target=/opt/project,source="$(pwd)" \
+  --workdir /opt/project \
+  -it ruby:3.1  bash

data/lib/bitly4r/client.rb

@@ -9,31 +9,20 @@ module Bitly4R
 	#
 	#A client object for accessing the bit.ly API.
 	#
-	#* Supports both API key and HTTP Auth credentials (although HTTP Auth / password-based doesn't seem to work)
-	#* Works with version 2.0.1 of the API
-	#* Uses XML for marshalling, for cheap & easy text parsing.
+    #* This Client uses version 4.0.0 of the API (eg. '/v4/*').
+	#* It supports Access Token credentials.
 	#
 	#See the API documentation:
-	#* http://code.google.com/p/bitly-api/wiki/ApiDocumentation
-	#* http://bit.ly
+	#* https://dev.bitly.com/docs/
 	class Client
-		#:nodoc:
-		BASE_PARAMS = Params.new
-		BASE_PARAMS[:version] = '2.0.1'
-		BASE_PARAMS[:format] = 'xml'
-
-		#The login credential provided at construction.
-		attr_reader :login
-		#The password credential provided at construction.
-		attr_reader :password
-		#The API key credential provided at construction.
-		attr_reader :api_key
+		#The Access Token credential provided at construction.
+		attr_reader :token
 
 		#Constructs a new client.
 		#
 		#Any tuples provided in the optional Hash are injected into instance variables.
 		#
-		#You must provide a login, and either an API key (<tt>api_key</tt>) or a password.
+		#You must provide an Access Token (<tt>token</tt>).
 		def initialize(ops={})
 			#	for the readers
 			#	not necessary, but polite
@@ -41,105 +30,77 @@ module Bitly4R
 				instance_variable_set "@#{k}".to_sym, v
 			end
 
-			raise Error.new("you must provide a login") unless self.login
-			raise Error.new("you must provide either an API key or a password") unless (self.api_key or self.password)
-
-			#	now, a client-izec set of parameters
-			@client_params = BASE_PARAMS.clone.merge(ops)
+			raise Error.new("you must provide an Access Token") unless self.token
 		end
 
 
 		#Invokes the API's <b>shorten</b> method.
 		#That's pretty much what makes bit.ly a valuable service.
+        #
+        #https://dev.bitly.com/api-reference/#createBitlink
 		#
 		#A Response is returned.
-		#Response.to_s will return the <tt>shortUrl</tt> / <tt>short_url</tt> value.
-		#
-		#You can take the shortened URL and re- expand it.
-		def shorten(long_url)
+		#Response.to_s will return the <tt>link</tt> value.
+		#
+		#You can take the shortened URL and re-expand it.
+        #
+        #<i>ops</i> allows for additional API parameters
+        #<ul>
+        #    <li><tt>group_guid</tt></li>
+        #    <li><tt>domain</tt></li>
+        #</ul>
+		def shorten(long_url, ops={})
 			return nil unless long_url
-			assert_codes(execute(:shorten, :short_url) do |params|
-				params[:longUrl] = long_url
-			end)
+            return execute_post('shorten', :link) do |params|
+                params[:long_url] = long_url
+                params.merge!(ops)
+            end
 		end
 
 		#Invokes the API's <b>expand</b> method.
 		#It reverses a shorten; the original full URL is re-hydrated.
+        #
+        #https://dev.bitly.com/api-reference/#expandBitlink
 		#
-		#For <i>param</i>, you can provide a previously-shortened URL from the bit.ly service.
-		#If so, you do not need to provide <i>param_type</i> (though <tt>:short_url</tt> would be the proper symbol).
-		#
-		#Alternately, you can provide a hash code returned by the bit.ly service.
-		#In this case, provide <tt>:hash</tt> as the <i>param_type</i>.
+		#For <i>url</i>, you can provide a previously-shortened URL from the bit.ly service.
+        #
+        #The URL must provide both a domain (hostname) and a Bitlink ID (path).
+        #A minimum-viable URL would be something along the lines of 'bit.ly/3ADCPDo'.
 		#
 		#A Response is returned.
-		#Response.to_s will return the <tt>longUrl</tt> / <tt>long_url</tt> value.
-		def expand(param, param_type=:short_url)
-			return nil unless param && param_type
-			assert_codes(execute(:expand, :long_url) do |params|
-				params[Utility::camelize(param_type).to_sym] = param
-			end)
+		#Response.to_s will return the <tt>long_url</tt> value.
+		def expand(url)
+			return nil unless url
+            uri = URI.parse(url)
+            bitlink = "#{uri.host}#{uri.path}"
+
+			return execute_post('expand', :long_url) do |params|
+				params[:bitlink_id] = bitlink
+			end
 		end
 
 		#Invokes the API's <b>info</b> method.
 		#Information about the shortened URL is returned by the service.
+        #
+        #https://dev.bitly.com/api-reference/#getBitlink
 		#
-		#For <i>param</i>, you can provide a previously-shortened URL from the bit.ly service.
-		#If so, you do not need to provide <i>param_type</i> (though <tt>:short_url</tt> would be the proper symbol).
-		#
-		#Alternately, you can provide a hash code returned by the bit.ly service.
-		#In this case, provide <tt>:hash</tt> as the <i>param_type</i>.
-		#
-		#You can optionally provide an arbitrary Hash of HTTP parameters.
-		#The one that bit.ly cares about is called <tt>:key</tt>.
-		#It should be an array of camel-cased or underscored element names which you would like to receive.
-		#In theory, this should limit the response content, but I haven't seen that work yet.
-		#The arbitrary Hash capability is left intact for future re-purposing.
+        #For <i>url</i>, you can provide a previously-shortened URL from the bit.ly service.
+        #
+        #The URL must provide both a domain (hostname) and a Bitlink ID (path).
+        #A minimum-viable URL would be something along the lines of 'bit.ly/3ADCPDo'.
 		#
 		#A Response is returned.
-		#Response.to_s will return the <tt>longUrl</tt> / <tt>long_url</tt> value.
+		#Response.to_s will return the <tt>long_url</tt> value.
 		#
 		#There is plenty of other data in the response besides the original full URL.
 		#Feel free to access the Response.body and use Response.method_missing to pull out specific element values.
-		def info(param, param_type=:short_url, ops={})
-			return nil unless param_type && param
-			assert_codes(execute(:info, :long_url) do |params|
-				params[Utility::camelize(param_type).to_sym] = param
-
-				#	optional keys
-				if (keys = ops[:keys])
-					keys = [keys] unless Array === keys
-					params[:keys] = (keys.inject([]) do |a, key|
-						a << Utility::camelize(key)
-						a
-					end).join(',')
-				end
-			end)
-		end
+		def info(url)
+			return nil unless url
+            uri = URI.parse(url)
+            bitlink = "#{uri.host}#{uri.path}"
 
-		#Invokes the API's <b>stats</b> method.
-		#Statistics about the shortened URL are returned by the service.
-		#
-		#For <i>param</i>, you can provide a previously-shortened URL from the bit.ly service.
-		#If so, you do not need to provide <i>param_type</i> (though <tt>:short_url</tt> would be the proper symbol).
-		#
-		#Alternately, you can provide a hash code returned by the bit.ly service.
-		#In this case, provide <tt>:hash</tt> as the <i>param_type</i>.
-		#
-		#A Response is returned.
-		#Response.to_s will return the <tt>longUrl</tt> / <tt>long_url</tt> value.
-		#
-		#There is plenty of other data in the response besides the original full URL.
-		#Feel free to access the Response.body and use Response.method_missing to pull out specific element values.
-		def stats(param, param_type=:short_url)
-			return nil unless param_type && param
-			assert_codes(execute(:info, :long_url) do |params|
-				params[Utility::camelize(param_type).to_sym] = param
-			end)
-		end
-
-		def errors
-			execute(:errors)
+            command = "bitlinks/#{bitlink}"
+			return execute_get(command, :long_url)
 		end
 
 
@@ -147,48 +108,62 @@ module Bitly4R
 		#	- - - - -
 		protected
 
-		def execute(command, to_s_sym=nil) #:nodoc:
-			#http://api.bit.ly/shorten?version=2.0.1&longUrl=http://cnn.com&login=bitlyapidemo&apiKey=R_0da49e0a9118ff35f52f629d2d71bf07
-			uri = URI.parse('http://api.bit.ly')
+        def execute_get(command, to_s_sym=nil) #:nodoc:
+            uri = URI.parse('https://api-ssl.bitly.com')
+
+            #   the client-ized set
+            params = Params.new
+
+            #   altered in whatever way the caller desires
+            yield params if block_given?
+
+            response = Net::HTTP.start(uri.host, uri.port,
+                :use_ssl => true,
+                :set_debug_output => $stdout,
+            ) do |http|
+                path = "/v4/#{command}?#{params}"
+                request = Net::HTTP::Get.new(path)
+                request['Authorization'] = "Bearer #{self.token}"
+                request['Accept'] = 'application/json'
+
+                http.request request
+            end
+
+            # accept the HTTP 2XX range
+            raise Error.new('did not receive HTTP 200 OK') unless (/2\d{2}/ =~ response.code)
+
+            #   a parsing response
+            Response.new(response, to_s_sym)
+        end
 
-			#	the client-izec set
-			params = @client_params.clone
-			params[:login] = self.login
-			params[:apiKey] = self.api_key if self.api_key
+		def execute_post(command, to_s_sym=nil) #:nodoc:
+            uri = URI.parse('https://api-ssl.bitly.com')
+
+			#	the client-ized set
+			params = Params.new
 
 			#	altered in whatever way the caller desires
 			yield params if block_given?
 
-			response = Net::HTTP.start(uri.host, uri.port) do |http|
-				path = "/#{command}?#{params}"
-				request = Net::HTTP::Get.new(path)
-				if self.password
-					#	HTTP auth expected
-					request.basic_auth self.login, self.password
-				end
+			response = Net::HTTP.start(uri.host, uri.port,
+                :use_ssl => true,
+                # :set_debug_output => $stdout,
+            ) do |http|
+				path = "/v4/#{command}"
+				request = Net::HTTP::Post.new(path)
+                request['Authorization'] = "Bearer #{self.token}"
+                request['Content-Type'] = 'application/json'
+                request.body = params.to_json
 
 				http.request request
 			end
 
-			raise Error.new('did not receive HTTP 200 OK') unless Net::HTTPOK === response
+            # accept the HTTP 2XX range
+            raise Error.new('did not receive an HTTP 2XX') unless (/2\d{2}/ =~ response.code)
 
 			#	a parsing response
 			Response.new(response, to_s_sym)
 		end
-
-		def assert_error_code(response) #:nodoc:
-			raise Error.new("errorCode #{response.errorCode} : #{response.errorMesage}") unless '0' == response.errorCode
-			response
-		end
-
-		def assert_status_code(response) #:nodoc:
-			raise Error.new("status #{response.statusCode}") unless 'OK' == response.statusCode
-			response
-		end
-
-		def assert_codes(response) #:nodoc:
-			assert_error_code(assert_status_code(response))
-		end
 	end
 
 

data/lib/bitly4r/definitions.rb

@@ -1,34 +1,20 @@
 #Simple constructor methods, so that you don't have to deal directly with Client if you don't want to.
 #
 #See also:
-#* Bitly4R.Keyed
-#* Bitly4R.Authed
+#* Bitly4R.Token
 #
 #--
 #Many thanks to Hpricot for introducing me to this convention.
 #++
 
 #Constructs a SimpleClient with the usual Hash of arguments.
-
 def Bitly4R(ops={})
 	#	general options
 	Bitly4R::SimpleClient.new(ops)
 end
 
-#Constructs a SimpleClient with login and API key credentials.
-#
-#No password is involved.
-#Simple HTTP GETs will be the order of the day.
-def Bitly4R.Keyed(login, api_key)
-	#	using an API key
-	Bitly4R::SimpleClient.new(:login => login, :api_key => api_key)
-end
-
-#Constructs a SimpleClient with login and password credentials.
-#
-#No API key is involved.
-#HTTP GETs with HTTP Basic Auth will be the order of the day.
-def Bitly4R.Authed(login, password)
-	#	using an API key
-	Bitly4R::SimpleClient.new(:login => login, :password => password)
+#Constructs a SimpleClient with an Access Token credential
+def Bitly4R.Token(token)
+    #   just token
+	Bitly4R::SimpleClient.new(:token => token)
 end

data/lib/bitly4r/objects.rb

@@ -68,10 +68,10 @@ module Bitly4R
 		#Constructs a bit.ly API response wrapper.
 		#
 		#<i>response</i> can be:
-		#* a String, which becomes the body
-		#* a Net::HTTPResponse, in which case its body is extracted
+		#* a JSON String, which becomes the body
+		#* a Net::HTTPResponse, in which case its body is extracted and expected to be in JSON format
 		#
-		#<i>to_s_sym</i> is optional, and it references the element which will become the to_s value of this Response.
+		#<i>to_s_sym</i> is optional, and it references the property which will become the `#to_s` value of this Response.
 		#It can be either camel-case or underscored.
 		#See method_missing.
 		def initialize(response, to_s_sym=nil)
@@ -80,18 +80,19 @@ module Bitly4R
 			@to_s_sym = to_s_sym
 		end
 
-		#Provides access the other text elements of the response via camel-case or underscored names.
+		#Provides access to the other properties of the response body via camel-case or underscored names.
 		#For example, <tt>longUrl</tt> and <tt>long_url</tt> are equivalent.
-		#If no such element exists, you'll get nil.
+		#If no such property exists, you'll get nil.
 		def method_missing(sym, *args)
-			sym = Utility::camelize(sym.to_s)
-			match = (self.body || '').match(%r{<#{sym}>(.*)</#{sym}>})
+            begin
+                json = JSON.parse(@body || '{}')
+            rescue JSON::ParserError => e
+                return nil
+            end
 
-			unless match
-				nil
-			else
-				match[1].gsub(/^<!\[CDATA\[(.*)\]\]>$/, '\1')
-			end
+            # their 'v4/*' JSON convention is snake_case
+            sym = Utility::decamelize(sym.to_s)
+			return json[sym]
 		end
 
 		#Provides the 'likely' value from the response.
@@ -102,7 +103,9 @@ module Bitly4R
 
 		#Provides the 'likely' value from the response, as a symbol.
 		def to_sym
-			@to_s_sym  ? self.to_s.to_sym  : super
+            return super unless @to_s_sym
+            value = self.to_s
+            return value.nil? ? value : value.to_sym
 		end
 	end
 

data/lib/bitly4r.rb

@@ -8,7 +8,9 @@
 #--
 
 #	external
-%w{ net/http cgi }.each {|lib| require lib }
+require 'net/http'
+require 'cgi'
+require 'json'
 
 #	internal, and in the proper sequence
 %w{

data/test/client_test.rb

@@ -9,122 +9,83 @@ class ClientTest < Test::Unit::TestCase #:nodoc: all
 		any = 'any'
 
 		assert_raises Bitly4R::Error do
-			#	no login
+			#	no token
 			Bitly4R::Client.new
 		end
 
-		assert_raises Bitly4R::Error do
-			#	needs API key or password
-			Bitly4R::Client.new(:login => any)
-		end
-
-		Bitly4R::Client.new(:login => any, :api_key => any)
-		Bitly4R::Client.new(:login => any, :password => any)
+		Bitly4R::Client.new(:token => any)
 	end
 
 	def test_shorten
-		#	shorten
+		#	shorten with a full Client
 		client = new_client
 		response = client.shorten LONG_URL
 
-		assert_is_response_ok response
+        assert (Bitly4R::Response === response)
 
 		#	we get back what we provided
-		assert_equal LONG_URL, response.node_key
+		assert_equal LONG_URL, response.long_url
 
 		#	no assumption as to the value, just how they inter-relate
-		hash = response.user_hash
-		assert hash && (! hash.empty?)
-		short = response.short_url
-		assert short =~ Regexp.compile(hash + '$')
+		id = response.id
+		assert id && (! id.empty?)
+		link = response.link
+		assert_equal "https://#{id}", link
+        assert_equal response.to_s, link
+
+        #   shorten with a SimpleClient
+        simple_client = new_simple_client
+        simple_response = simple_client.shorten LONG_URL
+        assert (String === simple_response)
+        assert_equal link, simple_response
 	end
 
 	def test_expand
-		#	shorten ...
+		#	shorten with a full Client
 		client = new_client
-
 		response = client.shorten(LONG_URL)
-		assert_is_response_ok response
 
-		hash = response.user_hash
+		id = response.id
 		short = response.to_s
 
 		#	... and re-expand
-		#	again, we don't have to know anything
+        #   no assumption as to the value, just how they inter-relate
 		response = client.expand(short)
-		assert_is_response_ok response
 
 		assert_equal LONG_URL, response.to_s
+        assert_equal LONG_URL, response.long_url
 
-		#	note sure what purpose it serves
-		#	but it will contain a hash-wrapped element
-		assert ! response.__send__(hash.to_sym).empty?
-
-		#	... and re-expand
-		#	again, we don't have to know anything
-		response = client.expand(hash, :hash)
-		assert_is_response_ok response
-
-		assert_equal LONG_URL, response.to_s
-
-		#	again...
-		assert ! response.__send__(hash.to_sym).empty?
+        #   expand with a SimpleClient
+        simple_client = new_simple_client
+        simple_response = simple_client.expand short
+        assert (String === simple_response)
+        assert_equal LONG_URL, simple_response
 	end
 
 	def test_info
-		#	shorten ...
+        #   shorten with a full Client
 		client = new_client
-
 		response = client.shorten(LONG_URL)
-		assert_is_response_ok response
 
-		hash = response.user_hash
 		short = response.to_s
 
-		#	short url, with no key limit
+		#	now, its info ...
 		response = client.info(short)
-		assert_is_response_ok response
-
-		assert_equal LONG_URL, response.long_url
-
-		#	hash, key limit
-		response = client.info(hash, :hash, :keys => [:long_url, :html_title])
-		assert_is_response_ok response
-
-		#	well, we're getting non-included keys back
-		#	then again, the demo doesn't constrain the keys either
-		#		http://code.google.com/p/bitly-api/wiki/ApiDocumentation
-		###assert response.thumbnail.empty?
-		###assert ! response.html_title.empty?
-		assert_equal LONG_URL, response.to_s
-	end
-
-	def test_stats
-		#	shorten ...
-		client = new_client
-
-		response = client.shorten(LONG_URL)
-		assert_is_response_ok response
-
-		hash = response.user_hash
-		short = response.to_s
-
-		{ :hash => hash, :short_url => short }.each do |param_type, param|
-			response = client.info(param, param_type)
-			assert_is_response_ok response
-
-			#	we could choose anything
-			assert_equal LONG_URL, response.to_s
-		end
-	end
-
-	def test_errors
-		#	errors ...
-		client = new_client
 
-		response = client.errors
-		assert ! response.results.empty?
-		assert ! response.error_code.empty?
-		assert ! response.status_code.empty?
+        assert_equal LONG_URL, response.to_s
+        assert_equal LONG_URL, response.long_url
+
+        #   a few other accessable properties
+        #   no assumption as to the value, just how they inter-relate
+        assert_equal "https://#{response.id}", response.link
+        assert_equal false, response.archived
+
+        #   info with a SimpleClient
+        #   which for this method is not "simple"; it provides a full Response
+        simple_client = new_simple_client
+        simple_response = simple_client.info short
+        assert (Bitly4R::Response === response)
+        assert_equal LONG_URL, simple_response.long_url
+        assert_equal false, response.archived
 	end
 end

data/test/definitions_test.rb

@@ -5,46 +5,28 @@ require 'test_helper'
 
 
 class DefinitionsTest < Test::Unit::TestCase #:nodoc: all
-	def test_keyed
+	def test_with_token
 		#	shorten ...
-		client = Bitly4R(:login => LOGIN, :api_key => API_KEY)
-		short = client.shorten(LONG_URL)
+		short = Bitly4R(:token => TOKEN).shorten(LONG_URL)
 		assert short && (! short.empty?)
+        assert (String === short)
 
-		#	... and expand
-		assert_equal LONG_URL, Bitly4R.Keyed(LOGIN, API_KEY).expand(short)
+		#	... and expand (with another Definition)
+        long = Bitly4R.Token(TOKEN).expand(short)
+        assert (String === long)
+		assert_equal LONG_URL, long
 	end
 
-	def test_authed
-		unless PASSWORD
-			puts %Q{
-NOTE:
-	the text login (#{LOGIN}) did not publish a password
-	cannot be tested without that private information
-			}.strip
-			return
-		end
-
-		#	http://code.google.com/p/bitly-api/wiki/ApiDocumentation
-		#		sure, the documentation claims there's HTTP Auth support
-		#		but i don't see it yet
-		short = nil
-		assert_raises Bitly4R::Error do
-			#	shorten ...
-			client = Bitly4R(:login => LOGIN, :password => API_KEY)
-			short = client.shorten(LONG_URL)
-			assert short && (! short.empty?)
-		end
-
+	def test_without_token
 		#	alright, let's use the API key
-		client = Bitly4R(:login => LOGIN, :api_key => API_KEY)
-		short = client.shorten(LONG_URL)
-		assert short && (! short.empty?)
+		client = Bitly4R(:token => 'INVALID')
+
+        assert_raises Bitly4R::Error do
+    		client.shorten(LONG_URL)
+        end
 
-		#	same deal.  *sigh*
 		assert_raises Bitly4R::Error do
-			#	... and expand
-			assert_equal LONG_URL, Bitly4R.Authed(LOGIN, PASSWORD).expand(short)
+            Bitly4R.Token('INVALID').shorten(LONG_URL)
 		end
 	end
 end

data/test/objects_test.rb

@@ -81,21 +81,20 @@ class ObjectsTest < Test::Unit::TestCase #:nodoc: all
 		response = Bitly4R::Response.new('string', :bogus)
 		assert_equal 'string', response.body
 		assert_nil response.to_s
+        assert_nil response.to_sym
 
 		#	simple
-		response = Bitly4R::Response.new('<a>value</a>', :b)
-		assert_equal 'value', response.a
-		assert_nil response.to_s
+		response = Bitly4R::Response.new('{"key":"value"}', :key)
+		assert_equal 'value', response.key
+        assert_nil response.another_key
+		assert_equal 'value', response.to_s
+        assert_equal :value, response.to_sym
 
 		#	camelization
-		response = Bitly4R::Response.new('<uD>down</uD><dU>up</dU>', :d_u)
+		response = Bitly4R::Response.new('{"uD":"down","dU":"up"}', :d_u)
 		assert_equal 'down', response.uD
 		assert_equal 'down', response.u_d
 		assert_equal 'up', response.dU
 		assert_equal 'up', response.to_s
-
-		#	CDATA, plus to_sym
-		response = Bitly4R::Response.new('<a><b>b</b><cData><![CDATA[data]]></cData><c>c</c></a>', :c_data)
-		assert_equal :data, response.to_sym
 	end
 end

data/test/test_helper.rb

@@ -9,33 +9,26 @@ $LOAD_PATH.unshift File.dirname(File.dirname(__FILE__)) + "/../lib"
 
 #	if we're lucky...
 begin
-	require 'ruby-debug'
-rescue Object => e
+	require 'debug'
+rescue Exception
 end
 
 
 
 class Test::Unit::TestCase #:nodoc: all
-
 	#	trailing slash makes a difference!  they normalize!
 	LONG_URL = 'http://rubyforge.org/'
 
-	#	credentials from
-	#		http://code.google.com/p/bitly-api/wiki/ApiDocumentation
-	#		no password provided
-	LOGIN = 'bitlyapidemo'
-	API_KEY = 'R_0da49e0a9118ff35f52f629d2d71bf07'
-	PASSWORD = nil
-
+	#	an Access Token credential is required
+	TOKEN = ENV['TOKEN']
+    raise Exception.new('You must provide an Access Token (TOKEN) from the environment') if (TOKEN.nil? || TOKEN.empty?)
 
 
-	def new_client
-		Bitly4R::Client.new(:login => LOGIN, :api_key => API_KEY)
-	end
+    def new_client
+        Bitly4R::Client.new(:token => TOKEN)
+    end
 
-	def assert_is_response_ok(response)
-		assert_equal '0', response.error_code
-		assert_equal '', response.error_message
-		assert_equal 'OK', response.status_code
+	def new_simple_client
+		Bitly4R.Token(TOKEN)
 	end
 end

metadata

@@ -1,70 +1,65 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: bitly4r
-version: !ruby/object:Gem::Version 
-  version: 0.1.0
+version: !ruby/object:Gem::Version
+  version: 0.2.0
 platform: ruby
-authors: 
+authors:
 - Dan Foley
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2009-02-02 00:00:00 -08:00
-default_executable: 
+date: 2023-05-01 00:00:00.000000000 Z
 dependencies: []
-
-description: "Bitly4R : A Ruby API for the http://bit.ly URL-shortening service"
+description: 'Bitly4R : A Ruby API for the http://bit.ly URL-shortening service'
 email: admin@cantremember.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.rdoc
 - CHANGELOG
 - LICENSE
-files: 
+files:
 - CHANGELOG
 - LICENSE
 - README.rdoc
 - Rakefile
+- bitly4r.gemspec
+- container
+- lib/bitly4r.rb
 - lib/bitly4r/client.rb
 - lib/bitly4r/definitions.rb
 - lib/bitly4r/objects.rb
-- lib/bitly4r.rb
-has_rdoc: true
+- test/client_test.rb
+- test/definitions_test.rb
+- test/objects_test.rb
+- test/test_helper.rb
 homepage: http://wiki.cantremember.com/Bitly4R
+licenses:
+- WTFPL
+metadata: {}
 post_install_message: 
-rdoc_options: 
-- --line-numbers
-- --inline-source
-- --title
+rdoc_options:
+- "--line-numbers"
+- "--inline-source"
+- "--title"
 - Bitly4R
-- --main
+- "--main"
 - README.rdoc
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "1.8"
-  version: 
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: bitly4r
-rubygems_version: 1.3.1
+rubygems_version: 3.3.26
 signing_key: 
-specification_version: 2
-summary: bitly4r 0.1.0
-test_files: 
-- test/client_test.rb
-- test/definitions_test.rb
-- test/objects_test.rb
-- test/test_helper.rb
+specification_version: 4
+summary: bitly4r 0.2.0
+test_files: []