smartring 0.0.1

data/lib/smartling/auth.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'httmultiparty'
+require 'hipsterhash'
+
+module Smartling
+  # Methods for authenticating a Smartling user with the API.
+  module Auth
+    attr_reader :user_id, :user_secret, :access_token, :refresh_token
+
+    def authenticate
+      refresh_token! if access_token&.expired? && refresh_token&.valid?
+      authenticate! unless access_token&.valid?
+      token = access_token.to_s
+      return token unless block_given?
+      yield token
+    end
+
+    public
+
+    def refresh_token!
+      path = '/auth-api/v2/authenticate/refresh'
+      headers = { 'Content-Type' => 'application/json' }
+      payload = { refreshToken: refresh_token.to_s }.to_json
+      resp = self.class.post(path, headers: headers, query: payload)
+      resp = HipsterHash[resp.parsed_response].response
+      raise(Failed, resp) unless resp.code == 'SUCCESS'
+      self.tokens = resp.data
+      true
+    end
+
+    def authenticate!
+      path = '/auth-api/v2/authenticate'
+      payload = { userIdentifier: user_id, userSecret: user_secret }.to_json
+      headers = { 'Content-Type' => 'application/json' }
+      resp = self.class.post(path, headers: headers, body: payload)
+      resp = HipsterHash[resp.parsed_response].response
+      raise(Failed, resp) unless resp.code == 'SUCCESS'
+      self.tokens = resp.data
+      true
+    end
+
+    def tokens=(data)
+      @access_token = Token.new(data.accessToken, data.expiresIn)
+      @refresh_token = Token.new(data.refreshToken, data.refreshExpiresIn)
+    end
+
+    Token = Class.new do
+      def initialize(token, expires_in)
+        @token = token
+        @expires_at = Time.now + expires_in
+      end
+      define_method(:expired?) { @expires_at < Time.now }
+      define_method(:valid?) { !expired? }
+      define_method(:to_s) { @token.to_s }
+    end
+
+    Error = Class.new(Exception)
+    Failed = Class.new(Error)
+  end
+end

data/lib/smartling/client.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'smartling/auth'
+require 'smartling/files'
+require 'smartling/contexts'
+require 'smartling/strings'
+require 'smartling/verbs'
+require 'hipsterhash'
+require 'forwardable'
+
+module Smartling
+  # A fairly generic Smartling REST API client.
+  class Client
+    include HTTMultiParty
+    include Auth
+    include Files
+    include Strings
+    include Contexts
+    include Verbs
+
+    attr_accessor :project_id
+
+    base_uri  'https://api.smartling.com'
+    headers   'Accept' => 'application/json'
+    raise_on  [404, 401, 500]
+
+    def initialize(user_id:     ENV.fetch('SMARTLING_USER_ID'),
+                   user_secret: ENV.fetch('SMARTLING_USER_SECRET'),
+                   project_id:  ENV.fetch('SMARTLING_PROJECT_ID', nil))
+      @user_id = user_id
+      @user_secret = user_secret
+      @project_id = project_id
+    end
+  end
+end

