linguist_ruby 0.0.2

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Carl Lerche, Yehuda Katz
+
+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/bin/linguist

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'linguist'
+require 'linguist/command'
+
+args = ARGV.dup
+ARGV.clear
+command = args.shift.strip rescue 'help'
+
+Linguist::Command.run(command, args)
+

data/lib/linguist/client.rb

@@ -0,0 +1,120 @@
+require 'rest_client'
+require 'uri'
+require 'time'
+require 'linguist/version'
+require 'vendor/okjson'
+require 'json'
+require 'linguist/models/projects'
+
+# A Ruby class to call the Linguist REST API.  You might use this if you want to
+# manage your Linguist apps from within a Ruby program, such as Capistrano.
+#
+# Example:
+#
+#   require 'linguist'
+#   linguist = Linguist::Client.new('me@example.com', 'mypass')
+#   linguist.create('myapp')
+#
+class Linguist::Client
+
+  def self.version
+    Linguist::VERSION
+  end
+
+  def self.gem_version_string
+    "linguist-gem/#{version}"
+  end
+
+  attr_accessor :host, :user, :auth_token
+
+  def self.auth(user, password, host='lingui.st')
+    client = new(user, password, host)
+    OkJson.decode client.post('/sessions', { :email => user, :password => password }, :accept => 'json').to_s
+  end
+
+  def initialize(user, auth_token, host='lingui.st')
+    @user       = user
+    @auth_token = auth_token
+    @host       = host
+  end
+
+  def project(title)
+    project = self.projects[title]
+    raise(CommandFailed, "=== You aren't associated for a project named '#{title}'") if project.nil?
+    project
+  end
+
+  def projects
+    return Linguist::Models::Projects.new(self)
+  end
+
+  def get(uri, extra_headers={ }) # :nodoc:
+    process(:get, uri, extra_headers)
+  end
+
+  def post(uri, payload="", extra_headers={ }) # :nodoc:
+    process(:post, uri, extra_headers, payload)
+  end
+
+  def put(uri, payload, extra_headers={ }) # :nodoc:
+    process(:put, uri, extra_headers, payload)
+  end
+
+  def delete(uri, extra_headers={ }) # :nodoc:
+    process(:delete, uri, extra_headers)
+  end
+
+  def process(method, uri, extra_headers={ }, payload=nil)
+    headers = linguist_headers.merge(extra_headers)
+#    payload  = auth_params.merge(payload)
+    args     = [method, payload, headers].compact
+    response = resource(uri).send(*args)
+
+    puts "RESPONSE #{response}"
+
+#    extract_warning(response)
+    response
+  end
+
+  def resource(uri)
+
+    RestClient.proxy = ENV['HTTP_PROXY'] || ENV['http_proxy']
+    if uri =~ /^https?/
+#      RestClient::Resource.new(uri, user, auth_token)
+      RestClient::Resource.new(uri)
+    elsif host =~ /^https?/
+#      RestClient::Resource.new(host, user, auth_token)[uri]
+      RestClient::Resource.new(host)[uri]
+    else
+#      RestClient::Resource.new("https://api.#{host}", user, password)[uri]
+#      RestClient::Resource.new("http://localhost:3000/api/v1", user, auth_token)[uri]
+      RestClient::Resource.new("http://localhost:3000/api/v1")[uri]
+    end
+  end
+
+  def extract_warning(response)
+#    return unless response
+#    if response.headers[:x_heroku_warning] && @warning_callback
+#      warning             = response.headers[:x_heroku_warning]
+#      @displayed_warnings ||= { }
+#      unless @displayed_warnings[warning]
+#        @warning_callback.call(warning)
+#        @displayed_warnings[warning] = true
+#      end
+#    end
+  end
+
+  def linguist_headers # :nodoc:
+    {
+      'X-Linguist-API-Version'     => '1',
+      'X-Linguist-User-Email'      => user,
+      'X-Linguist-User-Auth-Token' => auth_token,
+      'User-Agent'                 => self.class.gem_version_string,
+      'X-Ruby-Version'             => RUBY_VERSION,
+      'X-Ruby-Platform'            => RUBY_PLATFORM,
+      'content_type'               => 'json',
+      'accept'                     => 'json'
+    }
+  end
+
+end

data/lib/linguist/command.rb

