one_sky 1.0.0 → 2.0.0

data/lib/one_sky/translation.rb

@@ -0,0 +1,129 @@
+module OneSky
+  
+  # Implements the Translation I/O API for a given :platform_id
+  class Translation
+    
+    attr_reader :platform_id, :client
+    
+    # Provide the id of the platform, together with an instance of OneSky::Client.
+    def initialize(platform_id, client)
+      @platform_id = platform_id
+      @client = client
+    end
+
+    # Add new strings to be translated.
+    #   expects an array of strings, or an array of hashes [{:string_key => k, :string => v}, ...]
+    def input_strings(strings)
+      post("string/input", :input => format_input_strings(strings))
+    end
+    
+    # Add new strings to be translated.
+    #   expects a string, or a hash of {:string_key => k, :string => v}
+    def input_string(string)
+      input_strings([string])
+    end
+    
+    # Add new strings to be translated.
+    #   expects a hash of {"string_key1" => "String 1", "string_key2" => "String 2"}
+    def input_phrases(phrases)
+      strings = phrases.map do |string_key, string|
+        {:string_key => string_key, :string => string}
+      end
+      input_strings(strings)
+    end
+    
+    # Add translation to a string.
+    def translate(string_key, locale, translation)
+      post("string/translate", :"string-key" => string_key, :locale => locale, :translation => translation)
+    end
+    
+    # Get the strings with translations.
+    def output
+      get_output
+    end
+    
+    # Get the strings for a particular locale.
+    def output_for_locale(locale)
+      get_output(locale)
+    end
+    
+    YAML_FORMAT = "RUBY_YAML".freeze
+    PO_FORMAT = "GNU_PO".freeze
+    
+    # I don't believe these work right now.
+    
+      # Upload a string file to add new strings. In RUBY_YAML format.
+      def upload_yaml(file)
+        upload_file(file, YAML_FORMAT)
+      end
+    
+      # Upload a string file to add new strings. In GNU_PO format.
+      def upload_po(file)
+        upload_file(file, PO_FORMAT)
+      end
+    
+    # Download strings and translations as string file. In RUBY_YAML format.
+    def download_yaml(locale)
+      download_file(locale, YAML_FORMAT)
+    end
+    
+    # Download strings and translations as string file. In GNU_PO format.
+    def download_po(locale)
+      download_file(locale, PO_FORMAT)
+    end
+    
+    protected
+    
+    # Get the strings with translations.
+    def get_output(locale=nil)
+      options = {}
+      options[:locale] = locale if locale
+      
+      get("string/output", options)["translation"]
+    end
+    
+    # Upload a string file to add new strings.
+    def upload_file(file, format)
+      post("string/upload", :file => file, :format => format)
+    end
+    
+    # Download strings and translations as string file.
+    def download_file(locale, format)
+      get("string/download", :locale => locale, :format => format)
+    end
+    
+    def get(path, params={})
+      client.get(path, params.merge(:"platform-id" => platform_id))
+    end
+    
+    def post(path, params={})
+      client.post(path, params.merge(:"platform-id" => platform_id))
+    end
+    
+    def format_input_strings(strings)
+      JSON.dump(strings.map{|string| format_input_string(string)})
+    end
+    
+    def format_input_string(string)
+      case string
+      when String
+        {:string => string}
+      when Hash
+        dashify_string_hash(string)
+      else
+        raise "input string must either be a string, or a hash"
+      end
+    end
+    
+    # convert to "string-key" not "string_key"
+    def dashify_string_hash(string_hash)
+      output = Hash.new
+      string_hash.each do |key, value|
+        dashed = key.to_s.gsub("_", "-").to_sym
+        output[dashed] = value
+      end
+      output
+    end
+
+  end
+end

data/lib/one_sky/utility.rb