data/lib/smartling/contexts.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Smartling
+  # Methods for dealing wth the Smartling Contexts API
+  module Contexts
+    def contexts(project_id: @project_id, name_filter: nil, offset: nil,
+                 type: nil)
+      path = "/context-api/v2/projects/#{project_id}/contexts"
+      query = {}
+      query[:nameFilter] = name_filter unless name_filter.nil?
+      query[:offset] = Integer(offset) unless offset.nil?
+      query[:type] = type.to_s.upcase unless type.nil?
+      get(path, query: query)
+    end
+
+    def context(project_id: @project_id, context_uid:)
+      path = "/context-api/v2/projects/#{project_id}/contexts/#{context_uid}"
+      get(path)
+    end
+
+    # Uploads a new context. Content must quack like an UploadIO.
+    def upload_context(project_id: @project_id, content:, name: nil)
+      path = "/context-api/v2/projects/#{project_id}/contexts"
+      raise(InvalidContent, content) unless Contexts.valid_content?(content)
+      body = { content: content }
+      body[:name] = name unless name.nil?
+      post(path, body: body)
+    end
+
+    # Uploads a new context. Content must quack like an UploadIO.
+    def upload_context_and_match(project_id: @project_id, content:,
+                                 match_params: nil, name: nil)
+      path = "/context-api/v2/projects/#{project_id}/contexts"
+      path += '/upload-and-match-async'
+      raise(InvalidContent, content) unless Contexts.valid_content?(content)
+      body = { content: content }
+      body[:name] = name unless name.nil?
+      body[:matchParams] = match_params unless match_params.nil?
+      post(path, body: body)
+    end
+
+    def download_context(project_id: @project_id, context_uid:)
+      path = "/context-api/v2/projects/#{project_id}/contexts"
+      path += "/#{context_uid}/content"
+      get(path)
+    end
+
+    def delete_context(project_id: @project_id, context_uid:)
+      path = "/context-api/v2/projects/#{project_id}/contexts/#{context_uid}"
+      delete(path)
+    end
+
+    # POSTs to the /match/async endpoint
+    def match_context(project_id: @project_id, context_uid:, hashcodes: [])
+      path = "/context-api/v2/projects/#{project_id}/contexts/#{context_uid}"
+      path += '/match/async'
+      query = { stringHashcodes: hashcodes }.to_json
+      headers = { 'Content-Type' => 'application/json' }
+      post(path, query: query, headers: headers)
+    end
+
+    # GETs the results of an async match
+    def context_matches(project_id: @project_id, match_id:)
+      path = "/context-api/v2/projects/#{project_id}/match/#{match_id}"
+      get(path)
+    end
+
+    InvalidContent = Class.new(ArgumentError)
+
+    def self.valid_content?(content)
+      %i[read content_type original_filename].all? do |required_method|
+        content.respond_to?(required_method)
+      end
+    end
+  end
+end

data/lib/smartling/files.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'net/http/post/multipart'
+
+module Smartling
+  # Methods for using the Smartling files API
+  module Files
+    def files(project_id: @project_id)
+      path = "/files-api/v2/projects/#{project_id}/files/list"
+      get(path)
+    end
+
+    def file(project_id: @project_id, file_uri:, locale: nil)
+      path = ["/files-api/v2/projects/#{project_id}"]
+      path << "locales/#{locale}" unless locale.nil?
+      path << 'file/status'
+      path = path.join('/')
+      get(path, query: { fileUri: file_uri })
+    end
+
+    def delete_file(project_id: @project_id, file_uri:)
+      path = "/files-api/v2/projects/#{project_id}/file/delete"
+      post(path, body: { fileUri: file_uri })
+    end
+
+    def upload_file(project_id: @project_id, file:, file_uri:, file_type:,
+                    callback: nil, authorize: nil, locales_to_authorize: nil,
+                    smartling: {})
+      raise(InvalidFile, file) unless Files.valid_file?(file)
+      path = "/files-api/v2/projects/#{project_id}/file"
+      body = { file: file, fileUri: file_uri, fileType: file_type }
+      body[:authorize] = authorize unless authorize.nil?
+      body[:callback] = callback unless callback.nil?
+      unless locales_to_authorize.nil?
+        body[:localeIdsToAuthorize] = locales_to_authorize
+      end
+      smartling.each { |k, v| body["smartling.#{k}"] = v }
+      post(path, body: body)
+    end
+
+    InvalidFile = Class.new(ArgumentError)
+
+    def self.valid_file?(content)
+      %i[read content_type original_filename].all? do |required_method|
+        content.respond_to?(required_method)
+      end
+    end
+  end
+end

data/lib/smartling/strings.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Smartling
+  # Methods for the Smartling strings API
+  module Strings
+    def source_strings(project_id: @project_id, file_uri: nil, hashcodes: nil,
+                       limit: nil, offset: nil)
+      path = "/strings-api/v2/projects/#{project_id}/source-strings"
+      query = {}
+      query[:fileUri] = file_uri unless file_uri.nil?
+      query[:stringHashcodes] = hashcodes unless hashcodes.nil?
+      query[:limit] = Integer(limit) unless limit.nil?
+      query[:offset] = Integer(offset) unless limit.nil?
+      get(path, query: query)
+    end
+
+    def translations(project_id: @project_id, file_uri: nil, hashcodes: nil,
+                     limit: nil, offset: nil, retrieval_type: nil,
+                     target_locale_id: nil)
+      path = "/strings-api/v2/projects/#{project_id}/translations"
+      query = {}
+      query[:fileUri] = file_uri unless file_uri.nil?
+      query[:hashcodes] = hashcodes unless hashcodes.nil?
+      query[:retrievalType] = retrieval_type unless retrieval_type.nil?
+      query[:limit] = Integer(limit) unless limit.nil?
+      query[:offset] = Integer(offset) unless limit.nil?
+      query[:targetLocaleId] = target_locale_id unless target_locale_id.nil?
+      get(path, query: query)
+    end
+  end
+end

