duse 0.0.2

data/lib/duse/cli/account_password_change.rb

@@ -0,0 +1,30 @@
+require 'duse/cli'
+require 'duse/cli/password_helper'
+
+module Duse
+  module CLI
+    class AccountPasswordChange < ApiCommand
+      include PasswordHelper
+
+      description 'change your password'
+
+      on('-t', '--token [TOKEN]', 'The token to use for password reset')
+
+      def run
+        if self.token
+          Duse.session.patch('/users/password', {
+            token: self.token,
+            password: ask_for_password
+          })
+        else
+          user = Duse::User.current
+          Duse::User.update(user.id, {
+            password: ask_for_password,
+            current_password: ask_for_current_password
+          })
+        end
+        success 'Successfully updated your password!'
+      end
+    end
+  end
+end

data/lib/duse/cli/account_password_reset.rb

@@ -0,0 +1,20 @@
+require 'duse/cli'
+
+module Duse
+  module CLI
+    class AccountPasswordReset < ApiCommand
+      description 'request a reset of your password'
+
+      skip :authenticate
+
+      on('-e', '--email [EMAIL]', 'Your email')
+
+      def run
+        self.email ||= terminal.ask('Your email: ')
+        Duse::User.forgot_password(self.email)
+        success 'An email with instructions on how to reset your password has been sent.'
+      end
+    end
+  end
+end
+

data/lib/duse/cli/account_resend_confirmation.rb

@@ -0,0 +1,20 @@
+require 'duse/cli'
+
+module Duse
+  module CLI
+    class AccountResendConfirmation < ApiCommand
+      description 'resend the confirmation email for your account'
+
+      skip :authenticate
+
+      on('-e', '--email [EMAIL]', 'Your email')
+
+      def run
+        self.email ||= terminal.ask('Your email: ')
+        Duse::User.resend_confirmation(self.email)
+        success 'New confirmation process started.'
+      end
+    end
+  end
+end
+

data/lib/duse/cli/account_update.rb

@@ -0,0 +1,25 @@
+require 'duse/cli'
+require 'duse/cli/key_helper'
+require 'duse/cli/password_helper'
+
+module Duse
+  module CLI
+    class AccountUpdate < ApiCommand
+      include KeyHelper
+      include PasswordHelper
+
+      description 'update account'
+
+      def run
+        user = Duse::User.current
+        terminal.say 'Leave blank if you do not wish to change'
+        Duse::User.update(user.id, {
+          username: terminal.ask('Username: ') { |q| q.default = user.username },
+          email: terminal.ask('Email: ') { |q| q.default = user.email },
+          current_password: ask_for_current_password
+        })
+        success 'Successfully updated your account!'
+      end
+    end
+  end
+end

data/lib/duse/cli/api_command.rb

@@ -0,0 +1,33 @@
+require 'json'
+
+module Duse
+  module CLI
+    class ApiCommand < Command
+      abstract
+
+      def execute
+        ensure_uri_is_set
+        authenticate
+        run *arguments
+      rescue Duse::Client::NotLoggedIn
+        error "not logged in, run `#$0 login`"
+      rescue Duse::Client::Error => e
+        error e.message
+      rescue Faraday::ConnectionFailed
+        error 'Cannot connect to specified duse instance'
+      rescue Interrupt
+        say "\naborted!"
+      end
+
+      private
+
+      def ensure_uri_is_set
+        error "client not configured, run `#$0 config`" if config.uri.nil?
+      end
+
+      def authenticate
+        fail Duse::Client::NotLoggedIn if config.token.nil?
+      end
+    end
+  end
+end

data/lib/duse/cli/cli_config.rb

@@ -0,0 +1,54 @@
+require 'yaml'
+require 'duse/client/config'
+
+module Duse
+  class PrivateKeyMissing < StandardError; end
+
+  class CLIConfig < Duse::Client::Config
+    def private_key_for(user)
+      private_key_filename = private_key_file_for user
+      fail PrivateKeyMissing unless File.exists? private_key_filename
+      OpenSSL::PKey::RSA.new File.read private_key_filename
+    end
+
+    def save_private_key_for(user, private_key)
+      File.open(private_key_file_for(user), 'w') do |file|
+        file.write private_key
+      end
+    end
+
+    def self.load
+      config = YAML.load load_config_file
+      return {} unless config.is_a? Hash
+      config
+    end
+
+    def self.save(config)
+      FileUtils.mkdir_p config_dir
+      File.open(config_file, 'w') do |file|
+        file.write config.to_h.to_yaml
+        file.chmod 0600
+      end
+    end
+
+    def self.config_file
+      File.join config_dir, 'config.yml'
+    end
+
+    def self.config_dir
+      File.join Dir.home, '.config', 'duse'
+    end
+
+    def private_key_file_for(user)
+      File.join self.class.config_dir, user.username
+    end
+
+    private
+
+    def self.load_config_file
+      # pretend like it's an empty file if config does not exists
+      return "--- {}\n" unless File.exist? config_file
+      File.read config_file
+    end
+  end
+end

