uffizzi-cli 0.5.0 → 0.6.0

data/lib/uffizzi/cli/preview.rb

@@ -48,7 +48,7 @@ module Uffizzi
         Uffizzi.ui.disable_stdout
       end
       raise Uffizzi::Error.new('You are not logged in.') unless Uffizzi::AuthHelper.signed_in?
-      raise Uffizzi::Error.new('This command needs project to be set in config file') unless Uffizzi::AuthHelper.project_set?
+      raise Uffizzi::Error.new('This command needs project to be set in config file') unless Uffizzi::AuthHelper.project_set?(options)
 
       project_slug = options[:project].nil? ? ConfigFile.read_option(:project) : options[:project]
 
@@ -67,7 +67,7 @@ module Uffizzi
     end
 
     def handle_list_command(project_slug)
-      response = fetch_deployments(ConfigFile.read_option(:hostname), project_slug)
+      response = fetch_deployments(ConfigFile.read_option(:server), project_slug)
 
       if ResponseHelper.ok?(response)
         handle_succeed_list_response(response)
@@ -78,7 +78,7 @@ module Uffizzi
 
     def handle_create_command(file_path, project_slug)
       params = file_path.nil? ? {} : prepare_params(file_path)
-      response = create_deployment(ConfigFile.read_option(:hostname), project_slug, params)
+      response = create_deployment(ConfigFile.read_option(:server), project_slug, params)
 
       if ResponseHelper.created?(response)
         handle_succeed_create_response(project_slug, response)
@@ -92,7 +92,7 @@ module Uffizzi
 
       return Uffizzi.ui.say("Preview should be specified in 'deployment-PREVIEW_ID' format") if deployment_id.nil?
 
-      response = fetch_events(ConfigFile.read_option(:hostname), project_slug, deployment_id)
+      response = fetch_events(ConfigFile.read_option(:server), project_slug, deployment_id)
 
       if ResponseHelper.ok?(response)
         handle_succeed_events_response(response)
@@ -102,7 +102,7 @@ module Uffizzi
     end
 
     def handle_succeed_events_response(response)
-      Uffizzi.ui.print_in_columns(response[:body][:events])
+      Uffizzi.ui.pretty_say(response[:body][:events])
     end
 
     def handle_succeed_create_response(project_slug, response)
@@ -110,7 +110,7 @@ module Uffizzi
       deployment_id = deployment[:id]
       params = { id: deployment_id }
 
-      response = deploy_containers(ConfigFile.read_option(:hostname), project_slug, deployment_id, params)
+      response = deploy_containers(ConfigFile.read_option(:server), project_slug, deployment_id, params)
 
       if ResponseHelper.no_content?(response)
         Uffizzi.ui.say("Preview created with name deployment-#{deployment_id}")
@@ -129,12 +129,12 @@ module Uffizzi
       activity_items = []
 
       loop do
-        response = get_activity_items(ConfigFile.read_option(:hostname), project_slug, deployment_id)
+        response = get_activity_items(ConfigFile.read_option(:server), project_slug, deployment_id)
         handle_activity_items_response(response)
         return unless @spinner.spinning?
 
         activity_items = response[:body][:activity_items]
-        break unless activity_items.empty?
+        break if !activity_items.empty? && activity_items.count == deployment[:containers].count
 
         sleep(5)
       end
@@ -164,7 +164,7 @@ module Uffizzi
 
     def wait_containers_deploying(project_slug, deployment_id, containers_spinners)
       loop do
-        response = get_activity_items(ConfigFile.read_option(:hostname), project_slug, deployment_id)
+        response = get_activity_items(ConfigFile.read_option(:server), project_slug, deployment_id)
         handle_activity_items_response(response)
         return if @spinner.done?
 
@@ -208,7 +208,7 @@ module Uffizzi
 
       return Uffizzi.ui.say("Preview should be specified in 'deployment-PREVIEW_ID' format") if deployment_id.nil?
 
-      response = delete_deployment(ConfigFile.read_option(:hostname), project_slug, deployment_id)
+      response = delete_deployment(ConfigFile.read_option(:server), project_slug, deployment_id)
 
       if ResponseHelper.no_content?(response)
         handle_succeed_delete_response(deployment_id)
