typekit_client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 02f351c322a027c5490e836326c451eb19bb0374
+  data.tar.gz: 286df5e110bde5b1be3a821739acca9ae61fb32d
+SHA512:
+  metadata.gz: 1f115fa302f680754b71796d2ee836344bd4c3320d99b18dda7c165d1ed70ffc90881d3639c0ec5dde73f32a8a401d963ddac20cf756f8845f3c41e109af1feb
+  data.tar.gz: db216f62aa8195763b8726ebe1be2a757e1f23c1eecb27cd13fd3ea9275cf90e3364302d4613ff30f58433af072ab06b8633d2a98114104ecc5026d2923840c6

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.16.0

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in typekit_client.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Thirukonda Surendran,Koushic Babu
+
+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,43 @@
+# TypekitClient
+
+Ruby CLI app for Adobe TypeKit https://typekit.com/docs/api/v1/:format/kits
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'typekit_client'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install typekit_client
+
+## Usage
+
+To view the list of available commands, type:
+
+    $ typekit_client help
+
+All the commands require user token for authentication. Please input token when prompted. The user token can be obtained from https://typekit.com/account/tokens
+
+To run the Rspec tests, run:
+
+    $ rake
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/koushic88/typekit_client. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the TypekitClient project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/koushic88/typekit_client/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

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

data/bin/typekit_client

@@ -0,0 +1,5 @@
+ #!/usr/bin/env ruby
+ require_relative '../lib/typekit_client'
+
+# Start the CLI
+ TypekitClient::CLI.start ARGV

data/lib/typekit_client.rb

@@ -0,0 +1,5 @@
+require "typekit_client/version"
+
+require 'typekit_client/cli'
+require 'typekit_client/typekit_api'
+require 'typekit_client/http_request'

data/lib/typekit_client/cli.rb

@@ -0,0 +1,100 @@
+require "thor"
+require "typekit_client/typekit_api"
+require 'filecache'
+require 'colorize'
+
+module TypekitClient
+
+  TOKEN_CACHE = FileCache.new("auth-token", "/tmp/caches", 1800, 3)
+
+  class CLI < Thor
+
+    desc "kits", "Returns a list of kits owned by the authenticating user"
+    option :format, default: 'json', enum: %w(json xml yaml)
+    def kits
+      check_auth_token
+      TypekitClient::TypekitAPI.kits(options[:format])
+    end
+
+    desc "kit KIT_ID", "Returns information about the draft version of the kit KIT_ID"
+    option :format, default: 'json', enum: %w(json xml yaml)
+    def kit(kit_id)
+      check_auth_token
+      TypekitClient::TypekitAPI.kit(kit_id, options[:format])
+    end
+
+    desc "delete_kit KIT_ID", "Deletes a kit KIT_ID"
+    option :format, default: 'json', enum: %w(json xml yaml)
+    def delete_kit(kit_id)
+      check_auth_token
+      TypekitClient::TypekitAPI.delete_kit(kit_id, options[:format])
+    end
+
+    desc "publish_kit KIT_ID", "Publishes the current draft version of a kit KIT_ID"
+    option :format, default: 'json', enum: %w(json xml yaml)
+    def publish_kit(kit_id)
+      check_auth_token
+      TypekitClient::TypekitAPI.publish_kit(kit_id, options[:format])
+    end
+
+    desc "published_kit KIT_ID", "Returns information about the published version of the kit"
+    option :format, default: 'json', enum: %w(json xml yaml)
+    def published_kit(kit_id)
+      check_auth_token
+      TypekitClient::TypekitAPI.published_kit(kit_id, options[:format])
+    end
+
+    desc "kit_family KIT_ID FAMILY_ID", "Returns information about a font family FAMILY_ID used in a kit KIT_ID"
+    option :format, default: 'json', enum: %w(json xml yaml)
+    def kit_family(kit_id, family_id)
+      check_auth_token
+      TypekitClient::TypekitAPI.family(kit_id, family_id, options[:format])
+    end
+
+    desc "delete_family KIT_ID FAMILY_ID", "Removes font family FAMILY_ID from the kit KIT_ID"
+    option :format, default: 'json', enum: %w(json xml yaml)
+    def delete_family(kit_id, family_id)
+      check_auth_token
+      TypekitClient::TypekitAPI.delete_family(kit_id, family_id, options[:format])
+    end
+
+    desc "create_kit", "Creates a new draft kit and returns the updated information"
+    option :format, default: 'json', enum: %w(json xml yaml)
+    option :name, required: true, desc: 'name of the kit'
+    option :domains, required: true, desc: 'comma separated list of domains'
+    option :segmented_css_names, default: 'true', enum: %w(true false), desc: 'specify whether families in this kit should use segmented or unsegmented CSS fonts'
+    option :families, desc: 'font family to be included in the app, format: --families=id:123,variations:n1\;id:456,variations:i7'
+    def create_kit
+      check_auth_token
+      TypekitClient::TypekitAPI.create_kit(options)
+    end
+
+    desc "add_family KIT_ID FAMILY_ID", "Adds or Modifies existing family to the existing kit KIT_ID, returns the updated information"
+    option :format, default: 'json', enum: %w(json xml yaml)
+    option :subset, default: 'default', enum: %w(default all), desc: 'character subset to use'
+    option :variations, desc: 'a list of font variations to use - comma seperated values'
+    def add_family(kit_id, family_id)
+      check_auth_token
+      TypekitClient::TypekitAPI.add_family(kit_id, family_id, options)
+    end
+
+    no_commands do
+
+      # This helper method checks if the auth token exists in the file cache. If token doesn't exists, it prompts user to
+      # input the auth token, and it gets cached.
+      #
+      # Returns authentication token
+      #
+      def check_auth_token
+        token = TypekitClient::TOKEN_CACHE.get("token")
+        if !token
+          print "Authentication token required, Get token from https://typekit.com/account/tokens :".red
+          token = STDIN.gets.chomp
+          TypekitClient::TOKEN_CACHE.set("token", token.strip)
+        end
+
+        token
+      end
+    end
+  end
+end

