lingohub 0.0.4

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+## 0.0.4
+
+* added command line help for: login, logout
+* connects to 'lingohub.com' by default

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011-2012 lingohub GmbH
+
+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,10 @@
+## lingohub ruby
+
+### Maintainers
+
+* Markus Merzinger (https://github.com/maerzbow)
+* Helmut Juskewycz (https://github.com/hjuskewycz)
+
+## License
+
+MIT License. Copyright 2012 lingohub GmbH. http://lingohub.com

data/bin/lingohub

@@ -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 'lingohub'
+require 'lingohub/command'
+
+args = ARGV.dup
+ARGV.clear
+command = args.shift.strip rescue 'help'
+
+Lingohub::Command.run(command, args)
+

data/lib/lingohub.rb

@@ -0,0 +1,16 @@
+require "lingohub/client"
+require "lingohub/rails3/railtie" if defined?(Rails)
+
+module Lingohub
+  class << self
+    attr_accessor :environments, :protocol, :host, :username, :project
+
+    def configure
+      yield self
+    end
+
+    def default_value?(value)
+      value.start_with?(":")
+    end
+  end
+end

data/lib/lingohub/client.rb

@@ -0,0 +1,106 @@
+require 'rest_client'
+require 'uri'
+require 'time'
+require 'lingohub/version'
+require 'vendor/okjson'
+require 'json'
+require 'lingohub/models/projects'
+
+# A Ruby class to call the lingohub REST API.  You might use this if you want to
+# manage your lingohub apps from within a Ruby program, such as Capistrano.
+#
+# Example:
+#
+#   require 'lingohub'
+#   lingohub = Lingohub::Client.new('me@example.com', 'mypass')
+#   lingohub.create('myapp')
+#
+class Lingohub::Client
+
+  def self.version
+    Lingohub::VERSION
+  end
+
+  def self.gem_version_string
+    "lingohub-gem/#{version}"
+  end
+
+  attr_accessor :host, :user, :password
+
+  def self.auth(options)
+    client = new(options)
+    OkJson.decode client.post('/sessions', {}, :accept => 'json').to_s
+  end
+
+  def initialize(options)
+    @user       = options[:username]
+    @password   = options[:password]
+    @auth_token = options[:auth_token]
+    @host       = options[:host] || 'lingohub.com'
+  end
+
+  def credentials
+    @auth_token.nil? ? {:username => @user, :password => @password} : {:username => @auth_token, :password => ""}
+  end
+
+  def project(title)
+    project = self.projects[title]
+    raise(Lingohub::Command::CommandFailed, "=== You aren't associated for a project named '#{title}'") if project.nil?
+    project
+  end
+
+  def projects
+    return Lingohub::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 = lingohub_headers.merge(extra_headers)
+#    payload  = auth_params.merge(payload)
+    args     = [method, payload, headers].compact
+    response = resource(uri, credentials).send(*args)
+
+    response
+  end
+
+  def resource(uri, credentials)
+    RestClient.proxy = ENV['HTTP_PROXY'] || ENV['http_proxy']
+    if uri =~ /^https?/
+      RestClient::Resource.new(uri, :user => credentials[:username], :password => credentials[:password])
+    else
+      host_uri = host =~ /^https?/ ? "#{host}/#{api_uri_part}" : "https://#{host}/#{api_uri_part}"
+      RestClient::Resource.new(host_uri, :user => credentials[:username], :password => credentials[:password])[uri]
+    end
+  end
+
+  def api_uri_part
+    "api/#{Lingohub::API_VERSION}"
+  end
+
+  def lingohub_headers # :nodoc:
+    {
+      'X-lingohub-API-Version'     => '1',
+      '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/lingohub/command.rb

@@ -0,0 +1,98 @@
+require 'lingohub/helpers'
+require 'lingohub/commands/base'
+
+Dir["#{File.dirname(__FILE__)}/commands/*.rb"].each { |c| require c }
+
+module Lingohub
+  module Command
+    class InvalidCommand < RuntimeError; end
+    class CommandFailed  < RuntimeError; end
+
+    extend Lingohub::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 'lingohub 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 team@lingohub.com if this issue persists."
+        rescue CommandFailed => e
+          error e.message
+        rescue Interrupt => e
+          error "\n[canceled]"
+        end
+      end
+
+      def run_internal(command, args, lingohub=nil)
+        klass, method = parse(command)
+        runner = klass.new(args, lingohub)
+        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("Lingohub::Command::#{command.capitalize}"), :index
+            rescue NameError, NoMethodError
+              return Lingohub::Command::Project, command.to_sym
+            end
+          else
+            begin
+              const = Lingohub::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/lingohub/commands/auth.rb

@@ -0,0 +1,146 @@
+require "lingohub/client"
+
+module Lingohub::Command
+  class Auth < Base
+    attr_accessor :credentials
+
+    def client
+      @client ||= init_lingohub
+    end
+
+    def init_lingohub
+      client = Lingohub::Client.new(:username => user, :auth_token => auth_token, :host => host)
+#      client.on_warning { |msg| self.display("\n#{msg}\n\n") }
+      client
+    end
+
+    def host
+      ENV['lingohub_HOST'] || 'lingohub.com'
+    end
+
+    # just a stub; will raise if not authenticated
+    def check
+      client.projects.all
+    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}/.lingohub/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 Lingohub credentials."
+
+      print "Email: "
+      user = ask
+
+      print "Password: "
+      password = running_on_windows? ? ask_for_password_on_windows : ask_for_password
+      api_key = Lingohub::Client.auth(:username => user, :password => password, :host => 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/lingohub/commands/base.rb

@@ -0,0 +1,119 @@
+require 'fileutils'
+
+module Lingohub::Command
+  class Base
+    include Lingohub::Helpers
+
+    attr_accessor :args
+    attr_reader :autodetected_app
+
+    def initialize(args, lingohub=nil)
+      @args             = args
+      @lingohub         = lingohub
+      @autodetected_project_name = false
+    end
+
+    def lingohub
+      @lingohub ||= Lingohub::Command.run_internal('auth:client', args)
+    end
+
+    def project_title(force=true)
+      project_title = extract_project_title_from_args
+      unless project_title
+        project_title = extract_project_title_from_git || extract_project_title_from_dir_name ||
+          raise(CommandFailed, "No project specified.\nRun this command from project folder or set it adding --project <title>") if force
+        @autodetected_project_name = true
+      end
+      project_title
+    end
+
+    def extract_project_title_from_args
+      project_title = extract_option('--project', false)
+      raise(CommandFailed, "You must specify a project title after --project") if project_title == false
+      project_title
+    end
+
+    def extract_project_title_from_dir_name
+      dir = Dir.pwd
+      File.basename(dir)
+    end
+
+    def extract_project_title_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)
+      lingohub.escape(value)
+    end
+
+    def project(title=nil)
+      title ||= project_title
+      @project ||= lingohub.project(title)
+    end
+  end
+
+  class BaseWithApp < Base
+    attr_accessor :app
+
+    def initialize(args, lingohub=nil)
+      super(args, lingohub)
+      @app ||= extract_app
+    end
+  end
+end