typekitable 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 07bb313e5d918cc2e3eb1315fd657baa888d4368
+  data.tar.gz: 9862a8897cc8be29054bb2b05d4509198df538fe
+SHA512:
+  metadata.gz: a5022b0861150976b4afa6a2a74659521f5bdba0c9194fc3a575dea2db1ac535b69bf4eb9ff45455c14743ff63581d55466b4aa45cc557b956fbfd3a902c1cf7
+  data.tar.gz: 828707e0d58dcb70564740b6637c5782a80e8ec5a73a3a0ef267b21f7987cf70803f978dacbf2f39e9603ab2eb3a4b2064b2c67a3e92e194f9e85279e3b3e826

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.ruby-version

@@ -0,0 +1 @@
+2.2.0

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'rspec'
+  gem 'aruba'
+  gem 'cucumber'
+  gem 'vcr'
+  gem 'webmock'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Persa Zula
+
+MIT License
+
+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,38 @@
+# Typekitable
+
+A CLI for interacting with your Typekit kits.
+
+Get an API token [here](https://typekit.com/account/tokens) and get started!
+
+
+## Installation
+
+Install it yourself as:
+
+    $ gem install typekitable
+
+## Usage
+
+  Command                         |  Description
+  ------------------------------- |-------------------------------------
+  typekitable kit_add NAME DOMAINS|  # Adds a new kit
+  typekitable kit_info KIT_ID     |  # Get information on a specific kit
+  typekitable kit_list            |  # Get a list of all of your kits
+  typekitable kit_publish KIT_ID  |  # Publish a draft kit
+  typekitable re-authenticate     |  # Reset your Typekit API token
+
+## Tests
+
+Unit tests are written with [rspec](https://github.com/rspec/rspec) and can be run with the command `rake spec`
+
+Feature tests are written with [cucumber](https://github.com/cucumber/cucumber) and [aruba](https://github.com/cucumber/aruba) and can be run with the command `rake features`
+
+
+## Contributing
+
+1. Fork it ( https://github.com/pzula/typekitable/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Add spec coverage
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler/gem_tasks'
+require 'rubygems'
+require 'cucumber'
+require 'cucumber/rake/task'
+require 'rspec/core/rake_task'
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --format pretty"
+end
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.rspec_opts = "--format documentation --color"
+end

data/bin/typekitable

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require "typekitable"
+
+exit unless Typekitable::Tokenizer.has_token? || Typekitable::Authenticator.new.get_authentication
+
+Typekitable::Commander.start

data/features/authentication.feature

@@ -0,0 +1,13 @@
+@mock_home_directory
+Feature: As a user, I can enter my API token credentials
+
+  Scenario: Invoking the CLI to re-authenticate with a token results in success
+    Given I run `bundle exec ruby bin/typekitable re-authenticate` interactively
+      And I type "y"
+      And I type "4d6141e7c82cb30affebcc392abc2ce3ab0ea4c1"
+     Then the output should contain "Thank you, your Typekit API token has been stored"
+
+  Scenario: Invoking the CLI to re-authenticate without a token gives me API token generation information
+    Given I run `bundle exec ruby bin/typekitable re-authenticate` interactively
+      And I type "n"
+     Then the output should contain "Generate an API token"

data/features/kits.feature

@@ -0,0 +1,22 @@
+@mock_home_directory
+Feature: As a user with a stored token, I can interact with the commands
+
+  Background:
+    * I have a stored token
+
+  Scenario: I can get a list of all of my commands
+    Given I run `bundle exec ruby bin/typekitable help`
+     Then the output should contain "Commands"
+
+  Scenario: I can get a list of my kits
+    Given I run `bundle exec ruby bin/typekitable kit_list`
+     Then the output should contain "rmc4kry"
+
+  Scenario: I can get information about a kit
+    Given I run `bundle exec ruby bin/typekitable kit_info "rmc4kry"`
+     Then the output should contain "droid kit"
+
+  Scenario: I can publish a draft kit
+    Given I run `bundle exec ruby bin/typekitable kit_publish "rmc4kry"`
+     Then the output should contain "published"
+

data/features/step_definitions/kit_steps.rb

@@ -0,0 +1,5 @@
+Given(/^I have a stored token$/) do
+  File.open(File.absolute_path('.typekitable', Dir.home), 'w') do |file|
+    file.write("5e4ce50b7c5b996b2fb5e65ee4a6b870b9bd3297")
+  end
+end

data/features/support/env.rb

@@ -0,0 +1,15 @@
+require 'cucumber'
+require 'aruba/cucumber'
+
+Before do
+  @dirs = [File.expand_path(File.join(File.dirname(__FILE__), '../..'))]
+end
+
+Before '@mocked_home_directory' do
+  set_env 'HOME', File.expand_path(File.join(current_dir, 'home'))
+  FileUtils.mkdir_p ENV['HOME']
+end
+
+After '@mocked_home_directory' do
+  FileUtils.rm_f ENV['HOME']
+end

data/lib/typekitable.rb

@@ -0,0 +1,11 @@
+require "thor"
+require "net/http"
+require "formatador"
+require "json"
+require "typekitable/version"
+require "typekitable/commander"
+require "typekitable/tokenizer"
+require "typekitable/authenticator"
+require "typekitable/request_fetcher"
+require "typekitable/request"
+require "typekitable/response_formatter"

data/lib/typekitable/authenticator.rb

@@ -0,0 +1,22 @@
+module Typekitable
+  class Authenticator < Thor
+    include Thor::Actions
+
+    no_commands do
+      def get_authentication
+        if no?("Do you have a Typekit API token? [y/N]", :yellow)
+          say("Generate an API token at https://typekit.com/account/tokens and come back once you have it, we will only ask for it once", :red)
+          exit
+        else
+          request_token
+        end
+      end
+
+      def request_token
+        token = ask("What is your Typekit API token?:", :red)
+        Tokenizer.store(token)
+        say("Thank you, your Typekit API token has been stored.", :green)
+      end
+    end
+  end
+end

data/lib/typekitable/commander.rb

@@ -0,0 +1,51 @@
+module Typekitable
+  class Commander < Thor
+    include Thor::Actions
+
+    desc "re-authenticate", "Reset your Typekit API token"
+    def re_authenticate
+      Authenticator.new.get_authentication
+      invoke :help
+    end
+
+    desc "kit_list", "Get a list of all of your kits"
+    def kit_list
+      result = formatted_response(response_for_command(:kit_list))
+      result.output_heading
+      result.output_body
+    end
+
+    desc "kit_add NAME DOMAINS", "Adds a new kit"
+    def kit_add(name, domains)
+      response = response_for_command(:kit_add,  { :name => name, :domains => [domains] })
+      result = formatted_response(response)
+      result.output_heading
+      result.output_body
+    end
+
+    desc "kit_info KIT_ID", "Get information on a specific kit"
+    def kit_info(kit_id)
+      result = formatted_response(response_for_command(:kit_info, {}, kit_id))
+      result.output_heading
+      result.output_body
+    end
+
+    desc "kit_publish KIT_ID", "Publish a draft kit"
+    def kit_publish(kit_id)
+      result = formatted_response(response_for_command(:kit_publish, {}, kit_id))
+      result.output_heading
+      result.output_body
+    end
+
+    no_commands do
+      def response_for_command(command_type, options = {}, resource_id = nil)
+        RequestFetcher.new(command_type, options, resource_id).response
+      end
+
+      def formatted_response(response)
+        ResponseFormatter.new(response)
+      end
+    end
+
+  end
+end

data/lib/typekitable/request.rb

@@ -0,0 +1,66 @@
+module Typekitable
+  class Request
+    attr_reader :path, :verb, :parameters
+
+    BASE_URL = "https://typekit.com/api/v1/json/"
+
+    def initialize(path, verb, parameters)
+      @path = path
+      @verb = verb
+      @parameters = parameters
+    end
+
+    def token
+      Tokenizer.get_token
+    end
+
+    def response
+      case verb
+        when "GET" then get_request_response
+        when "POST" then post_request_response
+      end
+    end
+
+    def uri
+      URI.parse(BASE_URL + path)
+    end
+
+    def headers
+      { "X-Typekit-Token" => token }
+    end
+
+    private
+
+    def http_request
+      Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |https|
+        yield(https, uri)
+      end
+    end
+
+    def get_request_response
+      http_request do |https, uri|
+        response = https.get(uri.path, headers)
+        build_response(response.code, response.message, response.body)
+      end
+    end
+
+    def post_request_response
+      req = Net::HTTP::Post.new(uri.path, headers)
+      req.set_form_data(parameters)
+      http_request do |https, uri|
+        response = https.request(req)
+        build_response(response.code, response.message, response.body)
+      end
+    end
+
+    def build_response(code, message, body)
+      Response.new(:code => code, :message => message, :body => body)
+    end
+  end
+
+  class Response < Struct.new(:code, :message, :body)
+    def initialize(from_hash)
+      super(*from_hash.values_at(*members))
+    end
+  end
+end

data/lib/typekitable/request_fetcher.rb

@@ -0,0 +1,72 @@
+module Typekitable
+  class RequestFetcher
+    attr_reader :type, :options, :resource_id
+
+    VALID_TYPES = [:kit_list, :kit_add, :kit_info, :kit_publish]
+    VALID_OPTIONS = {
+      :kit_add => [:name, :domains]
+    }
+
+    def initialize(type, options = {}, resource_id = nil)
+      @type = validate_type(type)
+      @options = validate_options(options)
+      @resource_id = resource_id
+    end
+
+    def request_path
+      request_config[type][:request_path]
+    end
+
+    def verb
+      request_config[type][:verb]
+    end
+
+    def parameters
+      options
+    end
+
+    def response
+      Request.new(request_path, verb, parameters).response
+    end
+
+    private
+
+    def request_config
+      {
+        :kit_list => {
+          :request_path => "kits",
+          :verb => "GET"
+        },
+        :kit_add => {
+          :request_path => "kits",
+          :verb => "POST"
+        },
+        :kit_info => {
+          :request_path => "kits/#{resource_id}",
+          :verb => "GET"
+        },
+        :kit_publish => {
+          :request_path => "kits/#{resource_id}/publish",
+          :verb => "POST"
+        }
+      }
+    end
+
+    def validate_type(type)
+      raise InvalidTypeError unless VALID_TYPES.include?(type)
+
+      return type
+    end
+
+    def validate_options(options_list)
+      if options_list.empty? || VALID_OPTIONS[:kit_add].all? {|element| options_list.keys.include?(element) }
+        return options_list
+      else
+        raise InvalidOptionsError
+      end
+    end
+  end
+
+  class InvalidTypeError < StandardError; end
+  class InvalidOptionsError < StandardError; end
+end

data/lib/typekitable/response_formatter.rb

@@ -0,0 +1,120 @@
+module Typekitable
+  class ResponseFormatter
+    attr_reader :response
+
+    ERRORS = {
+      "400" => "Error in data sent",
+      "401" => "Not authorized",
+      "403" => "Rate limit reached",
+      "404" => "Not found",
+      "500" => "Unable to process request",
+      "503" => "Service is offline"
+    }
+
+    def initialize(response)
+      @response = response
+    end
+
+    def error?
+      ERRORS.keys.include?(response.code)
+    end
+
+    def parsed_body
+      JSON.parse(response.body, :symbolize_names => true)
+    end
+
+    def table_headers
+      if error?
+        error_key
+      elsif collection?
+        collection_headers
+      elsif singular_resource?
+        singular_resource_headers
+      else
+        [main_key]
+      end
+    end
+
+    def table_body
+      if error?
+        error_message
+      elsif collection?
+        collection_data
+      elsif singular_resource?
+        singular_resource_data
+      else
+        [parsed_body]
+      end
+    end
+
+    def data_heading
+      main_key.to_s.capitalize
+    end
+
+    def output_heading
+      display_line(data_heading)
+    end
+
+    def output_body
+      display_table(table_body, table_headers)
+    end
+
+    private
+
+    def data_element
+      parsed_body[main_key]
+    end
+
+    def singular_resource?
+      !error? && data_element.is_a?(Hash)
+    end
+
+    def collection?
+      !error? && data_element.is_a?(Array)
+    end
+
+    def empty_response?
+      data_element.any?
+    end
+
+    def main_key
+      parsed_body.keys.first
+    end
+
+    def collection_headers
+      data_element.map do |data|
+        data.keys
+      end.flatten.uniq
+    end
+
+    def collection_data
+      data_element.map do |line|
+        line
+      end
+    end
+
+    def singular_resource_headers
+      data_element.keys
+    end
+
+    def singular_resource_data
+      [data_element]
+    end
+
+    def error_key
+      [response.code]
+    end
+
+    def error_message
+      [{response.code => data_element.pop}]
+    end
+
+    def display_line(line)
+      Formatador.display_line(line)
+    end
+
+    def display_table(table_data, headers)
+      Formatador.display_table(table_data, headers)
+    end
+  end
+end