data/lib/smartling/verbs.rb

@@ -0,0 +1,17 @@
+
+# frozen_string_literal: true
+
+module Smartling
+  module Verbs
+    %i[get put post patch delete].each do |verb|
+      define_method(verb) do |path, options = {}|
+        authenticate do |token|
+          (options[:headers] ||= {})[:Authorization] = "Bearer #{token}"
+          resp = self.class.send(verb, path, options).parsed_response
+          return resp unless resp.is_a?(Hash)
+          HipsterHash[resp].response
+        end
+      end
+    end
+  end
+end

data/lib/smartling.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'smartling/client'
+
+# Smartling contains a client and helpers for working with the Smartling
+# files, contexts, strings and authentication API
+module Smartling
+  class << self
+    # Gets a new Client
+    def new(*args)
+      Client.new(*args)
+    end
+  end
+end

data/lib/smartring.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'smartling'

data/test/smartling/auth_test.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'hipsterhash'
+require 'httmultiparty'
+require 'smartling/client'
+
+describe Smartling::Auth do
+  describe 'authenticate (first time)' do
+    it 'POSTs to the authentication endpoint', :vcr do
+      client = Smartling::Client.new
+      client.authenticate!
+    end
+  end
+
+  describe 'authenticate (twice)' do
+    it 'POSTs to the authentication endpoint', :vcr do
+      client = Smartling::Client.new
+      client.authenticate!
+      client.refresh_token!
+      client.authenticate!
+    end
+  end
+end

data/test/smartling/client_test.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'smartling/client'
+
+describe Smartling::Client, :vcr do
+  let(:options) { {} }
+  let(:client) { Smartling::Client.new(options) }
+
+  it('knows context') { assert client.is_a?(Smartling::Contexts) }
+  it('knows about files') { assert client.is_a?(Smartling::Files) }
+  it('knows about strings') { assert client.is_a?(Smartling::Strings) }
+  it('knows how to authenticate') { assert client.is_a?(Smartling::Auth) }
+
+  it 'can be created with options' do
+    c = Smartling::Client.new(project_id: 3)
+    refute_nil c.user_id
+    refute_nil c.user_secret
+    assert_equal 3, c.project_id
+  end
+
+  it 'is cool with bullshit' do
+    path = '/no/such/path'
+    assert_raises { Smartling::Client.new.get(path) }
+  end
+
+  it 'explains when credentials are borked' do
+    path = '/auth-api/v2/authorize'
+    assert_raises do
+      Smartling::Client.new(user_id: 'no', user_secret: 'way').get(path)
+    end
+  end
+end