@@ -222,7 +222,7 @@ module Uffizzi
 
       return Uffizzi.ui.say("Preview should be specified in 'deployment-PREVIEW_ID' format") if deployment_id.nil?
 
-      response = describe_deployment(ConfigFile.read_option(:hostname), project_slug, deployment_id)
+      response = describe_deployment(ConfigFile.read_option(:server), project_slug, deployment_id)
 
       if ResponseHelper.ok?(response)
         handle_succeed_describe_response(response)

data/lib/uffizzi/cli/project/compose.rb

@@ -12,25 +12,27 @@ module Uffizzi
 
     desc 'set [OPTIONS]', 'set'
     def set
-      run(options, 'set')
+      run('set')
     end
 
     desc 'unset', 'unset'
     def unset
-      run(options, 'unset')
+      run('unset')
     end
 
     desc 'describe', 'describe'
     def describe
-      run(options, 'describe')
+      run('describe')
     end
 
     private
 
-    def run(options, command)
+    def run(command)
       return Uffizzi.ui.say('You are not logged in.') unless Uffizzi::AuthHelper.signed_in?
-      return Uffizzi.ui.say('This command needs project to be set in config file') unless Uffizzi::AuthHelper.project_set?
+      return Uffizzi.ui.say('This command needs project to be set in config file') unless Uffizzi::AuthHelper.project_set?(options)
 
+      @project_slug = options[:project].nil? ? ConfigFile.read_option(:project) : options[:project]
+      @server = ConfigFile.read_option(:server)
       file_path = options[:file]
       case command
       when 'set'
@@ -39,18 +41,14 @@ module Uffizzi
         handle_unset_command
       when 'describe'
         handle_describe_command
-      when 'validate'
-        handle_validate_command(file_path)
       end
     end
 
     def handle_set_command(file_path)
       return Uffizzi.ui.say('No file provided') if file_path.nil?
 
-      hostname = ConfigFile.read_option(:hostname)
-      project_slug = ConfigFile.read_option(:project)
       params = prepare_params(file_path)
-      response = set_compose_file(hostname, params, project_slug)
+      response = set_compose_file(@server, params, @project_slug)
 
       if ResponseHelper.created?(response)
         Uffizzi.ui.say('compose file created')
@@ -60,9 +58,9 @@ module Uffizzi
     end
 
     def handle_unset_command
-      hostname = ConfigFile.read_option(:hostname)
+      server = ConfigFile.read_option(:server)
       project_slug = ConfigFile.read_option(:project)
-      response = unset_compose_file(hostname, project_slug)
+      response = unset_compose_file(server, project_slug)
 
       if ResponseHelper.no_content?(response)
         Uffizzi.ui.say('compose file deleted')
@@ -72,9 +70,9 @@ module Uffizzi
     end
 
     def handle_describe_command
-      hostname = ConfigFile.read_option(:hostname)
+      server = ConfigFile.read_option(:server)
       project_slug = ConfigFile.read_option(:project)
-      response = describe_compose_file(hostname, project_slug)
+      response = describe_compose_file(server, project_slug)
       compose_file = response[:body][:compose_file]
 
       if ResponseHelper.ok?(response)

data/lib/uffizzi/cli/project/secret.rb

@@ -48,8 +48,8 @@ module Uffizzi
     end
 
     def handle_list_command(project_slug)
-      hostname = ConfigFile.read_option(:hostname)
-      response = fetch_secrets(hostname, project_slug)
+      server = ConfigFile.read_option(:server)
+      response = fetch_secrets(server, project_slug)
       secrets = response[:body][:secrets].map { |secret| [secret[:name]] }
       return Uffizzi.ui.say('There are no secrets for the project') if secrets.empty?
 
@@ -61,20 +61,20 @@ module Uffizzi
     end
 
     def handle_create_command(project_slug, id)
-      hostname = ConfigFile.read_option(:hostname)
+      server = ConfigFile.read_option(:server)
       secret_value = $stdin.read
       return Uffizzi.ui.say('Please provide the secret value') if secret_value.nil?
 
       params = { secrets: [{ name: id, value: secret_value }] }