data/lib/typekit_client/http_request.rb

@@ -0,0 +1,69 @@
+require 'net/http'
+require 'json'
+require 'rack/utils'
+
+module TypekitClient
+  module HttpRequest
+
+    BASE_URI = 'https://typekit.com/api/v1'
+
+    # This allow us to not pass strings to determine the request type.
+    REQUEST_TYPE = {
+        :GET => Net::HTTP::Get,
+        :POST => Net::HTTP::Post,
+        :DELETE => Net::HTTP::Delete
+    }
+
+    # Public: This function makes network calls to the Typekit API depending on the
+    # parameters passed and returns the response from the server.
+    # The function can make 3 types of HTTP calls including get, post, delete
+    #
+    # uri_string- The uri string to be appended to the base uri
+    # type- the type of HTTP request to make
+    # format- format of the response data
+    # body- hash to set as request body for POST requests
+    #
+    # Example:
+    #
+    #   request('kits',:GET, 'json', {kits: ''})
+    #   => # Net::HTTPResponse object
+    #
+    # It returns the response from the request if there are no runtime errors
+    #
+    def self.request(uri_string, type, format, body=nil)
+
+      request = REQUEST_TYPE[type].new(URI.parse("#{BASE_URI}/#{format}/#{uri_string}"))
+      request['X-Typekit-Token'] = TypekitClient::TOKEN_CACHE.get("token")
+
+      request.body = Rack::Utils.build_nested_query(body) if body
+
+      response = execute_request(request)
+
+      # clear the cache if the response code is not 401(unauthorized)
+      TypekitClient::TOKEN_CACHE.clear if response.code == '401'
+
+      return response
+    rescue SocketError
+      puts "Socket Error, Please check your internet connection.".red
+    rescue Net::OpenTimeout
+      puts "The request timed out when trying to connect, please check your connection.".red
+    end
+
+    private
+
+    # Private: Makes http calls with given request. It can be any http
+    # request such as get, post, delete.
+    #
+    # request- request instance such as Net::HTTP::Get.new(), Net::HTTP::POST.new()
+    #
+    # Returns the response object
+    # Raises error when there is a timeout issue or internet connection is down
+    def self.execute_request(request)
+      http = Net::HTTP.new(request.uri.host, request.uri.port)
+      http.use_ssl = true if request.uri.to_s.include? 'https'
+
+      http.request(request)
+    end
+
+  end
+end