@@ -0,0 +1,98 @@
+require 'linguist/helpers'
+require 'linguist/commands/base'
+
+Dir["#{File.dirname(__FILE__)}/commands/*.rb"].each { |c| require c }
+
+module Linguist
+  module Command
+    class InvalidCommand < RuntimeError; end
+    class CommandFailed  < RuntimeError; end
+
+    extend Linguist::Helpers
+
+    class << self
+
+      def run(command, args, retries=0)
+        begin
+          run_internal 'auth:reauthorize', args.dup if retries > 0
+          run_internal(command, args.dup)
+        rescue InvalidCommand
+          error "Unknown command. Run 'linguist help' for usage information."
+#        rescue RestClient::Unauthorized
+#          if retries < 3
+#            STDERR.puts "Authentication failure"
+#            run(command, args, retries+1)
+#          else
+#            error "Authentication failure"
+#          end
+#        rescue RestClient::ResourceNotFound => e
+#          error extract_not_found(e.http_body)
+#        rescue RestClient::RequestFailed => e
+#          error extract_error(e.http_body) unless e.http_code == 402
+#          retry if run_internal('account:confirm_billing', args.dup)
+#        rescue RestClient::RequestTimeout
+#          error "API request timed out. Please try again, or contact support@lingui.st if this issue persists."
+        rescue CommandFailed => e
+          error e.message
+        rescue Interrupt => e
+          error "\n[canceled]"
+        end
+      end
+
+      def run_internal(command, args, linguist=nil)
+        klass, method = parse(command)
+        runner = klass.new(args, linguist)
+        raise InvalidCommand unless runner.respond_to?(method)
+        runner.send(method)
+      end
+
+      def parse(command)
+        parts = command.split(':')
+        case parts.size
+          when 1
+            begin
+              return eval("Linguist::Command::#{command.capitalize}"), :index
+            rescue NameError, NoMethodError
+              return Linguist::Command::App, command.to_sym
+            end
+          else
+            begin
+              const = Linguist::Command
+              command = parts.pop
+              parts.each { |part| const = const.const_get(part.capitalize) }
+              return const, command.to_sym
+            rescue NameError
+              raise InvalidCommand
+            end
+        end
+      end
+
+#      def extract_not_found(body)
+#        body =~ /^[\w\s]+ not found$/ ? body : "Resource not found"
+#      end
+#
+#      def extract_error(body)
+#        msg = parse_error_xml(body) || parse_error_json(body) || parse_error_plain(body) || 'Internal server error'
+#        msg.split("\n").map { |line| ' !   ' + line }.join("\n")
+#      end
+#
+#      def parse_error_xml(body)
+#        xml_errors = REXML::Document.new(body).elements.to_a("//errors/error")
+#        msg = xml_errors.map { |a| a.text }.join(" / ")
+#        return msg unless msg.empty?
+#      rescue Exception
+#      end
+#
+#      def parse_error_json(body)
+#        json = OkJson.decode(body.to_s)
+#        json['error']
+#      rescue OkJson::ParserError
+#      end
+#
+#      def parse_error_plain(body)
+#        return unless body.respond_to?(:headers) && body.headers[:content_type].include?("text/plain")
+#        body.to_s
+#      end
+    end
+  end
+end

data/lib/linguist/commands/app.rb

@@ -0,0 +1,72 @@
+require 'readline'
+require 'launchy'
+
+module Linguist::Command
+  class App < Base
+    def login
+      Linguist::Command.run_internal "auth:reauthorize", args.dup
+    end
+
+    def logout
+      Linguist::Command.run_internal "auth:delete_credentials", args.dup
+      display "Local credentials cleared."
+    end
+
+    def list
+      list = linguist.projects.all
+      if list.size > 0
+        display "Projects:\n" + list.keys.map { |name|
+          "- #{name}"
+        }.join("\n")
+      else
+        display "You have no projects."
+      end
+    end
+
+    def create
+      title = args.shift.downcase.strip rescue nil
+      title ||= extract_from_dir_name
+      linguist.projects.create title
+      display("Created #{title}")
+    end
+
+    def rename
+      newtitle = args.shift.downcase.strip rescue ''
+      oldtitle = project.title
+
+      raise(CommandFailed, "Invalid name.") if newtitle == ''
+
+      project.update(:title => newtitle)
+      display("Renaming project from #{oldtitle} to #{newtitle}")
+
+      display app_urls(newtitle)
+    end
+
+    def info
+      display "=== #{project.title}"
+      display "Web URL:        #{project.weburl}"
+      display "Owner:          #{project.owner}"
+      display "Number of translation:      #{project.translations_count}"
+    end
+
+    def open
+      project = linguist.project
+      url     = project.weburl
+      Launchy.open url
+    end
+
+    def destroy
+      display "=== #{project.title}"
+      display "Web URL:        #{project.weburl}"
+      display "Owner:          #{project.owner}"
+
+      if confirm_command(project_title)
+        redisplay "Destroying #{project_title} ... "
+        project.destroy
+        display "done"
+      end
+    end
+
+  end
+
+end