data/lib/duse/cli/command.rb

@@ -0,0 +1,202 @@
+require 'highline'
+require 'duse/cli/cli_config'
+require 'duse/cli/parser'
+
+module Duse
+  module CLI
+    class Command
+      attr_reader :output, :input
+      attr_accessor :arguments, :force_interactive
+
+      extend Parser
+
+      HighLine.color_scheme = HighLine::ColorScheme.new do |cs|
+        cs[:command]   = [ :bold             ]
+        cs[:error]     = [ :red              ]
+        cs[:important] = [ :bold, :underline ]
+        cs[:success]   = [ :green            ]
+        cs[:info]      = [ :yellow           ]
+        cs[:debug]     = [ :magenta          ]
+      end
+
+      on('-h', '--help', 'Display help') do |c, _|
+        c.say c.help
+        exit
+      end
+
+      def initialize(options = {})
+        self.output      = $stdout
+        self.input       = $stdin
+        self.arguments ||= []
+        options.each do |key, value|
+          public_send("#{key}=", value) if respond_to? "#{key}="
+        end
+        @arguments ||= []
+      end
+
+      def parse(args)
+        arguments.concat(parser.parse(args))
+      rescue OptionParser::ParseError => e
+        error e.message
+      end
+
+      def execute
+        run *arguments
+      rescue Interrupt
+        say "\naborted!"
+      end
+
+      def output=(io)
+        @terminal = nil
+        @output = io
+      end
+
+      def input=(io)
+        @terminal = nil
+        @input = io
+      end
+
+      def terminal
+        @terminal ||= HighLine.new(input, output)
+      end
+
+      # ignore Command since its not supposed to be executed
+      @@abstract ||= [Command]
+      def self.abstract?
+        @@abstract.include? self
+      end
+
+      def self.abstract
+        @@abstract << self
+      end
+
+      def self.skip(*names)
+        names.each { |n| define_method(n) {} }
+      end
+
+      def self.super_command=(command_class)
+        @super_command = command_class
+      end
+
+      def self.has_super_command?
+        !@super_command.nil?
+      end
+
+      def self.super_command
+        @super_command
+      end
+
+      def self.subcommand(command)
+        return nil if command.nil?
+        return subcommands.select { |sc| sc.command_name == command }.first if command.is_a? String
+        command.super_command = self
+        subcommands << command
+      end
+
+      def self.subcommands
+        @subcommands ||= []
+      end
+
+      def self.has_subcommands?
+        !@subcommands.empty?
+      end
+
+      def config
+        CLI.config
+      end
+
+      def warn(message)
+        write_to($stderr) do
+          say color(message, :error)
+          yield if block_given?
+        end
+      end
+
+      def error(message, &block)
+        warn(message, &block)
+        exit 1
+      end
+
+      def success(line)
+        say color(line, :success) if interactive?
+      end
+
+      def write_to(io)
+        io_was, self.output = output, io
+        yield
+      ensure
+        self.output = io_was if io_was
+      end
+
+      def color(line, style)
+        return line.to_s unless interactive?
+        terminal.color(line || '???', Array(style).map(&:to_sym))
+      end
+
+      def interactive?(io = output)
+        return io.tty? if force_interactive.nil?
+        force_interactive
+      end
+
+      def say(data, format = nil, style = nil)
+        terminal.say format(data, format, style)
+      end
+
+      def self.full_command
+        name[/[^:]*$/].split(/(?=[A-Z])/).map(&:downcase).join(' ')
+      end
+
+      def full_command
+        self.class.full_command
+      end
+
+      def self.command_name
+        return full_command.sub(super_command.full_command, '').strip.sub(' ', '-') if has_super_command?
+        full_command
+      end
+
+      def command_name
+        self.class.command_name
+      end
+
+      def self.description(description = nil)
+        @description = description if description
+        @description ||= ""
+      end
+
+      def help(info = "")
+        return help_subcommands unless self.class.subcommands.empty?
+        parser.banner = usage
+        self.class.description.sub(/./) { |c| c.upcase } + ".\n\n" + info + parser.to_s
+      end
+
+      def help_subcommands
+        result = "#{self.class.description}\n\n"
+        result << "Usage: duse #{full_command} COMMAND ...\n\nAvailable commands:\n\n"
+        self.class.subcommands.each { |command_class| result << "\t#{color(command_class.command_name, :command).ljust(22)} #{color(command_class.description, :info)}\n" }
+        result << "\nrun `#$0 help #{full_command} COMMAND` for more infos"
+        result
+      end
+
+      def usage
+        "Usage: " << color(usage_for(full_command, :run), :command)
+      end
+
+      def usage_for(prefix, method)
+        usage = "duse #{prefix}"
+        method = method(method)
+        if method.respond_to? :parameters
+          method.parameters.each do |type, name|
+            name = name.upcase
+            name = "[#{name}]"   if type == :opt
+            name = "[#{name}..]" if type == :rest
+            usage << " #{name}"
+          end
+        elsif method.arity != 0
+          usage << " ..."
+        end
+        usage << " [OPTIONS]"
+      end
+    end
+  end
+end

