rosette-client 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ca6f02478fbb347742958dd575df86db72b742c6
+  data.tar.gz: c43753c2cedbfa451b2c69215df10c82a49d8979
+SHA512:
+  metadata.gz: 28b9c44f0d32376b59a3f98e653e59050be2339293de23c8bb6315f4f90b5dac263a3e6e32aedc915a1c916446dc49bd64fc7ac7f5c21560cb052c4e19bf5012
+  data.tar.gz: 5a85c962749d9ff7ba04082641ecac2d055822357491b0fab6e904dac377ee0eaee840d13fb09ecbea8b610e212ec3afd4c824f6ce1d3e64c24b6750f2a99829

data/Gemfile

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :development, :test do
+  gem 'pry-nav'
+  gem 'rake'
+  gem 'threaded'
+end
+
+group :test do
+  gem 'rspec'
+  gem 'tmp-repo'
+end

data/History.txt

@@ -0,0 +1,3 @@
+== 1.0.0
+
+* Birthday!

data/README.md

@@ -0,0 +1,4 @@
+rosette-core
+========
+
+[![Build Status](https://travis-ci.org/rosette-proj/rosette-client.svg?branch=master)](https://travis-ci.org/rosette-proj/rosette-client.svg?branch=master)

data/Rakefile

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+require 'rubygems' unless ENV['NO_RUBYGEMS']
+
+require 'bundler'
+require 'rspec/core/rake_task'
+require 'rubygems/package_task'
+
+require './lib/rosette/client'
+
+Bundler::GemHelper.install_tasks
+
+task :default => :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = './spec/**/*_spec.rb'
+end

data/bin/git-rosette

@@ -0,0 +1,17 @@
+#! /usr/bin/env ruby
+
+require 'rosette/client'
+
+config_file = File.join(Dir.home, '.rosette/config.yml')
+
+api = Rosette::Client::Api.new(
+  if File.exist?(config_file)
+    YAML.load_file(config_file)
+  else
+    {}
+  end
+)
+
+terminal = Rosette::Client::Terminal.new
+repo = Rosette::Client::Repo.new(Dir.getwd)
+Rosette::Client::Cli.new(terminal, api, repo).start(ARGV)

data/lib/rosette/client/api.rb

@@ -0,0 +1,128 @@
+# encoding: UTF-8
+
+require 'cgi'
+require 'net/http'
+require 'json'
+
+module Rosette
+  module Client
+
+    class ApiError < StandardError; end
+
+    class Api
+      DEFAULT_HOST = 'localhost'
+      DEFAULT_PORT = 8080
+      DEFAULT_VERSION = 'v1'
+
+      attr_reader :host, :port, :version
+
+      def initialize(options = {})
+        @host = options.fetch(:host, DEFAULT_HOST)
+        @port = options.fetch(:port, DEFAULT_PORT)
+        @version = options.fetch(:version, DEFAULT_VERSION)
+      end
+
+      def diff(params)
+        wrap(make_request(:get, 'git/diff.json', params))
+      end
+
+      def show(params)
+        wrap(make_request(:get, 'git/show.json', params))
+      end
+
+      def status(params)
+        wrap(make_request(:get, 'git/status.json', params))
+      end
+
+      def commit(params)
+        wrap(make_request(:get, 'git/commit.json', params))
+      end
+
+      def snapshot(params)
+        wrap(make_request(:get, 'git/snapshot.json', params))
+      end
+
+      def repo_snapshot(params)
+        wrap(make_request(:get, 'git/repo_snapshot.json', params))
+      end
+
+      def add_or_update_translation(params)
+        wrap(make_request(:post, 'translations/add_or_update.json', params))
+      end
+
+      def export(params)
+        wrap(make_request(:get, 'translations/export.json', params))
+      end
+
+      private
+
+      def wrap(api_response)
+        Response.from_api_response(api_response)
+      end
+
+      def base_url
+        "http://#{host}:#{port}/#{version}"
+      end
+
+      def make_request(verb, path, params)
+        parse_response(
+          case verb
+            when :post
+              url = make_post_url(path, params)
+              post(url, params)
+            when :get
+              url = make_get_url(path, params)
+              get(url)
+            else
+              raise ArgumentError, "unsupported HTTP verb #{verb}."
+          end
+        )
+      rescue => e
+        raise ApiError, e.message
+      end
+
+      def parse_response(response)
+        JSON.parse(response)
+      end
+
+      def make_param_string(params)
+        (params.map do |key, val|
+          "#{CGI.escape(key.to_s)}=#{CGI.escape(val.to_s)}"
+        end).join("&")
+      end
+
+      def make_get_url(path, params)
+        File.join(base_url, path, "?#{make_param_string(params)}")
+      end
+
+      def make_post_url(path, params)
+        File.join(base_url, path)
+      end
+
+      def post(url, params)
+        uri = parse_uri(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        request = Net::HTTP::Post.new(uri.path)
+        request.body = make_param_string(params)
+        resp = http.request(request)
+        resp.body
+      end
+
+      def get(url)
+        resp = Net::HTTP.get_response(parse_uri(url))
+        resp.body
+      end
+
+      # hack to handle bug in URI.parse, which doesn't allow subdomains to contain underscores
+      def parse_uri(url = nil)
+        URI.parse(url)
+      rescue URI::InvalidURIError
+        host = url.match(".+\:\/\/([^\/]+)")[1]
+        uri = URI.parse(url.sub(host, 'dummy-host'))
+        uri.instance_variable_set('@host', host)
+        uri
+      end
+    end
+
+  end
+end

data/lib/rosette/client/cli.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+require 'yaml'
+
+module Rosette
+  module Client
+
+    class Cli
+      attr_reader :api, :terminal, :repo
+
+      def initialize(terminal, api, repo)
+        @api = api
+        @terminal = terminal
+        @repo = repo
+      end
+
+      def start(argv)
+        if command_const = find_command_const(argv.first)
+          command_const.new(api, terminal, repo, argv[1..-1]).execute
+        else
+          terminal.say("Command '#{argv.first}' not recognized.")
+        end
+      rescue Rosette::Client::ApiError => e
+        terminal.say("An api error occurred: #{e.message}")
+      end
+
+      private
+
+      def find_command_const(name)
+        const = const_name(name)
+        if Rosette::Client::Commands.const_defined?(const)
+          Rosette::Client::Commands.const_get(const)
+        end
+      end
+
+      def const_name(name)
+        name.downcase.gsub(/(\A\w|_\w)/) { $1.sub('_', '').upcase } + 'Command'
+      end
+    end
+
+  end
+end

data/lib/rosette/client/commands/commit_command.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+# git rs commit <ref>
+
+module Rosette
+  module Client
+    module Commands
+
+      CommitCommandArgs = Struct.new(:ref) do
+        def self.from_argv(argv, repo)
+          new(repo.rev_parse(argv[0] || repo.get_head))
+        end
+      end
+
+      class CommitCommand < Command
+        attr_reader :args
+
+        def initialize(api, terminal, repo, argv)
+          super(api, terminal, repo)
+          @args = CommitCommandArgs.from_argv(argv, repo)
+        end
+
+        def execute
+          terminal.say("Committing phrases for '#{args.ref}'...")
+
+          response = api.commit(
+            repo_name: derive_repo_name,
+            ref: args.ref
+          )
+
+          handle_error(response) do
+            terminal.say("Added: #{response.added || 0}")
+            terminal.say("Removed: #{response.removed || 0}")
+            terminal.say("Modified: #{response.modified || 0}")
+            terminal.say('done.')
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/client/commands/diff_command.rb

@@ -0,0 +1,110 @@
+# encoding: UTF-8
+
+# git rs diff <ref1> [<ref2> | <path>] [-- <path1> <path2> ...]
+
+# git rs diff
+# git rs diff master .
+# git rs diff master branch
+# git rs diff master branch .
+# git rs diff master branch -- path/to/files
+
+module Rosette
+  module Client
+    module Commands
+
+      DiffCommandArgs = Struct.new(:diff_point_ref, :head_ref, :paths) do
+        # should probably use a parser for these args, since they're pretty complicated
+        # currently no support for options like --name-only, etc
+        def self.from_argv(argv, repo)
+          diff_point_ref = repo.rev_parse(argv[0] || 'refs/heads/master')
+          paths = []
+
+          if argv[1]
+            if File.exist?(argv[1])
+              paths << argv[1]
+            else
+              head_ref = argv[1] unless argv[1] == '--'
+            end
+          end
+
+          head_ref ||= repo.rev_parse(repo.get_head)
+
+          (2..argv.size).each do |i|
+            next if argv[i] == '--'
+            if argv[i] && File.exist?(argv[i])
+              paths << argv[i]
+            end
+          end
+
+          new(diff_point_ref, head_ref, paths)
+        end
+      end
+
+      class DiffCommand < Command
+        attr_reader :args
+
+        def initialize(api, terminal, repo, argv)
+          super(api, terminal, repo)
+          @args = DiffCommandArgs.from_argv(argv, repo)
+        end
+
+        def execute
+          response = api.diff(
+            repo_name: derive_repo_name,
+            head_ref: args.head_ref,
+            diff_point_ref: args.diff_point_ref,
+            paths: args.paths.join(' ')
+          )
+
+          handle_error(response) do |response|
+            print_diff(response.attributes)
+          end
+        end
+
+        private
+
+        def add_str_for(change)
+          str = "#{change['key']}"
+          meta_key = change['meta_key']
+
+          unless meta_key.empty?
+            str += " (#{meta_key})"
+          end
+        end
+
+        def remove_str_for(change)
+          str = "#{change.fetch('old_key', change['key'])}"
+          meta_key = change['meta_key']
+
+          unless meta_key.empty?
+            str += " (#{meta_key})"
+          end
+        end
+
+        def print_diff(diff)
+          group_diff_by_file(diff).each_pair do |path, states|
+            terminal.say("diff --rosette a/#{path} b/#{path}", :white)
+
+            states.each do |state, changes|
+              changes.each do |change|
+                add_str = add_str_for(change)
+                remove_str = remove_str_for(change)
+
+                case state
+                  when 'modified'
+                    terminal.say("- #{remove_str}", :red)
+                    terminal.say("+ #{add_str}", :green)
+                  when 'removed'
+                    terminal.say("- #{remove_str}", :red)
+                  when 'added'
+                    terminal.say("+ #{add_str}", :green)
+                end
+              end
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/client/commands/repo_snapshot_command.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+
+# git rs snapshot <ref>
+
+module Rosette
+  module Client
+    module Commands
+
+      RepoSnapshotCommandArgs = Struct.new(:ref) do
+        def self.from_argv(argv, repo)
+          new(repo.rev_parse(argv[0] || repo.get_head))
+        end
+      end
+
+      # a show is really just a diff against your parent (so the inheritance makes sense)
+      class RepoSnapshotCommand < Command
+        attr_reader :args
+
+        def initialize(api, terminal, repo, argv)
+          super(api, terminal, repo)
+          @args = RepoSnapshotCommandArgs.from_argv(argv, repo)
+        end
+
+        def execute
+          response = api.repo_snapshot(
+            repo_name: derive_repo_name,
+            ref: args.ref
+          )
+
+          handle_error(response) do |response|
+            print_hash(response.attributes)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/client/commands/show_command.rb

@@ -0,0 +1,40 @@
+# encoding: UTF-8
+
+# git rs show <ref>
+
+module Rosette
+  module Client
+    module Commands
+
+      ShowCommandArgs = Struct.new(:ref) do
+        def self.from_argv(argv, repo)
+          new(repo.rev_parse(argv[0] || repo.get_head))
+        end
+      end
+
+      # a show is really just a diff against your parent (so the inheritance makes sense)
+      class ShowCommand < DiffCommand
+        attr_reader :args
+
+        def initialize(api, terminal, repo, argv)
+          @api = api
+          @terminal = terminal
+          @repo = repo
+          @args = ShowCommandArgs.from_argv(argv, repo)
+        end
+
+        def execute
+          response = api.show(
+            repo_name: derive_repo_name,
+            ref: args.ref
+          )
+
+          handle_error(response) do |response|
+            print_diff(response.attributes)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/client/commands/snapshot_command.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+
+# git rs snapshot <ref>
+
+module Rosette
+  module Client
+    module Commands
+
+      SnapshotCommandArgs = Struct.new(:ref) do
+        def self.from_argv(argv, repo)
+          new(repo.rev_parse(argv[0] || repo.get_head))
+        end
+      end
+
+      # a show is really just a diff against your parent (so the inheritance makes sense)
+      class SnapshotCommand < Command
+        attr_reader :args
+
+        def initialize(api, terminal, repo, argv)
+          super(api, terminal, repo)
+          @args = SnapshotCommandArgs.from_argv(argv, repo)
+        end
+
+        def execute
+          response = api.snapshot(
+            repo_name: derive_repo_name,
+            ref: args.ref
+          )
+
+          handle_error(response) do |response|
+            response.attributes.each do |item|
+              print_hash(item)
+              terminal.say('')
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/client/commands/status_command.rb

@@ -0,0 +1,96 @@
+# encoding: UTF-8
+
+# git rs status [ref]
+
+module Rosette
+  module Client
+    module Commands
+
+      StatusCommandArgs = Struct.new(:ref) do
+        def self.from_argv(argv, repo)
+          new(repo.rev_parse(argv[0] || repo.get_head))
+        end
+      end
+
+      # a show is really just a diff against your parent (so the inheritance makes sense)
+      class StatusCommand < Command
+        attr_reader :args
+
+        def initialize(api, terminal, repo, argv)
+          @api = api
+          @terminal = terminal
+          @repo = repo
+          @args = StatusCommandArgs.from_argv(argv, repo)
+        end
+
+        def execute
+          response = api.status(
+            repo_name: derive_repo_name,
+            ref: args.ref
+          )
+
+          handle_error(response) do |response|
+            if response.locales && response.phrase_count
+              terminal.say(
+                build_locale_table(response.locales, response.phrase_count)
+              )
+            end
+          end
+        end
+
+        private
+
+        HEADER = ['Locale', 'Phrases', 'Translations', 'Percent']
+
+        def build_locale_table(locales, phrase_count)
+          rows = build_locale_rows(locales, phrase_count)
+          column_widths = find_column_widths(rows)
+          rows = pad_rows(rows, column_widths)
+          add_markup(rows)
+        end
+
+        def add_markup(rows)
+          rows = rows.map do |row|
+            "| #{row.join(' | ')} |"
+          end
+
+          separator = '-' * rows.first.length
+          result = rows.join("\n#{separator}\n")
+          "#{separator}\n#{result}\n#{separator}"
+        end
+
+        def pad_rows(rows, column_widths)
+          rows.map do |row|
+            row.map.with_index do |col, index|
+              col.ljust(column_widths[index], ' ')
+            end
+          end
+        end
+
+        def find_column_widths(rows)
+          rows.each_with_object([]) do |row, ret|
+            row.each_with_index do |col, index|
+              ret[index] ||= []
+              ret[index] << col.length
+            end
+          end.map(&:max)
+        end
+
+        def build_locale_rows(locales, phrase_count)
+          [HEADER] + locales.map do |locale|
+            build_locale_table_row(locale, phrase_count)
+          end
+        end
+
+        def build_locale_table_row(locale, phrase_count)
+          [
+            locale['locale'], phrase_count.to_i.to_s,
+            locale['translated_count'].to_i.to_s,
+            locale['percent_translated'].to_f.to_s
+          ]
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/client/commands.rb

@@ -0,0 +1,68 @@
+# encoding: UTF-8
+
+module Rosette
+  module Client
+    module Commands
+
+      autoload :DiffCommand,             'rosette/client/commands/diff_command'
+      autoload :DiffCommandArgs,         'rosette/client/commands/diff_command'
+      autoload :ShowCommand,             'rosette/client/commands/show_command'
+      autoload :ShowCommandArgs,         'rosette/client/commands/show_command'
+      autoload :StatusCommand,           'rosette/client/commands/status_command'
+      autoload :StatusCommandArgs,       'rosette/client/commands/status_command'
+      autoload :CommitCommand,           'rosette/client/commands/commit_command'
+      autoload :CommitCommandArgs,       'rosette/client/commands/commit_command'
+      autoload :SnapshotCommand,         'rosette/client/commands/snapshot_command'
+      autoload :SnapshotCommandArgs,     'rosette/client/commands/snapshot_command'
+      autoload :RepoSnapshotCommand,     'rosette/client/commands/repo_snapshot_command'
+      autoload :RepoSnapshotCommandArgs, 'rosette/client/commands/repo_snapshot_command'
+
+      class Command
+        attr_reader :api, :terminal, :repo
+
+        def initialize(api, terminal, repo)
+          @api = api
+          @terminal = terminal
+          @repo = repo
+        end
+
+        protected
+
+        def print_hash(hash)
+          hash.each_pair do |key, value|
+            terminal.say("#{key}: #{value}")
+          end
+        end
+
+        def handle_error(response)
+          if response.error?
+            terminal.say(
+              [response.error, response.detail].compact.join(': ')
+            )
+          else
+            yield response if block_given?
+          end
+        end
+
+        def group_diff_by_file(diff)
+          result = Hash.new do |h, i|
+            h[i] = Hash.new do |h2, i2|
+              h2[i2] = []
+            end
+          end
+
+          diff.each_with_object(result) do |(state, items), by_path|
+            items.each do |item|
+              by_path[item['file']][state] << item
+            end
+          end
+        end
+
+        def derive_repo_name
+          File.basename(`git config --get remote.origin.url`.strip).gsub(/\.git\z/, '')
+        end
+      end
+
+    end
+  end
+end