data/lib/linguist/commands/auth.rb

@@ -0,0 +1,146 @@
+require "linguist/client"
+
+module Linguist::Command
+  class Auth < Base
+    attr_accessor :credentials
+
+    def client
+      @client ||= init_linguist
+    end
+
+    def init_linguist
+      client = Linguist::Client.new(user, auth_token, host)
+#      client.on_warning { |msg| self.display("\n#{msg}\n\n") }
+      client
+    end
+
+    def host
+      ENV['LINGUIST_HOST'] || 'lingui.st'
+    end
+
+    # just a stub; will raise if not authenticated
+    def check
+      client.list
+    end
+
+    def reauthorize
+      @credentials = ask_for_and_save_credentials
+    end
+
+    def user # :nodoc:
+      get_credentials
+      @credentials[0]
+    end
+
+    def auth_token # :nodoc:
+      get_credentials
+      @credentials[1]
+    end
+
+    def credentials_file
+      "#{home_directory}/.linguist/credentials"
+    end
+
+    def get_credentials # :nodoc:
+      return if @credentials
+      unless @credentials = read_credentials
+        ask_for_and_save_credentials
+      end
+      @credentials
+    end
+
+    def read_credentials
+      File.exists?(credentials_file) and File.read(credentials_file).split("\n")
+    end
+
+    def echo_off
+      system "stty -echo"
+    end
+
+    def echo_on
+      system "stty echo"
+    end
+
+    def ask_for_credentials
+#      puts "Enter your Linguist credentials."
+
+      print "Email: "
+      user = "hjuskewycz@hemju.com"#ask
+
+      print "Password: "
+      password = "testtest"#running_on_windows? ? ask_for_password_on_windows : ask_for_password
+      api_key  = Linguist::Client.auth(user, password, host)['api_key']
+
+      [user, api_key]
+    end
+
+    def ask_for_password_on_windows
+      require "Win32API"
+      char     = nil
+      password = ''
+
+      while char = Win32API.new("crtdll", "_getch", [], "L").Call do
+        break if char == 10 || char == 13 # received carriage return or newline
+        if char == 127 || char == 8 # backspace and delete
+          password.slice!(-1, 1)
+        else
+          # windows might throw a -1 at us so make sure to handle RangeError
+          (password << char.chr) rescue RangeError
+        end
+      end
+      puts
+      return password
+    end
+
+    def ask_for_password
+      echo_off
+      password = ask
+      puts
+      echo_on
+      return password
+    end
+
+    def ask_for_and_save_credentials
+      begin
+        @credentials = ask_for_credentials
+        write_credentials
+        check
+      rescue ::RestClient::Unauthorized, ::RestClient::ResourceNotFound => e
+        puts "EXCEPTION #{e}"
+        delete_credentials
+        @client      = nil
+        @credentials = nil
+        display "Authentication failed."
+        retry if retry_login?
+        exit 1
+      rescue Exception => e
+        delete_credentials
+        raise e
+      end
+    end
+
+    def retry_login?
+      @login_attempts ||= 0
+      @login_attempts += 1
+      @login_attempts < 3
+    end
+
+    def write_credentials
+      FileUtils.mkdir_p(File.dirname(credentials_file))
+      f = File.open(credentials_file, 'w')
+      f.chmod(0600)
+      f.puts self.credentials
+      f.close
+      set_credentials_permissions
+    end
+
+    def set_credentials_permissions
+      FileUtils.chmod 0700, File.dirname(credentials_file)
+      FileUtils.chmod 0600, credentials_file
+    end
+
+    def delete_credentials
+#      FileUtils.rm_f(credentials_file)
+    end
+  end
+end

data/lib/linguist/commands/base.rb