@@ -0,0 +1,38 @@
+module OneSky
+  
+  # Implements the Utility API
+  class Utility
+    
+    attr_reader :client
+    
+    def initialize(client)
+      @client = client
+    end
+    
+    # Get available locale list.
+    def locales
+      get("locales")["locales"]
+    end
+    
+    # Get available platform type list.
+    def platform_types
+      get("platform-types")["types"]
+    end
+    
+    # Get the Single-Sign-On link for logging in.
+    def get_sso_link(unique_id, name)
+      post("sso/get-link", {:"unique-id" => unique_id, :name => name})["url"]
+    end
+    
+    protected
+    
+    def get(path)
+      client.get(path)
+    end
+    
+    def post(path, params)
+      client.post(path, params)
+    end
+    
+  end
+end

data/lib/one_sky/version.rb

@@ -1,3 +1,3 @@
 module OneSky
-  VERSION = "1.0.0"
+  VERSION = "2.0.0"
 end

data/one_sky.gemspec

@@ -14,11 +14,12 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "one_sky"
 
-  s.add_dependency "json", ">= 1.4.6"
-  s.add_dependency "rest-client", "~> 1.6.1"
+  s.add_dependency "json", ">= 1.4.0"
+  s.add_dependency "rest-client", ">= 1.4.0"
 
   s.add_development_dependency "rspec", "~> 2.2.0"
-  s.add_development_dependency "bundler", "~> 1.0.0"
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "time_freeze"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/spec/client_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+
+describe OneSky::Client do
+
+  let(:api_key) { "apikey" }
+  let(:secret)  { "secret" }
+  
+  let(:client) { OneSky::Client.new(api_key, secret) }
+  
+  let(:fake_response) { mock("some response", :headers => {:content_type => "text/plain"}, :body => "response") }
+  let(:fake_json) {     mock("json response", :headers => {:content_type => "json"}, :body => %|{"some": "json"}|) }
+  
+  describe "proxies" do
+    describe "utility" do
+      it "returns a OneSky::Utility instance" do
+        client.utility.should be_an_instance_of OneSky::Utility
+      end
+      
+      it "sets the client to itself" do
+        client.utility.client.should == client
+      end
+    end
+    
+    describe "project" do
+      it "returns a OneSky::Project instance" do
+        client.project("some-project").should be_an_instance_of OneSky::Project
+      end
+      
+      it "sets the client to itself" do
+        client.project("some-project").client.should == client
+      end
+      
+      it "sets the provided project name" do
+        client.project("some-project").project_name.should == "some-project"
+      end
+    end
+    
+  end
+  
+  describe "get" do
+
+    it "GETs the given path" do
+      RestClient.should respond_to(:post)
+      RestClient.should_receive(:get).with("https://api.oneskyapp.com/2/some_path/to/something", kind_of(Hash)).and_return(fake_response)
+      client.get("some_path/to/something")
+    end
+    
+    it "GETs the given path - when given a leading /" do
+      RestClient.should_receive(:get).with("https://api.oneskyapp.com/2/some_path/to/something", kind_of(Hash)).and_return(fake_response)
+      client.get("/some_path/to/something")
+    end
+    
+    it "passes in the api key, timestamp, and a hash of the secret" do
+      Time.freeze! do
+        timestamp = Time.now.to_i.to_s
+        RestClient.should_receive(:get).with(
+          kind_of(String),
+          {:params => {
+            :"api-key" => api_key,
+            :timestamp => timestamp,
+            :"dev-hash" => Digest::MD5.hexdigest(timestamp + secret)
+          },
+          :content_type => "text/plain; charset=UTF-8"}
+        ).and_return(fake_response)
+        client.get("some_path/to/something")
+      end
+    end
+    
+    it "adds any provided params" do
+      Time.freeze! do
+        timestamp = Time.now.to_i.to_s
+        RestClient.should_receive(:get).with(
+          kind_of(String),
+          {:params => {
+            :"api-key" => api_key,
+            :timestamp => timestamp,
+            :"dev-hash" => Digest::MD5.hexdigest(timestamp + secret),
+            :some => "other param"
+          },
+          :content_type => "text/plain; charset=UTF-8"}
+        ).and_return(fake_response)
+        client.get("some_path/to/something", :some => "other param")
+      end
+    end
+    
+    context "with a json content_type" do
+      it "parses the json" do
+        RestClient.should_receive(:get).and_return(fake_json)
+        client.get("some_path").should == {"some" => "json"}
+      end
+      
+      it "raises an error if the response: is not OK" do
+        fake_json.should_receive(:body).and_return(%|{"response": "bad"}|)
+        RestClient.should_receive(:get).and_return(fake_json)
+        expect {
+          client.get("some_path")
+        }.to raise_error(OneSky::ApiError)
+      end
+    end
+    
+    context "without a non-json content_type" do
+      it "returns the body" do
+        RestClient.should_receive(:get).and_return(fake_response)
+        client.get("some_path").should == fake_response.body
+      end
+    end
+  end
+  
+  describe "post" do
+
+    it "POSTSs the given path" do
+      RestClient.should respond_to(:post)
+      RestClient.should_receive(:post).with("https://api.oneskyapp.com/2/some_path/to/something", kind_of(Hash)).and_return(fake_response)
+      client.post("some_path/to/something")
+    end
+    
+    it "passes in the api key, timestamp, and a hash of the secret" do
+      Time.freeze! do
+        timestamp = Time.now.to_i.to_s
+        RestClient.should_receive(:post).with(
+          kind_of(String),
+          {
+            :"api-key" => api_key,
+            :timestamp => timestamp,
+            :"dev-hash" => Digest::MD5.hexdigest(timestamp + secret),
+            :content_type => "text/plain; charset=UTF-8"
+          }
+        ).and_return(fake_response)
+        client.post("some_path/to/something")
+      end
+    end
+    
+    it "adds any provided params" do
+      Time.freeze! do
+        timestamp = Time.now.to_i.to_s
+        RestClient.should_receive(:post).with(
+          kind_of(String),
+          {
+            :"api-key" => api_key,
+            :timestamp => timestamp,
+            :"dev-hash" => Digest::MD5.hexdigest(timestamp + secret),
+            :some => "other param",
+            :content_type => "text/plain; charset=UTF-8"
+          }
+        ).and_return(fake_response)
+        client.post("some_path/to/something", :some => "other param")
+      end
+    end
+    
+    context "with a json content_type" do
+      it "parses the json" do
+        RestClient.should_receive(:post).and_return(fake_json)
+        client.post("some_path").should == {"some" => "json"}
+      end
+      
+      it "raises an error if the response: is not OK" do
+        fake_json.should_receive(:body).and_return(%|{"response": "bad"}|)
+        RestClient.should_receive(:post).and_return(fake_json)
+        expect {
+          client.post("some_path")
+        }.to raise_error(OneSky::ApiError)
+      end
+    end
+    
+    context "without a non-json content_type" do
+      it "returns the body" do
+        RestClient.should_receive(:post).and_return(fake_response)
+        client.post("some_path").should == fake_response.body
+      end
+    end
+  end
+end