-      response = bulk_create_secrets(hostname, project_slug, params)
+      response = bulk_create_secrets(server, project_slug, params)
       return Uffizzi.ui.say('The secret was successfully created') if ResponseHelper.created?(response)
 
       ResponseHelper.handle_failed_response(response)
     end
 
     def handle_delete_command(project_slug, id)
-      hostname = ConfigFile.read_option(:hostname)
-      response = delete_secret(hostname, project_slug, id)
+      server = ConfigFile.read_option(:server)
+      response = delete_secret(server, project_slug, id)
 
       if ResponseHelper.no_content?(response)
         Uffizzi.ui.say('The secret was successfully deleted')

data/lib/uffizzi/cli/project.rb

@@ -34,8 +34,8 @@ module Uffizzi
     end
 
     def handle_list_command
-      hostname = ConfigFile.read_option(:hostname)
-      response = fetch_projects(hostname)
+      server = ConfigFile.read_option(:server)
+      response = fetch_projects(server)
 
       if ResponseHelper.ok?(response)
         handle_succeed_response(response)

data/lib/uffizzi/cli.rb

@@ -4,19 +4,24 @@ require 'uffizzi'
 
 module Uffizzi
   class CLI < Thor
+    require_relative 'cli/common'
+
+    class_option :help, type: :boolean, aliases: HELP_MAPPINGS
+    class_option :project, type: :string
+
     def self.exit_on_failure?
       true
     end
 
-    desc 'version', 'show version'
+    desc 'version', 'Show Version'
     def version
       require_relative 'version'
       Uffizzi.ui.say(Uffizzi::VERSION)
     end
 
     desc 'login [OPTIONS]', 'Login into Uffizzi'
-    method_option :user, required: true, aliases: '-u'
-    method_option :hostname, required: true
+    method_option :server, required: false, aliases: '-s'
+    method_option :username, required: false, aliases: '-u'
     def login
       require_relative 'cli/login'
       Login.new(options).run

data/lib/uffizzi/clients/api/api_client.rb

@@ -6,148 +6,148 @@ require_relative 'http_client'
 module ApiClient
   include ApiRoutes
 
-  def create_session(hostname, params = {})
-    uri = session_uri(hostname)
+  def create_session(server, params = {})
+    uri = session_uri(server)
     response = Uffizzi::HttpClient.make_post_request(uri, params, false)
 
     build_response(response)
   end
 
-  def destroy_session(hostname)
-    uri = session_uri(hostname)
+  def destroy_session(server)
+    uri = session_uri(server)
     response = Uffizzi::HttpClient.make_delete_request(uri)
 
     build_response(response)
   end
 
-  def fetch_projects(hostname)
-    uri = projects_uri(hostname)
+  def fetch_projects(server)
+    uri = projects_uri(server)
     response = Uffizzi::HttpClient.make_get_request(uri)
 
     build_response(response)
   end
 
-  def create_credential(hostname, params)
-    uri = credentials_uri(hostname)
+  def create_credential(server, params)
+    uri = credentials_uri(server)
     response = Uffizzi::HttpClient.make_post_request(uri, params)
 
     build_response(response)
   end
 
-  def fetch_deployment_services(hostname, project_slug, deployment_id)
-    uri = preview_services_uri(hostname, project_slug, deployment_id)
+  def fetch_deployment_services(server, project_slug, deployment_id)
+    uri = preview_services_uri(server, project_slug, deployment_id)
     response = Uffizzi::HttpClient.make_get_request(uri)
 
     build_response(response)
   end
 
-  def delete_credential(hostname, credential_type)
-    uri = delete_credential_uri(hostname, credential_type)
+  def delete_credential(server, credential_type)
+    uri = delete_credential_uri(server, credential_type)
     response = Uffizzi::HttpClient.make_delete_request(uri)
 
     build_response(response)
   end
 
-  def fetch_deployment_service_logs(hostname, project_slug, deployment_id, container_name)
-    uri = preview_service_logs_uri(hostname, project_slug, deployment_id, container_name)
+  def fetch_deployment_service_logs(server, project_slug, deployment_id, container_name)
+    uri = preview_service_logs_uri(server, project_slug, deployment_id, container_name)
     response = Uffizzi::HttpClient.make_get_request(uri)
 
     build_response(response)
   end
 