data/lib/typekit_client/typekit_api.rb

@@ -0,0 +1,249 @@
+require "typekit_client/http_request"
+require 'colorize'
+
+module TypekitClient
+  module TypekitAPI
+
+    # Public: This helper method makes http request and prints out the list of kits
+    #
+    # format- The user requested format, set to JSON by default
+    #
+    # Example:
+    #
+    #   kits('json')
+    #
+    # If it is a success, it prints the response body based on the specified format
+    # If it is a failure, it prints out error status code and message
+    #
+    def self.kits(format)
+      uri_string = 'kits'
+      response = TypekitClient::HttpRequest.request(uri_string, :GET, format)
+
+      print_response(response)
+    end
+
+    # Public: This helper method makes http request and prints out the draft version of the kit for the given kit id
+    #
+    # kit_id- The kit id to find the details for
+    # format- The user requested format, set to JSON by default
+    #
+    # Example:
+    #
+    #   kit('bsz4xuy', 'json')
+    #
+    # If it is a success, it prints the kit details based on the specified format
+    # If it is a failure, it prints out error status code and message
+    #
+    def self.kit(kit_id, format)
+      uri_string = "kits/#{kit_id}"
+      response = TypekitClient::HttpRequest.request(uri_string, :GET, format)
+
+      print_response(response)
+    end
+
+    # Public: This helper method makes http request to create a new kit
+    #
+    # options- The options hash containing user inputs
+    #
+    # Example:
+    #
+    #   create_kit({format: 'json', name: 'test'})
+    #
+    # If it is a success, it prints the newly created kit details based on the specified format
+    # If it is a failure, it prints out error status code and message
+    #
+    def self.create_kit(options)
+
+      body = {
+        name: options[:name],
+        domains: options[:domains],
+        segmented_css_names: options[:segmented_css_names]
+      }
+
+      body[:families] = parse_families(options[:families]) if options[:families]
+
+      uri_string = 'kits'
+      response = TypekitClient::HttpRequest.request(uri_string, :POST, options[:format], body)
+      print_response(response)
+    end
+
+    # Public: This helper method makes http request and deletes the kit for the given kit id
+    #
+    # kit_id- The id of the kit to delete
+    # format- The user requested format, set to JSON by default
+    #
+    # Example:
+    #
+    #   delete_kit('bsz4xuy', 'json')
+    #
+    # If it is a success, it prints the success message
+    # If it is a failure, it prints out error status code and message
+    #
+    def self.delete_kit(kit_id, format)
+      uri_string = "kits/#{kit_id}"
+      response = TypekitClient::HttpRequest.request(uri_string, :DELETE, format)
+
+      print_response(response)
+    end
+
+    # Public: This helper method makes http request and prints out the font family details for the given
+    # font id and the family id
+    #
+    # kit_id- The kit id to find the details for
+    # family_id- The font family id for the kit
+    # format- The user requested format, set to JSON by default
+    #
+    # Example:
+    #
+    #   family('bsz4xuy', 'myvg', 'json')
+    #
+    # If it is a success, it prints the font family details based on the specified format
+    # If it is a failure, it prints out error status code and message
+    #
+    def self.family(kit_id, family_id, format)
+      uri_string = "kits/#{kit_id}/families/#{family_id}"
+      response = TypekitClient::HttpRequest.request(uri_string, :GET, format)
+
+      print_response(response)
+    end
+
+    # Public: This helper method makes http request to add new font family to kit
+    #
+    # kit_id- The kit id to add the font family
+    # family_id- The font family id to be added
+    # options- The options hash containing user inputs
+    #
+    # Example:
+    #
+    #   add_family('bsz4xuy', 'myvg', {format: 'json', subset: 'default'})
+    #
+    # If it is a success, it prints the newly added font family details based on the specified format
+    # If it is a failure, it prints out error status code and message
+    #
+    def self.add_family(kit_id, family_id, options)
+
+      body = { subset: options[:subset] }
+      body[:variations] = options[:variations] if options[:variations]
+
+      uri_string = "kits/#{kit_id}/families/#{family_id}"
+      response = TypekitClient::HttpRequest.request(uri_string, :POST, options[:format], body)
+      print_response(response)
+    end
+
+    # Public: This helper method makes http request to publish the draft version of the kit
+    #
+    # kit_id- The id of the kit to publish
+    # format- The user requested format, set to JSON by default
+    #
+    # Example:
+    #
+    #   publish_kit('bsz4xuy', 'json')
+    #
+    # If it is a success, it prints the published date in specified format
+    # If it is a failure, it prints out error status code and message
+    #
+    def self.publish_kit(kit_id, format)
+      uri_string = "kits/#{kit_id}/publish"
+      response = TypekitClient::HttpRequest.request(uri_string, :POST, format)
+
+      print_response(response)
+    end
+
+    # Public: This helper method makes http request and prints out the published version of kit for the given kit id
+    # If token is not provided, it will display only public info
+    # pass-in token in the options hash to get all info with proper authentication
+    #
+    # kit_id- The kit id to find the details for
+    # format- The user requested format, set to JSON by default
+    #
+    # Example:
+    #
+    #   published_kit('bsz4xuy', 'json')
+    #
+    # If it is a success, it prints the kit details based on the specified format
+    # If it is a failure, it prints out error status code and message
+    #
+    def self.published_kit(kit_id, format)
+      uri_string = "kits/#{kit_id}/published"
+      response = TypekitClient::HttpRequest.request(uri_string, :GET, format)
+
+      print_response(response)
+    end
+
+    # Public: This helper method makes http request to delete font family from kit
+    #
+    # kit_id- The kit id to delete the family from
+    # family_id- The font family id in the kit
+    # format- The user requested format, set to JSON by default
+    #
+    # Example:
+    #
+    #   delete_family('bsz4xuy', 'myvg', 'json')
+    #
+    # If it is a success, it prints success message
+    # If it is a failure, it prints out error status code and message
+    #
+    def self.delete_family(kit_id, family_id, format)
+      uri_string = "kits/#{kit_id}/families/#{family_id}"
+      response = TypekitClient::HttpRequest.request(uri_string, :DELETE, format)
+
+      print_response(response)
+    end
+
+
+    private
+
+    # Private: This helper method prints out the response body based on the response code
+    #
+    # response- The http response object from the http request call
+    #
+    # Example:
+    #
+    #   print_response(Net::HTTPResponse)
+    #
+    # If the status code is 200, it prints out the response body based on the content-type
+    # If it is a failure, it prints out error status code and message
+    #
+    def self.print_response(response)
+      if response.code == '200'
+        if response.body.empty?
+          puts 'The command ran successfully'
+        end
+        if response['content-type'] == 'application/json; charset=utf-8'
+          puts JSON.pretty_generate(JSON.parse(response.body))
+        else
+          puts response.body
+        end
+      else
+        puts "The following error occurred while running the command:#{response.code}, #{JSON.parse(response.body)['errors']}".red
+      end
+    end
+
+    # Private: This helper method parses families input string and converts it to a hash
+    #
+    # families- The user input families string in the format 'id:abcd,variations:n2;id:2,variations:i7'
+    #
+    # Example:
+    #
+    #   parse_families('id:abcd,variations:n2;id:2,variations:i7')
+    #   => {"0"=>{"id"=>"1", "variations"=>"n2"}, "1"=>{"id"=>"2", "variations"=>"i7"}}
+    #
+    # Returns equivalent hash for the string
+    #
+    def self.parse_families(families)
+
+      family_list = families.split(';')
+      family_hash = {}
+
+      family_list.each_with_index do |family, index|
+        family_hash[index.to_s] = family.split(',').each_with_object({}) { |str, attribute_hash|
+          tmp = str.split(':')
+          attribute_hash[tmp[0]] = tmp[1] if %w(id variations subset).include? tmp[0]
+        }
+      end
+
+      family_hash
+    end
+
+  end
+end