@@ -0,0 +1,118 @@
+require 'fileutils'
+
+module Linguist::Command
+  class Base
+    include Linguist::Helpers
+
+    attr_accessor :args
+    attr_reader :autodetected_app
+
+    def initialize(args, linguist=nil)
+      @args             = args
+      @linguist         = linguist
+      @autodetected_app = false
+    end
+
+    def linguist
+      @linguist ||= Linguist::Command.run_internal('auth:client', args)
+    end
+
+    def extract_app(force=true)
+      app = extract_option('--app', false)
+      raise(CommandFailed, "You must specify an app name after --app") if app == false
+      unless app
+        app = extract_app_from_git || extract_from_dir_name ||
+          raise(CommandFailed, "No app specified.\nRun this command from app folder or set it adding --app <app name>") if force
+        @autodetected_app = true
+      end
+      app
+    end
+
+    def extract_from_dir_name
+      dir = Dir.pwd
+      File.basename(dir)
+    end
+
+    def extract_app_from_git
+      dir = Dir.pwd
+      return unless remotes = git_remotes(dir)
+
+      if remote = extract_option('--remote')
+        remotes[remote]
+      elsif remote = extract_app_from_git_config
+        remotes[remote]
+      else
+        apps = remotes.values.uniq
+        return apps.first if apps.size == 1
+      end
+    end
+
+    def extract_app_from_git_config
+      remote = git("config heroku.remote")
+      remote == "" ? nil : remote
+    end
+
+    def git_remotes(base_dir=Dir.pwd)
+      remotes      = { }
+      original_dir = Dir.pwd
+      Dir.chdir(base_dir)
+
+      # TODO
+#      git("remote -v").split("\n").each do |remote|
+#        name, url, method = remote.split(/\s/)
+#        if url =~ /^git@#{heroku.host}:([\w\d-]+)\.git$/
+#          remotes[name] = $1
+#        end
+#      end
+
+      Dir.chdir(original_dir)
+      remotes
+    end
+
+    def extract_option(options, default=true)
+      values = options.is_a?(Array) ? options : [options]
+      return unless opt_index = args.select { |a| values.include? a }.first
+      opt_position = args.index(opt_index) + 1
+      if args.size > opt_position && opt_value = args[opt_position]
+        if opt_value.include?('--')
+          opt_value = nil
+        else
+          args.delete_at(opt_position)
+        end
+      end
+      opt_value ||= default
+      args.delete(opt_index)
+      block_given? ? yield(opt_value) : opt_value
+    end
+
+    def git_url(name)
+      "git@#{heroku.host}:#{name}.git"
+    end
+
+    def app_urls(name)
+#      "#{web_url(name)} | #{git_url(name)}"
+    end
+
+    def escape(value)
+      linguist.escape(value)
+    end
+
+    def project(title=nil)
+      title ||= project_title
+      @project ||= linguist.project(title) 
+    end
+
+    def project_title
+      (args.first && !args.first =~ /^\-\-/) ? args.first : extract_app
+    end
+  end
+
+  class BaseWithApp < Base
+    attr_accessor :app
+
+    def initialize(args, linguist=nil)
+      super(args, linguist)
+      @app ||= extract_app
+    end
+  end
+end

data/lib/linguist/commands/help.rb

@@ -0,0 +1,90 @@
+module Linguist::Command
+  class Help < Base
+    class HelpGroup < Array
+
+      attr_reader :title
+
+      def initialize(title)
+        @title = title
+      end
+
+      def command(name, description)
+        self << [name, description]
+      end
+
+      def space
+        self << ['', '']
+      end
+    end
+
+    def self.groups
+      @groups ||= []
+    end
+
+    def self.group(title, &block)
+      groups << begin
+        group = HelpGroup.new(title)
+        yield group
+        group
+      end
+    end
+
+    def self.create_default_groups!
+      return if @defaults_created
+      @defaults_created = true
+      group 'General Commands' do |group|
+        group.command 'help',                         'show this usage'
+        group.command 'version',                      'show the gem version'
+        group.space
+#        group.command 'login',                        'log in with your linguist credentials'
+#        group.command 'logout',                       'clear local authentication credentials'
+#        group.space
+        group.command 'list',                         'list your projects'
+#        group.command 'create [<name>]',              'create a new app'
+        group.command 'info',                         'show app info, like web url and number of translations'
+        group.command 'open',                         'open the app in a web browser'
+        group.command 'rename <newname>',             'rename the app'
+        group.command 'destroy',                      'destroy the app permanently'
+        group.space
+      end
+
+#      group 'Plugins' do |group|
+#        group.command 'plugins',                      'list installed plugins'
+#        group.command 'plugins:install <url>',        'install the plugin from the specified git url'
+#        group.command 'plugins:uninstall <url/name>', 'remove the specified plugin'
+#      end
+    end
+
+    def index
+      display usage
+    end
+
+    def version
+      display Linguist::Client.version
+    end
+
+    def usage
+      longest_command_length = self.class.groups.map do |group|
+        group.map { |g| g.first.length }
+      end.flatten.max
+
+      self.class.groups.inject(StringIO.new) do |output, group|
+        output.puts "=== %s" % group.title
+        output.puts
+
+        group.each do |command, description|
+          if command.empty?
+            output.puts
+          else
+            output.puts "%-*s # %s" % [longest_command_length, command, description]
+          end
+        end
+
+        output.puts
+        output
+      end.string
+    end
+  end
+end
+
+Linguist::Command::Help.create_default_groups!