-  def set_compose_file(hostname, params, project_slug)
-    uri = compose_file_uri(hostname, project_slug)
+  def set_compose_file(server, params, project_slug)
+    uri = compose_file_uri(server, project_slug)
     response = Uffizzi::HttpClient.make_post_request(uri, params)
 
     build_response(response)
   end
 
-  def unset_compose_file(hostname, project_slug)
-    uri = compose_file_uri(hostname, project_slug)
+  def unset_compose_file(server, project_slug)
+    uri = compose_file_uri(server, project_slug)
     response = Uffizzi::HttpClient.make_delete_request(uri)
 
     build_response(response)
   end
 
-  def fetch_secrets(hostname, project_slug)
-    uri = secrets_uri(hostname, project_slug)
+  def fetch_secrets(server, project_slug)
+    uri = secrets_uri(server, project_slug)
     response = Uffizzi::HttpClient.make_get_request(uri)
 
     build_response(response)
   end
 
-  def bulk_create_secrets(hostname, project_slug, params)
-    uri = "#{secrets_uri(hostname, project_slug)}/bulk_create"
+  def bulk_create_secrets(server, project_slug, params)
+    uri = "#{secrets_uri(server, project_slug)}/bulk_create"
     response = Uffizzi::HttpClient.make_post_request(uri, params)
 
     build_response(response)
   end
 
-  def delete_secret(hostname, project_slug, id)
-    uri = secret_uri(hostname, project_slug, id)
+  def delete_secret(server, project_slug, id)
+    uri = secret_uri(server, project_slug, id)
     response = Uffizzi::HttpClient.make_delete_request(uri)
 
     build_response(response)
   end
 
-  def describe_compose_file(hostname, project_slug)
-    uri = compose_file_uri(hostname, project_slug)
+  def describe_compose_file(server, project_slug)
+    uri = compose_file_uri(server, project_slug)
     response = Uffizzi::HttpClient.make_get_request(uri)
 
     build_response(response)
   end
 
-  def validate_compose_file(hostname, project_slug)
-    uri = validate_compose_file_uri(hostname, project_slug)
+  def validate_compose_file(server, project_slug)
+    uri = validate_compose_file_uri(server, project_slug)
     response = Uffizzi::HttpClient.make_get_request(uri)
 
     build_response(response)
   end
 
-  def fetch_deployments(hostname, project_slug)
-    uri = deployments_uri(hostname, project_slug)
+  def fetch_deployments(server, project_slug)
+    uri = deployments_uri(server, project_slug)
     response = Uffizzi::HttpClient.make_get_request(uri)
 
     build_response(response)
   end
 
-  def create_deployment(hostname, project_slug, params)
-    uri = deployments_uri(hostname, project_slug)
+  def create_deployment(server, project_slug, params)
+    uri = deployments_uri(server, project_slug)
     response = Uffizzi::HttpClient.make_post_request(uri, params)
 
     build_response(response)
   end
 
-  def delete_deployment(hostname, project_slug, deployment_id)
-    uri = deployment_uri(hostname, project_slug, deployment_id)
+  def delete_deployment(server, project_slug, deployment_id)
+    uri = deployment_uri(server, project_slug, deployment_id)
     response = Uffizzi::HttpClient.make_delete_request(uri)
 
     build_response(response)
   end
 
-  def describe_deployment(hostname, project_slug, deployment_id)
-    uri = deployment_uri(hostname, project_slug, deployment_id)
+  def describe_deployment(server, project_slug, deployment_id)
+    uri = deployment_uri(server, project_slug, deployment_id)
     response = Uffizzi::HttpClient.make_get_request(uri)
 
     build_response(response)
   end
 
-  def fetch_events(hostname, project_slug, deployment_id)
-    uri = events_uri(hostname, project_slug, deployment_id)
+  def fetch_events(server, project_slug, deployment_id)
+    uri = events_uri(server, project_slug, deployment_id)
     response = Uffizzi::HttpClient.make_get_request(uri)
 
     build_response(response)
   end
 
-  def get_activity_items(hostname, project_slug, deployment_id)
-    uri = activity_items_uri(hostname, project_slug, deployment_id)
+  def get_activity_items(server, project_slug, deployment_id)
+    uri = activity_items_uri(server, project_slug, deployment_id)
     response = Uffizzi::HttpClient.make_get_request(uri)
 
     build_response(response)
   end
 