data/spec/files/example.po

@@ -0,0 +1,2 @@
+msgid "test1"
+msgstr "Test 1"

data/spec/files/example.yml

@@ -0,0 +1,5 @@
+en_US:
+  test1: "Test 1"
+  
+zh_CN:
+  test1: "测试一"

data/spec/live_spec.rb

@@ -0,0 +1,187 @@
+# encoding: utf-8
+
+# this spec runs through live api calls
+# and requires a real api key for the account
+#
+#   http://ruby-gem-tests.oneskyapp.com/
+#
+# before running this test we need to do
+#
+#   export ONESKY_API_KEY="the key"
+#   export ONESKY_API_SECRET="the secret"
+#
+# the rake spec task skips these test
+# you need to run
+#
+#   rake spec:live
+#
+require 'spec_helper'
+require 'yaml'
+
+describe OneSky, :live => true do
+  
+  let(:onesky_api_key)    { ENV["ONESKY_API_KEY"] }
+  let(:onesky_api_secret) { ENV["ONESKY_API_SECRET"] }
+  let(:project_name)      { "api-test" }
+  let(:platform_id)       { 840 }
+  let(:platform_code)     { "website" }
+  
+  let(:english_locale) { "en_US" }
+  let(:chinese_locale) { "zh_CN" }
+  
+  let(:client) do
+    client = OneSky::Client.new(onesky_api_key, onesky_api_secret)
+  end
+  
+  context "utility apis" do
+    let(:utility) do
+      client.utility
+    end
+    
+    it "locales" do
+      locales = utility.locales
+      locales.should be_an_instance_of Array
+      locales.should_not be_empty
+      en_us = locales.detect{|l| l["locale"] == english_locale }
+      en_us["name"]["eng"].should == "English (US)"
+    end
+    
+    it "platform_types" do
+      types = utility.platform_types
+      types.should be_an_instance_of Array
+      types.should_not be_empty
+      website = types.detect{|t| t["code"] == platform_code }
+      website.should == {"name" => "Website", "code" => platform_code}
+    end
+    
+    it "get_sso_link" do
+      link = utility.get_sso_link(123, "fred")
+      link.should be_an_instance_of String
+      link.should match(".oneskyapp.com/")
+    end
+  end
+  
+  context "project" do
+    let(:project) do
+      client.project(project_name)
+    end
+    
+    it "details" do
+      details = project.details
+      details.should be_an_instance_of Hash
+      details["name"].should == project_name
+    end
+    
+    it "platforms" do
+      platforms = project.platforms
+      platforms.should be_an_instance_of Array
+      platforms.should_not be_empty
+      
+      expected = platforms.detect{|p| p["id"]== platform_id}
+      expected.should be_an_instance_of Hash
+      expected["code"].should == platform_code
+    end
+  end
+  
+  context "platform" do
+    let(:platform) do
+      client.project(project_name).platform(platform_id)
+    end
+    
+    it "details" do
+      details = platform.details
+      details.should be_an_instance_of Hash
+      details["project"].should == project_name
+      details["type"]["code"].should == platform_code
+    end
+    
+    it "locales" do
+      locales = platform.locales
+      locales.should be_an_instance_of Array
+      locales.should_not be_empty
+      en_us = locales.detect{|l| l["locale"] == english_locale }
+      en_us["name"]["eng"].should == "English (US)"
+    end
+  end
+  
+  context "translation" do
+    let(:translation) do
+      client.project(project_name).platform(platform_id).translation
+    end
+    
+    it "input_phrases" do
+      translation.input_phrases("test1" => "Test 1", "test2" => "Test 2")
+    end
+    
+    it "input_strings - as strings" do
+      translation.input_strings(["test1", "test2"])
+    end
+    
+    it "input_strings - as hashes" do
+      translation.input_strings([{:string => "Test 3", :string_key => "test3"}, {:string => "Test 4", :string_key => "test4"}])
+    end
+    
+    it "input_string - as string" do
+      translation.input_string("test5")
+    end
+    
+    it "input_string - as hash" do
+      translation.input_string({:string => "Test 6", :string_key => "test6"})
+    end
+    
+    it "translate" do
+      translation.translate("test1", chinese_locale, "测试一")
+    end
+    
+    it "output" do
+      output = translation.output
+      output.should be_an_instance_of Hash
+      
+      output["Default"].should have_key(english_locale)
+      output["Default"].should have_key(chinese_locale)
+      
+      output["Default"][english_locale].should have_key("test1")
+    end
+    
+    it "output_for_locale" do
+      output = translation.output_for_locale(chinese_locale)
+      output.should be_an_instance_of Hash
+      
+      output["Default"].keys.should == [chinese_locale]
+      output["Default"][chinese_locale].should have_key("test1")
+    end
+    
+    def file(filename)
+      path = File.join(File.dirname(__FILE__), "files", filename)
+      File.open(File.expand_path(path))
+    end
+    
+    it "upload_yaml" do
+      translation.upload_yaml(file("example.yml"))
+    end
+    
+    it "upload_po" do
+      translation.upload_po(file("example.po"))
+    end
+    
+    it "download_yaml" do
+      yaml = translation.download_yaml(chinese_locale)
+      yaml.should be_an_instance_of String
+      
+      hash = YAML.load(yaml)
+      hash.should be_an_instance_of Hash
+      
+      hash[chinese_locale].should have_key("test1")
+    end
+    
+    it "download_po" do
+      po = translation.download_po(chinese_locale)
+      po.should be_an_instance_of String
+      
+      # some way of verifying it looks like a po
+      po.should match(%(msgid "test1"\nmsgstr "))
+    end
+  end
+    
+    
+end