data/test/smartling/contexts_test.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'smartling/contexts'
+
+describe Smartling::Contexts do
+  let(:smartling) do
+    Class.new(Minitest::Mock) do
+      include Smartling::Contexts
+    end.new
+  end
+
+  after { smartling.verify }
+
+  describe 'contexts' do
+    it 'lists contexts the items of the smartling contexts result' do
+      smartling.expect(:get, nil) do |path, query:|
+        assert_equal path, '/context-api/v2/projects/1/contexts'
+        assert_equal 'n', query.fetch(:nameFilter)
+        assert_equal 1, query.fetch(:offset)
+        assert_equal 'HTML', query.fetch(:type)
+      end
+      smartling.contexts(project_id: 1, name_filter: 'n',
+                         offset: 1, type: 'HTML')
+    end
+  end
+
+  describe 'context' do
+    it 'gets the /context with the right param' do
+      smartling.expect(:get, nil) do |path|
+        assert_equal '/context-api/v2/projects/1/contexts/x', path
+      end
+      smartling.context(project_id: 1, context_uid: 'x')
+    end
+  end
+
+  describe 'download_context' do
+    it 'gets the /context with the right param' do
+      smartling.expect(:get, nil) do |path|
+        assert_equal '/context-api/v2/projects/1/contexts/x/content', path
+      end
+      smartling.download_context(project_id: 1, context_uid: 'x')
+    end
+  end
+
+  describe 'delete_context' do
+    it 'deletes the context at the right endpoing' do
+      smartling.expect(:delete, nil) do |path|
+        assert_equal '/context-api/v2/projects/1/contexts/x', path
+      end
+      smartling.delete_context(project_id: 1, context_uid: 'x')
+    end
+  end
+
+  describe 'upload_context' do
+    it 'posts the right body to the right endpoint' do
+      smartling.expect(:post, nil) do |path, body:|
+        assert_equal '/context-api/v2/projects/1/contexts', path
+        assert_equal 'n', body.fetch(:name)
+        assert_equal '<i>Hi</i>', body.fetch(:content).read
+        assert_equal 'text/html', body.fetch(:content).content_type
+        assert_equal 'n', body.fetch(:name)
+      end
+      content = UploadIO.new(StringIO.new('<i>Hi</i>'), 'text/html')
+      smartling.upload_context(project_id: 1, content: content, name: 'n')
+    end
+
+    it 'prints a helpful message if the contextType is unsupported' do
+      assert_raises Smartling::Contexts::InvalidContent do
+        smartling.upload_context(project_id: 1, content: 'not a file')
+      end
+    end
+  end
+
+  describe 'upload_context_and_match' do
+    it 'posts the right body to the right endpoint' do
+      smartling.expect(:post, nil) do |path, body:|
+        expected = '/context-api/v2/projects/1/contexts/'
+        expected += 'upload-and-match-async'
+        assert_equal expected, path
+        assert_equal 'n', body.fetch(:name)
+        assert_equal '<i>Hi</i>', body.fetch(:content).read
+        assert_equal 'text/html', body.fetch(:content).content_type
+        assert_equal %w[1 2 3], body.fetch(:matchParams)
+        assert_equal 'n', body.fetch(:name)
+      end
+      content = UploadIO.new(StringIO.new('<i>Hi</i>'), 'text/html')
+      smartling.upload_context_and_match(project_id: 1, content: content,
+                                         match_params: %w[1 2 3], name: 'n')
+    end
+
+    it 'prints a helpful message if the contextType is unsupported' do
+      assert_raises Smartling::Contexts::InvalidContent do
+        smartling.upload_context(project_id: 1, content: 'not a file')
+      end
+    end
+  end
+
+  describe 'async context matching' do
+    it 'posts to the right endpoint with the right params' do
+      smartling.expect(:post, nil) do |path, query:, headers:|
+        assert_equal '/context-api/v2/projects/1/contexts/x/match/async', path
+        assert_equal %w[x], JSON.parse(query)['stringHashcodes']
+        assert_equal 'application/json', headers['Content-Type']
+      end
+      smartling.match_context(project_id: 1, context_uid: 'x',
+                              hashcodes: %w[x])
+    end
+  end
+
+  describe 'retrieving match results' do
+    it 'get the right endpoint' do
+      smartling.expect(:get, nil) do |p|
+        assert_equal '/context-api/v2/projects/1/match/8', p
+      end
+      smartling.context_matches(project_id: 1, match_id: 8)
+    end
+  end
+end