-  def deploy_containers(hostname, project_slug, deployment_id, params)
-    uri = deploy_containers_uri(hostname, project_slug, deployment_id)
+  def deploy_containers(server, project_slug, deployment_id, params)
+    uri = deploy_containers_uri(server, project_slug, deployment_id)
     response = Uffizzi::HttpClient.make_post_request(uri, params)
 
     build_response(response)
@@ -167,6 +167,8 @@ module ApiClient
     return nil if response.body.nil?
 
     JSON.parse(response.body, symbolize_names: true)
+  rescue JSON::ParserError
+    raise Uffizzi::Error.new(response.message)
   end
 
   def response_cookie(response)

data/lib/uffizzi/clients/api/api_routes.rb

@@ -3,64 +3,64 @@
 require 'cgi'
 
 module ApiRoutes
-  def compose_file_uri(hostname, project_slug)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/compose_file"
+  def compose_file_uri(server, project_slug)
+    "#{server}/api/cli/v1/projects/#{project_slug}/compose_file"
   end
 
-  def projects_uri(hostname)
-    "#{hostname}/api/cli/v1/projects"
+  def projects_uri(server)
+    "#{server}/api/cli/v1/projects"
   end
 
-  def secret_uri(hostname, project_slug, id)
+  def secret_uri(server, project_slug, id)
     path_id = CGI.escape(id)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/secrets/#{path_id}"
+    "#{server}/api/cli/v1/projects/#{project_slug}/secrets/#{path_id}"
   end
 
-  def secrets_uri(hostname, project_slug)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/secrets"
+  def secrets_uri(server, project_slug)
+    "#{server}/api/cli/v1/projects/#{project_slug}/secrets"
   end
 
-  def session_uri(hostname)
-    "#{hostname}/api/cli/v1/session"
+  def session_uri(server)
+    "#{server}/api/cli/v1/session"
   end
 
-  def validate_compose_file_uri(hostname, project_slug)
-    "#{compose_files_uri(hostname, project_slug)}/validate"
+  def validate_compose_file_uri(server, project_slug)
+    "#{compose_files_uri(server, project_slug)}/validate"
   end
 
-  def deployments_uri(hostname, project_slug)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/deployments"
+  def deployments_uri(server, project_slug)
+    "#{server}/api/cli/v1/projects/#{project_slug}/deployments"
   end
 
-  def deployment_uri(hostname, project_slug, deployment_id)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}"
+  def deployment_uri(server, project_slug, deployment_id)
+    "#{server}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}"
   end
 
-  def activity_items_uri(hostname, project_slug, deployment_id)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/activity_items"
+  def activity_items_uri(server, project_slug, deployment_id)
+    "#{server}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/activity_items"
   end
 
-  def deploy_containers_uri(hostname, project_slug, deployment_id)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/deploy_containers"
+  def deploy_containers_uri(server, project_slug, deployment_id)
+    "#{server}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/deploy_containers"
   end
 
-  def events_uri(hostname, project_slug, deployment_id)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/events"
+  def events_uri(server, project_slug, deployment_id)
+    "#{server}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/events"
   end
 
-  def credentials_uri(hostname)
-    "#{hostname}/api/cli/v1/account/credentials"
+  def credentials_uri(server)
+    "#{server}/api/cli/v1/account/credentials"
   end
 
-  def preview_services_uri(hostname, project_slug, deployment_id)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/containers"
+  def preview_services_uri(server, project_slug, deployment_id)
+    "#{server}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/containers"
   end
 
-  def delete_credential_uri(hostname, credential_type)
-    "#{hostname}/api/cli/v1/account/credentials/#{credential_type}"
+  def delete_credential_uri(server, credential_type)
+    "#{server}/api/cli/v1/account/credentials/#{credential_type}"
   end
 
-  def preview_service_logs_uri(hostname, project_slug, deployment_id, container_name)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/containers/#{container_name}/logs"
+  def preview_service_logs_uri(server, project_slug, deployment_id, container_name)
+    "#{server}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/containers/#{container_name}/logs"
   end
 end