data/lib/typekit_client/version.rb

@@ -0,0 +1,3 @@
+module TypekitClient
+  VERSION = "0.1.0"
+end

data/spec/http_request_spec.rb

@@ -0,0 +1,92 @@
+RSpec.describe TypekitClient::HttpRequest do
+
+  describe '#execute_request' do
+    let (:http) { Net::HTTP::Post.new(URI.parse('https://adobe.api.com')) }
+    let (:actual) { subject.execute_request(http) }
+
+    before do
+      allow_any_instance_of(Net::HTTP).to receive(:request) { Net::HTTPOK.new('get', '200', 'successful') }
+    end
+
+    context 'with get request' do
+      it 'checks response of authorized rest call' do
+        expect(actual).to be_a Net::HTTPOK
+      end
+
+      it 'checks response of unauthorized/invalid credentials rest call' do
+        allow_any_instance_of(Net::HTTP).to receive(:request) { Net::HTTPUnauthorized.new('get', '401', 'Unauthorized') }
+
+        expect(actual).to be_a Net::HTTPUnauthorized
+      end
+    end
+
+    context 'when wrong url or no internet' do
+      it 'checks for SocketError' do
+        allow_any_instance_of(Net::HTTP).to receive(:request).and_raise(SocketError)
+
+        expect { actual }.to raise_error(SocketError)
+      end
+    end
+  end
+
+  describe '#request' do
+    let(:uri_string) { 'kits' }
+
+    let (:good_path) { 'http://valid.url' }
+
+    let(:http_request) { subject.request(uri_string, :GET, 'json') }
+
+
+    context 'when SocketError occurs' do
+      before do
+        allow(subject).to receive(:execute_request).and_raise(SocketError)
+      end
+
+      it 'raises a StandardError' do
+        expect{ actual }.to raise_error(StandardError)
+      end
+    end
+
+    context 'when request times out' do
+      before do
+        allow(subject).to receive(:execute_request).and_raise(Net::OpenTimeout)
+      end
+
+      it 'raises a StandardError' do
+        expect{ actual }.to raise_error(StandardError)
+      end
+    end
+
+    context 'when response with 200 is returned' do
+      let(:request) { object_double("Net::HTTP::Get.new") }
+      let(:response) { Net::HTTPSuccess.new('response', '200', '{}') }
+
+      before do
+        allow_any_instance_of(Net::HTTP::Get).to receive(:new).and_return(request)
+        allow(subject).to receive(:execute_request) { response }
+      end
+
+      it 'ensures response object is returned' do
+        expect(http_request).to eq response
+      end
+    end
+
+    context 'when response with 401 is returned' do
+      let(:request) { object_double("Net::HTTP::Get.new") }
+      let(:response) { Net::HTTPUnauthorized.new('response', '401', '{}') }
+
+      before do
+        allow_any_instance_of(Net::HTTP::Get).to receive(:new).and_return(request)
+        allow(subject).to receive(:execute_request) { response }
+      end
+
+      it 'ensures token cache gets cleared' do
+        token_cache = object_double("TypekitClient::TOKEN_CACHE", :get => nil, :clear => nil).as_stubbed_const
+        expect(http_request).to eq response
+        expect(token_cache).to have_received(:get).with("token")
+        expect(token_cache).to have_received(:clear)
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require "bundler/setup"
+require "typekit_client"
+require 'rack/test'
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/typekit_api_spec.rb