data/test/smartling/files_test.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'smartling/files'
+
+describe Smartling::Files do
+  let(:smartling) do
+    Class.new(Minitest::Mock) do
+      include Smartling::Files
+    end.new
+  end
+
+  after { smartling.verify }
+
+  describe 'files' do
+    it 'lists files the items of the smartling files result' do
+      smartling.expect(:get, nil, ['/files-api/v2/projects/1/files/list'])
+      smartling.files(project_id: 1)
+    end
+  end
+
+  describe 'file' do
+    it 'gets the /file/status endpoint with the right param' do
+      smartling.expect(:get, nil) do |path, query:|
+        assert_match %r{files-api/v2/projects/1/file/status$}, path
+        assert_equal({ fileUri: 'x' }, query)
+      end
+      smartling.file(project_id: 1, file_uri: 'x')
+    end
+  end
+
+  describe 'file with locale' do
+    it 'gets the /locale/x/file/status endpoint with the right params' do
+      smartling.expect(:get, nil) do |path, query:|
+        assert_match %r{files-api/v2/projects/1/locales/es/file/status$}, path
+        assert_equal({ fileUri: 'x' }, query)
+      end
+      smartling.file(project_id: 1, file_uri: 'x', locale: 'es')
+    end
+  end
+
+  describe 'delete_file' do
+    it 'posts the right body to the right endpoint' do
+      smartling.expect(:post, nil) do |path, body:|
+        assert_match %r{files-api/v2/projects/1/file/delete$}, path,
+                     assert_equal({ fileUri: 'x' }, body)
+      end
+      smartling.delete_file(project_id: 1, file_uri: 'x')
+    end
+  end
+
+  describe 'upload_file' do
+    it 'posts the right body to the right endpoint' do
+      smartling.expect(:post, nil) do |path, body:|
+        assert_equal '/files-api/v2/projects/1/file', path
+        assert_equal 'x', body.fetch(:fileUri)
+        assert_equal 'json', body.fetch(:fileType)
+        assert_equal '"hello"', body.fetch(:file).read
+        assert_equal 'application/json', body.fetch(:file).content_type
+        assert_equal 'cb', body.fetch(:callback)
+        assert_equal %w[a b], body.fetch(:localeIdsToAuthorize)
+        assert_equal 'bar', body.fetch('smartling.foo')
+        assert_equal false, body.fetch(:authorize)
+      end
+      file = UploadIO.new(StringIO.new('"hello"'), 'application/json')
+      smartling.upload_file(project_id: 1, file: file, file_uri: 'x',
+                            file_type: 'json', callback: 'cb',
+                            locales_to_authorize: %w[a b],
+                            smartling: { foo: 'bar' }, authorize: false)
+    end
+    it 'throws an exception if the file is not a file' do
+      assert_raises Smartling::Files::InvalidFile do
+        smartling.upload_file(project_id: 1, file: 'hi', file_uri: 'x',
+                              file_type: 'bullshit')
+      end
+    end
+  end
+end

data/test/smartling/strings_test.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'smartling/strings'
+
+describe Smartling::Strings do
+  let(:smartling) do
+    Class.new(Minitest::Mock) do
+      include Smartling::Strings
+    end.new
+  end
+
+  describe 'source_strings' do
+    it 'lists files the items of the smartling files result' do
+      smartling.expect(:get, nil) do |path, query:|
+        assert_equal path, '/strings-api/v2/projects/1/source-strings'
+        assert_equal 'x', query.fetch(:fileUri)
+        assert_equal ['a'], query.fetch(:stringHashcodes)
+        assert_equal 99, query.fetch(:limit)
+        assert_equal 2, query.fetch(:offset)
+      end
+      smartling.source_strings(project_id: 1, file_uri: 'x', hashcodes: ['a'],
+                               limit: 99, offset: 2)
+    end
+  end
+end

data/test/smartling_test.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'smartling'
+
+describe Smartling do
+  it 'can be "instantiated"' do
+    assert_instance_of Smartling::Client, Smartling.new
+  end
+
+  it 'handles things gracefully', :vcr do
+    client = Smartling::Client.new
+    assert_instance_of HipsterHash, client.files
+    assert_instance_of HipsterHash, client.translations(file_uri: 'boo')
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+
+require 'simplecov'
+SimpleCov.start
+
+require 'minitest/autorun'
+
+require 'dotenv'
+Dotenv.load '.env.local', '.env.test'
+
+require 'vcr'
+require 'cgi'
+VCR.configure do |vcr|
+  vcr.hook_into :webmock
+  vcr.cassette_library_dir = 'test/cassettes'
+  vcr.filter_sensitive_data('SMARTLING_PROJECT_ID') { ENV.fetch('SMARTLING_PROJECT_ID') }
+  vcr.filter_sensitive_data('SMARTLING_USER_ID') { ENV.fetch('SMARTLING_USER_ID') }
+  vcr.filter_sensitive_data('SMARTLING_USER_SECRET') { ENV.fetch('SMARTLING_USER_SECRET') }
+end
+
+require 'minitest-vcr'
+MinitestVcr::Spec.configure!
+
+require 'pry'