data/lib/uffizzi/clients/api/http_client.rb

@@ -36,9 +36,7 @@ module Uffizzi
           http.request(request)
         end
 
-        if response.instance_of?(Net::HTTPUnauthorized)
-          raise StandardError.new('Not authorized')
-        end
+        raise Uffizzi::Error.new('Not authorized') if response.is_a?(Net::HTTPUnauthorized)
 
         response
       end
@@ -59,7 +57,7 @@ module Uffizzi
           request.body = params.to_json
         end
         request['Cookie'] = ConfigFile.read_option(:cookie) if require_cookies
-        if ConfigFile.exists? && ConfigFile.option_exists?(:basic_auth_user) && ConfigFile.option_exists?(:basic_auth_password)
+        if ConfigFile.exists? && ConfigFile.option_has_value?(:basic_auth_user) && ConfigFile.option_has_value?(:basic_auth_password)
           request.basic_auth(ConfigFile.read_option(:basic_auth_user), ConfigFile.read_option(:basic_auth_password))
         end
 

data/lib/uffizzi/config_file.rb

@@ -5,11 +5,11 @@ require 'fileutils'
 
 module Uffizzi
   class ConfigFile
-    CONFIG_PATH = "#{Dir.home}/.uffizzi/config.json"
+    CONFIG_PATH = "#{Dir.home}/.config/uffizzi/config_default.json"
 
     class << self
-      def create(account_id, cookie, hostname)
-        data = prepare_config_data(account_id, cookie, hostname)
+      def create(account_id, cookie, server)
+        data = prepare_config_data(account_id, cookie, server)
         data.each_pair { |key, value| write_option(key, value) }
       end
 
@@ -28,11 +28,11 @@ module Uffizzi
         data[option]
       end
 
-      def option_exists?(option)
+      def option_has_value?(option)
         data = read
-        return false unless data.is_a?(Hash)
+        return false if !data.is_a?(Hash) || !option_exists?(option)
 
-        data.key?(option)
+        !data[option].empty?
       end
 
       def write_option(key, value)
@@ -40,15 +40,15 @@ module Uffizzi
         return nil unless data.is_a?(Hash)
 
         data[key] = value
-        write(data.to_json)
+        write(data)
       end
 
-      def delete_option(key)
+      def unset_option(key)
         data = read
-        return nil unless data.is_a?(Hash)
+        return nil unless data.is_a?(Hash) || !option_exists?(key)
 
-        new_data = data.except(key)
-        write(new_data.to_json)
+        data[key] = ''
+        write(data)
       end
 
       def rewrite_cookie(cookie)
@@ -61,7 +61,7 @@ module Uffizzi
 
         content = data.reduce('') do |acc, pair|
           property, value = pair
-          "#{acc}#{property} - #{value}\n"
+          "#{acc}#{property} = #{value}\n"
         end
 
         Uffizzi.ui.say(content)
@@ -71,26 +71,42 @@ module Uffizzi
 
       private
 
+      def option_exists?(option)
+        data = read
+        return false unless data.is_a?(Hash)
+
+        data.key?(option)
+      end
+
       def read
-        JSON.parse(File.read(CONFIG_PATH), symbolize_names: true)
+        data = File.read(CONFIG_PATH)
+        options = data.split("\n")
+        options.reduce({}) do |acc, option|
+          key, value = option.split('=', 2)
+          acc.merge({ key.strip.to_sym => value.strip })
+        end
       rescue Errno::ENOENT => e
         Uffizzi.ui.say(e)
-        nil
-      rescue JSON::ParserError
-        Uffizzi.ui.say('Config file is in incorrect format')
-        nil
       end
 
       def write(data)
         file = create_file
-        file.write(data)
+        prepared_data = prepare_data(data)
+        file.write(prepared_data)
         file.close
       end
 
-      def prepare_config_data(account_id, cookie, hostname)
+      def prepare_data(data)
+        data.reduce('') do |acc, option|
+          key, value = option
+          "#{acc}#{key} = #{value}\n"
+        end
+      end
+
+      def prepare_config_data(account_id, cookie, server)
         {
           account_id: account_id,
-          hostname: hostname,
+          server: server,
           cookie: cookie,
         }
       end