data/lib/duse/cli/config.rb

@@ -0,0 +1,16 @@
+require 'duse/cli'
+
+module Duse
+  module CLI
+    class Config < Command
+      description 'Configure the client'
+
+      def run
+        config.uri = terminal.ask('Uri to the duse instance you want to use: ') { |q| q.default = config.uri }
+        CLIConfig.save(config)
+      rescue ArgumentError
+        error 'Not an uri'
+      end
+    end
+  end
+end

data/lib/duse/cli/help.rb

@@ -0,0 +1,23 @@
+require 'duse/cli'
+
+module Duse
+  module CLI
+    class Help < Command
+      description "Displays help messages, such as this one"
+
+      def run(*args)
+        unless args.empty?
+          say CLI.command(args).new.help
+        else
+          say "Usage: duse COMMAND ...\n\nAvailable commands:\n\n"
+          commands.each { |c| say "\t#{color(c.command_name, :command).ljust(22)} #{color(c.description, :info)}" }
+          say "\nrun `#$0 help COMMAND` for more infos"
+        end
+      end
+
+      def commands
+        CLI.commands.sort_by { |c| c.command_name }
+      end
+    end
+  end
+end

data/lib/duse/cli/key_helper.rb

@@ -0,0 +1,84 @@
+module Duse
+  module KeyHelper
+    def choose_key(options = { allow_generate: true })
+      key = nil
+      generate_option = 'Generate a new one'
+      choose_myself_option = 'Let me choose it myself'
+      choices = possible_ssh_keys
+      choices << generate_option if options[:allow_generate]
+      choices << choose_myself_option
+      terminal.choose do |ssh_keys|
+        ssh_keys.prompt = 'Which private ssh-key do you want to use?'
+        ssh_keys.choices *choices do |choice|
+          key = generate_key if choice == generate_option
+          key = choose_private_key_file if choice == choose_myself_option
+          key ||= OpenSSL::PKey::RSA.new File.read choice
+        end
+      end
+      key
+    end
+
+    def ensure_matching_keys_for(user)
+      key_pair = {
+        public: user.public_key,
+        private: private_key_for(user)
+      }
+      loop do
+        break if matching_keys? key_pair
+        warn 'Your private key does not match the public key, please select a new one.'
+        key_pair[:private] = choose_key(allow_generate: false)
+      end
+      Duse::CLIConfig.new.save_private_key_for user, key_pair[:private].to_pem
+    end
+
+    def private_key_for(user)
+      Duse::CLIConfig.new.private_key_for(user)
+    rescue PrivateKeyMissing
+      warn 'No private key found, please select one.'
+      choose_key(allow_generate: false)
+    rescue OpenSSL::PKey::RSAError
+      warn 'The private key file does not contain a valid private key, please select a new one.'
+      choose_key(allow_generate: false)
+    end
+
+    def matching_keys?(key_pair)
+      public_key = key_pair[:public]
+      private_key = key_pair[:private]
+      public_key.params['n'] == private_key.params['n']
+    end
+
+    def possible_ssh_keys
+      ssh_keys = Dir.glob File.join(ssh_dir, '*')
+      ssh_keys.keep_if &method(:valid_ssh_private_key?)
+    end
+
+    def choose_private_key_file
+      private_key_file = nil
+      loop do
+        private_key_file = terminal.ask('Private key file: ') { |q| q.default = File.join ssh_dir, 'id_rsa' }
+        break if valid_ssh_private_key? private_key_file
+      end
+      OpenSSL::PKey::RSA.new File.read private_key_file
+    end
+
+    def valid_ssh_private_key?(private_key_file)
+      rsa_key = OpenSSL::PKey::RSA.new File.read private_key_file
+      rsa_key.private?
+    rescue
+      false
+    end
+
+    def generate_key
+      OpenSSL::PKey::RSA.generate 4096
+    end
+
+    def ssh_dir
+      File.join home_dir, '.ssh'
+    end
+
+    def home_dir
+      File.expand_path '~'
+    end
+  end
+end
+