@@ -0,0 +1,261 @@
+RSpec.describe TypekitClient::TypekitAPI do
+
+  describe '#kits' do
+
+    context 'with successful response from http_request' do
+      let(:response) { Net::HTTPSuccess.new('response', '200', '') }
+      let(:kits) { subject.kits('json') }
+
+      it 'prints message if the response has no body' do
+        allow(TypekitClient::HttpRequest).to receive(:request) { response }
+        allow(response).to receive_message_chain(:body, :empty?).and_return(true)
+        expect { kits }.to output(/The command ran successfully/).to_stdout
+      end
+    end
+
+    context 'with failure response from http_request' do
+      let(:response) { Net::HTTPNotFound.new('response', '404', '') }
+      let(:kits) { subject.kits('json') }
+
+      it 'prints error message' do
+        allow(TypekitClient::HttpRequest).to receive(:request) { response }
+        allow(response).to receive(:body).and_return("{\"errors\":[\"Not Found\"]}")
+        expect { kits }.to output(/The following error occurred while running the command:404/).to_stdout
+      end
+
+    end
+  end
+
+  describe '#kit' do
+
+    context 'with successful response from http_request' do
+      let(:response) { Net::HTTPSuccess.new('response', '200', '') }
+      let(:kit) { subject.kit('kit_id', 'json') }
+
+      it 'prints message if the response has no body' do
+        allow(TypekitClient::HttpRequest).to receive(:request) { response }
+        allow(response).to receive_message_chain(:body, :empty?).and_return(true)
+        expect { kit }.to output(/The command ran successfully/).to_stdout
+      end
+    end
+
+    context 'with failure response from http_request' do
+      let(:response) { Net::HTTPNotFound.new('response', '404', '') }
+      let(:kit) { subject.kit('kit_id', 'json') }
+
+      it 'prints error message when kit is not found' do
+        allow(TypekitClient::HttpRequest).to receive(:request) { response }
+        allow(response).to receive(:body).and_return("{\"errors\":[\"Not Found\"]}")
+        expect { kit }.to output(/The following error occurred while running the command:404/).to_stdout
+      end
+
+    end
+  end
+
+  describe '#create_kit' do
+
+    context 'with successful response from http_request' do
+      let(:response) { Net::HTTPSuccess.new('response', '200', '') }
+      let(:create_kit) { subject.create_kit({ "name" => "test", domains: "http://localhost.com", segmented_css_names: false }) }
+
+      it 'prints message if the response has no body' do
+        allow(TypekitClient::HttpRequest).to receive(:request) { response }
+        allow(response).to receive_message_chain(:body, :empty?).and_return(true)
+        expect { create_kit }.to output(/The command ran successfully/).to_stdout
+      end
+    end
+
+    context 'with failure response from http_request' do
+      let(:response) { Net::HTTPForbidden.new('response', '403', '') }
+      let(:create_kit) { subject.create_kit({ name: "test", domains: "http://localhost.com", segmented_css_names: false }) }
+
+      it 'prints error message when 403 is thrown' do
+        allow(TypekitClient::HttpRequest).to receive(:request) { response }
+        allow(response).to receive(:body).and_return("{\"errors\":[\"Not Found\"]}")
+        expect { create_kit }.to output(/The following error occurred while running the command:403/).to_stdout
+      end
+
+    end
+  end
+
+  describe '#delete_kit' do
+
+    context 'with successful response from http_request' do
+      let(:response) { Net::HTTPSuccess.new('response', '200', '') }
+      let(:delete_kit) { subject.delete_kit('kit_id', 'json') }
+
+      it 'prints message if the response has no body' do
+        allow(TypekitClient::HttpRequest).to receive(:request) { response }
+        allow(response).to receive_message_chain(:body, :empty?).and_return(true)
+        expect { delete_kit }.to output(/The command ran successfully/).to_stdout
+      end
+    end
+
+    context 'with failure response from http_request' do
+      let(:response) { Net::HTTPNotFound.new('response', '404', '') }
+      let(:delete_kit) { subject.delete_kit('kit_id', 'json') }
+
+      it 'prints error message when kit is not found' do
+        allow(TypekitClient::HttpRequest).to receive(:request) { response }
+        allow(response).to receive(:body).and_return("{\"errors\":[\"Not Found\"]}")
+        expect { delete_kit }.to output(/The following error occurred while running the command:404/).to_stdout
+      end
+
+    end
+  end
+
+  describe '#family' do
+
+    context 'with successful response from http_request' do
+      let(:response) { Net::HTTPSuccess.new('response', '200', '') }
+      let(:family) { subject.family('kit_id', 'family_id', 'json') }
+
+      it 'prints message if the response has no body' do
+        allow(TypekitClient::HttpRequest).to receive(:request) { response }
+        allow(response).to receive_message_chain(:body, :empty?).and_return(true)
+        expect { family }.to output(/The command ran successfully/).to_stdout
+      end
+    end
+
+    context 'with failure response from http_request' do
+      let(:response) { Net::HTTPNotFound.new('response', '404', '') }
+      let(:family) { subject.family('kit_id', 'family_id', 'json') }
+
+      it 'prints error message when kit is not found' do
+        allow(TypekitClient::HttpRequest).to receive(:request) { response }
+        allow(response).to receive(:body).and_return("{\"errors\":[\"Not Found\"]}")
+        expect { family }.to output(/The following error occurred while running the command:404/).to_stdout
+      end
+
+    end
+  end
+
+  describe '#add_family' do
+
+    context 'with successful response from http_request' do
+      let(:response) { Net::HTTPSuccess.new('response', '200', '') }
+      let(:add_family) { subject.add_family('kit_id', 'family_id', { name: "test", domains: "http://localhost.com",
+                                                                     segmented_css_names: false }) }
+
+      it 'prints message if the response has no body' do
+        allow(TypekitClient::HttpRequest).to receive(:request) { response }
+        allow(response).to receive_message_chain(:body, :empty?).and_return(true)
+        expect { add_family }.to output(/The command ran successfully/).to_stdout
+      end
+    end
+
+    context 'with failure response from http_request' do
+      let(:response) { Net::HTTPForbidden.new('response', '403', '') }
+      let(:add_family) { subject.add_family('kit_id', 'family_id', { name: "test", domains: "http://localhost.com",
+                                                                     segmented_css_names: false }) }
+
+      it 'prints error message when 403 error is thrown' do
+        allow(TypekitClient::HttpRequest).to receive(:request) { response }
+        allow(response).to receive(:body).and_return("{\"errors\":[\"Not Found\"]}")
+        expect { add_family }.to output(/The following error occurred while running the command:403/).to_stdout
+      end
+
+    end
+  end
+
+  describe '#publish_kit' do
+
+    context 'with successful response from http_request' do
+      let(:response) { Net::HTTPSuccess.new('response', '200', '') }
+      let(:publish_kit) { subject.publish_kit('kit_id', 'json') }
+
+      it 'prints message if the response has no body' do
+        allow(TypekitClient::HttpRequest).to receive(:request) { response }
+        allow(response).to receive_message_chain(:body, :empty?).and_return(true)
+        expect { publish_kit }.to output(/The command ran successfully/).to_stdout
+      end
+    end
+
+    context 'with failure response from http_request' do
+      let(:response) { Net::HTTPNotFound.new('response', '404', '') }
+      let(:publish_kit) { subject.publish_kit('kit_id', 'json') }
+
+      it 'prints error message when kit is not found' do
+        allow(TypekitClient::HttpRequest).to receive(:request) { response }
+        allow(response).to receive(:body).and_return("{\"errors\":[\"Not Found\"]}")
+        expect { publish_kit }.to output(/The following error occurred while running the command:404/).to_stdout
+      end
+
+    end
+  end
+
+  describe '#published_kit' do
+
+    context 'with successful response from http_request' do
+      let(:response) { Net::HTTPSuccess.new('response', '200', '') }
+      let(:published_kit) { subject.published_kit('kit_id', 'json') }
+
+      it 'prints message if the response has no body' do
+        allow(TypekitClient::HttpRequest).to receive(:request) { response }
+        allow(response).to receive_message_chain(:body, :empty?).and_return(true)
+        expect { published_kit }.to output(/The command ran successfully/).to_stdout
+      end
+    end
+
+    context 'with failure response from http_request' do
+      let(:response) { Net::HTTPNotFound.new('response', '404', '') }
+      let(:published_kit) { subject.published_kit('kit_id', 'json') }
+
+      it 'prints error message when kit is not found' do
+        allow(TypekitClient::HttpRequest).to receive(:request) { response }
+        allow(response).to receive(:body).and_return("{\"errors\":[\"Not Found\"]}")
+        expect { published_kit }.to output(/The following error occurred while running the command:404/).to_stdout
+      end
+
+    end
+  end
+
+  describe '#delete_family' do
+
+    context 'with successful response from http_request' do
+      let(:response) { Net::HTTPSuccess.new('response', '200', '') }
+      let(:delete_family) { subject.delete_family('kit_id', 'family_id', 'json') }
+
+      it 'prints message if the response has no body' do
+        allow(TypekitClient::HttpRequest).to receive(:request) { response }
+        allow(response).to receive_message_chain(:body, :empty?).and_return(true)
+        expect { delete_family }.to output(/The command ran successfully/).to_stdout
+      end
+    end
+
+    context 'with failure response from http_request' do
+      let(:response) { Net::HTTPNotFound.new('response', '404', '') }
+      let(:delete_family) { subject.delete_family('kit_id', 'family_id', 'json') }
+
+      it 'prints error message when kit is not found' do
+        allow(TypekitClient::HttpRequest).to receive(:request) { response }
+        allow(response).to receive(:body).and_return("{\"errors\":[\"Not Found\"]}")
+        expect { delete_family }.to output(/The following error occurred while running the command:404/).to_stdout
+      end
+
+    end
+  end
+
+  describe '#parse_families' do
+    it 'returns families hash for the given string' do
+
+      expected_hash = {
+        "0" => {"id"=>"abcd", "variations"=>"n2"},
+        "1" =>{"id"=>"2", "variations"=>"i7"}
+      }
+
+      expect(subject.send(:parse_families, 'id:abcd,variations:n2;id:2,variations:i7')).to eq expected_hash
+    end
+
+
+    it 'verifies unnecessary params are ignored' do
+      expected_hash = {
+          "0" => {"id"=>"abcd", "variations"=>"n2"},
+          "1" =>{"id"=>"2", "variations"=>"i7"}
+      }
+
+      expect(subject.send(:parse_families, 'id:abcd,variations:n2,invalid_param:invalid_value;id:2,variations:i7')).to eq expected_hash
+    end
+
+  end
+end

data/spec/typekit_client_spec.rb

@@ -0,0 +1,6 @@
+RSpec.describe TypekitClient do
+  it "has a version number" do
+    expect(TypekitClient::VERSION).not_to be nil
+  end
+
+end

data/typekit_client.gemspec

@@ -0,0 +1,36 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "typekit_client/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "typekit_client"
+  spec.version       = TypekitClient::VERSION
+  spec.authors       = ["Thirukonda Surendran,Koushic Babu"]
+  spec.email         = ["koushicbabuts@gmail.com"]
+
+  spec.summary       = %q{Typekit Ruby Client}
+  spec.description   = %q{Ruby CLI client for typekit API}
+  spec.homepage      = "https://github.com/koushic88/typekit_client"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split("\n")
+
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rack-test', '~> 0.8.2'
+  spec.add_runtime_dependency 'thor', '0.20.0'
+  spec.add_runtime_dependency 'colorize', '0.8.1'
+  spec.add_runtime_dependency 'filecache', '1.0.2'
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: typekit_client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Thirukonda Surendran,Koushic Babu
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-01-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.20.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.20.0
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: filecache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+description: Ruby CLI client for typekit API
+email:
+- koushicbabuts@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/typekit_client
+- lib/typekit_client.rb
+- lib/typekit_client/cli.rb
+- lib/typekit_client/http_request.rb
+- lib/typekit_client/typekit_api.rb
+- lib/typekit_client/version.rb
+- spec/http_request_spec.rb
+- spec/spec_helper.rb
+- spec/typekit_api_spec.rb
+- spec/typekit_client_spec.rb
+- typekit_client.gemspec
+homepage: https://github.com/koushic88/typekit_client
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+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.14
+signing_key: 
+specification_version: 4
+summary: Typekit Ruby Client
+test_files: []