arcanus 0.1.0

data/lib/arcanus/key.rb

@@ -0,0 +1,55 @@
+require 'openssl'
+
+module Arcanus
+  # Encapsulates operations for creating keys that encrypt/decrypt secrets.
+  class Key
+    DEFAULT_SIZE = 4096
+    PASSWORD_CIPHER = OpenSSL::Cipher.new('AES-256-CBC')
+
+    class << self
+      def generate(key_size_bits: DEFAULT_SIZE)
+        key = OpenSSL::PKey::RSA.new(key_size_bits)
+        new(key)
+      end
+
+      def from_file(file_path)
+        key = OpenSSL::PKey::RSA.new(File.read(file_path))
+        new(key)
+      rescue OpenSSL::PKey::RSAError
+        raise Errors::DecryptionError,
+              "Invalid PEM file #{file_path}"
+      end
+
+      def from_protected_file(file_path, password)
+        key = OpenSSL::PKey::RSA.new(File.read(file_path), password)
+        new(key)
+      rescue OpenSSL::PKey::RSAError
+        raise Errors::DecryptionError,
+              'Either the password is invalid or the PEM file is invalid'
+      end
+    end
+
+    def initialize(key)
+      @key = key
+    end
+
+    def save(key_file_path:, password: nil)
+      pem =
+        if password
+          @key.to_pem(PASSWORD_CIPHER, password)
+        else
+          @key.to_pem
+        end
+
+      File.open(key_file_path, 'w') { |f| f.write(pem) }
+    end
+
+    def encrypt(plaintext)
+      @key.public_encrypt(plaintext)
+    end
+
+    def decrypt(ciphertext)
+      @key.private_decrypt(ciphertext)
+    end
+  end
+end

data/lib/arcanus/output.rb

@@ -0,0 +1,25 @@
+module Arcanus
+  # Encapsulates all communication to an output source.
+  class Output
+    # Creates a {Arcanus::Output} which displays nothing.
+    #
+    # @return [Arcanus::Output]
+    def self.silent
+      new(File.open('/dev/null', 'w'))
+    end
+
+    # Creates a new {Arcanus::Output} instance.
+    #
+    # @param stream [IO] the output destination stream.
+    def initialize(stream)
+      @output_stream = stream
+    end
+
+    # Print the specified output.
+    #
+    # @param [String] output the output to display
+    def print(output)
+      @output_stream.print(output)
+    end
+  end
+end

data/lib/arcanus/repo.rb

@@ -0,0 +1,84 @@
+require 'pathname'
+
+module Arcanus
+  # Exposes information about the current git repository.
+  class Repo
+    # @param config [Arcanus::Configuration]
+    def initialize(config)
+      @config = config
+    end
+
+    # Returns the absolute path to the root of the current repository the
+    # current working directory resides within.
+    #
+    # @return [String]
+    # @raise [Arcanus::Errors::InvalidGitRepoError] if the current directory
+    #   doesn't reside within a git repository
+    def root
+      @root ||=
+        begin
+          git_dir = Pathname.new(File.expand_path('.'))
+                            .enum_for(:ascend)
+                            .find do |path|
+            (path + '.git').exist?
+          end
+
+          unless git_dir
+            raise Errors::InvalidGitRepoError, 'no .git directory found'
+          end
+
+          git_dir.to_s
+        end
+    end
+
+    # Returns an absolute path to the .git directory for a repo.
+    #
+    # @return [String]
+    def git_dir
+      @git_dir ||=
+        begin
+          git_dir = File.expand_path('.git', root)
+
+          # .git could also be a file that contains the location of the git directory
+          unless File.directory?(git_dir)
+            git_dir = File.read(git_dir)[/^gitdir: (.*)$/, 1]
+
+            # Resolve relative paths
+            unless git_dir.start_with?('/')
+              git_dir = File.expand_path(git_dir, repo_dir)
+            end
+          end
+
+          git_dir
+        end
+    end
+
+    def gitignore_file_path
+      File.join(root, '.gitignore')
+    end
+
+    def chest_file_path
+      File.join(root, CHEST_FILE_NAME)
+    end
+
+    def has_chest_file?
+      File.exist?(chest_file_path)
+    end
+
+    def locked_key_path
+      File.join(root, LOCKED_KEY_NAME)
+    end
+
+    def has_locked_key?
+      File.exist?(locked_key_path)
+    end
+
+    def unlocked_key_path
+      File.join(root, UNLOCKED_KEY_NAME)
+    end
+
+    def has_unlocked_key?
+      File.exist?(unlocked_key_path)
+    end
+  end
+end

data/lib/arcanus/subprocess.rb

@@ -0,0 +1,53 @@
+require 'childprocess'
+require 'tempfile'
+
+module Arcanus
+  # Manages execution of a child process, collecting the exit status and
+  # standard out/error output.
+  class Subprocess
+    # Encapsulates the result of a process.
+    #
+    # @attr_reader status [Integer] exit status code returned by process
+    # @attr_reader stdout [String] standard output stream output
+    # @attr_reader stderr [String] standard error stream output
+    Result = Struct.new(:status, :stdout, :stderr) do
+      def success?
+        status == 0
+      end
+    end
+
+    class << self
+      # Spawns a new process using the given array of arguments (the first
+      # element is the command).
+      #
+      # @param args [Array<String>]
+      # @return [Result]
+      def spawn(args)
+        process = ChildProcess.build(*args)
+
+        out, err = assign_output_streams(process)
+
+        process.start
+        process.wait
+
+        err.rewind
+        out.rewind
+
+        Result.new(process.exit_code, out.read, err.read)
+      end
+
+      private
+
+      # @param process [ChildProcess]
+      # @return [Array<IO>]
+      def assign_output_streams(process)
+        %w[out err].map do |stream_name|
+          ::Tempfile.new(stream_name).tap do |stream|
+            stream.sync = true
+            process.io.send("std#{stream_name}=", stream)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arcanus/ui.rb

@@ -0,0 +1,132 @@
+require 'forwardable'
+require 'tty'
+
+module Arcanus
+  # Manages all interaction with the user.
+  class UI
+    extend Forwardable
+
+    def_delegators :@shell, :ask, :confirm
+
+    # Creates a {UI} that mediates between the given input/output streams.
+    #
+    # @param input [Arcanus::Input]
+    # @param output [Arcanus::Output]
+    def initialize(input, output)
+      @input = input
+      @output = output
+      @pastel = Pastel.new
+      @shell = TTY::Shell.new
+    end
+
+    # Get user input, stripping extraneous whitespace.
+    #
+    # @return [String, nil]
+    def user_input
+      if input = @input.get
+        input.strip
+      end
+    rescue Interrupt
+      exit 130 # User cancelled
+    end
+
+    # Get user input without echoing (useful for passwords).
+    #
+    # Does not strip extraneous whitespace (since it could be part of password).
+    #
+    # @return [String, nil]
+    def secret_user_input
+      @input.get(noecho: true)
+    rescue Interrupt
+      exit 130 # User cancelled
+    end
+
+    # Print the specified output.
+    #
+    # @param output [String]
+    # @param newline [Boolean] whether to append a newline
+    def print(output, newline: true)
+      @output.print(output)
+      @output.print("\n") if newline
+    end
+
+    # Print output in bold face.
+    #
+    # @param args [Array]
+    # @param kwargs [Hash]
+    def bold(*args, **kwargs)
+      print(@pastel.bold(*args), **kwargs)
+    end
+
+    # Print the specified output in a color indicative of error.
+    #
+    # @param args [Array]
+    # @param kwargs [Hash]
+    def error(args, **kwargs)
+      print(@pastel.red(*args), **kwargs)
+    end
+
+    # Print the specified output in a bold face and color indicative of error.
+    #
+    # @param args [Array]
+    # @param kwargs [Hash]
+    def bold_error(*args, **kwargs)
+      print(@pastel.bold.red(*args), **kwargs)
+    end
+
+    # Print the specified output in a color indicative of success.
+    #
+    # @param args [Array]
+    # @param kwargs [Hash]
+    def success(*args, **kwargs)
+      print(@pastel.green(*args), **kwargs)
+    end
+
+    # Print the specified output in a color indicative of a warning.
+    #
+    # @param args [Array]
+    # @param kwargs [Hash]
+    def warning(*args, **kwargs)
+      print(@pastel.yellow(*args), **kwargs)
+    end
+
+    # Print the specified output in a color indicating information.
+    #
+    # @param args [Array]
+    # @param kwargs [Hash]
+    def info(*args, **kwargs)
+      print(@pastel.cyan(*args), **kwargs)
+    end
+
+    # Print a blank line.
+    def newline
+      print('')
+    end
+
+    # Execute a command with a spinner animation until it completes.
+    def spinner(*args, &block)
+      spinner = TTY::Spinner.new(*args)
+      spinner_thread = Thread.new do
+        loop do
+          sleep 0.1
+          spinner.spin
+        end
+      end
+
+      block.call
+    ensure
+      spinner_thread.kill
+      newline # Ensure next line of ouptut on separate line from spinner
+    end
+
+    # Prints a table.
+    #
+    # Customize the table by passing a block and operating on the table object
+    # passed to that block to add rows and customize its appearance.
+    def table(options = {}, &block)
+      t = TTY::Table.new(options)
+      block.call(t)
+      print(t.render(:unicode, options))
+    end
+  end
+end

data/lib/arcanus/utils.rb

@@ -0,0 +1,30 @@
+module Arcanus
+  # A miscellaneous set of utility functions.
+  module Utils
+    module_function
+
+    # Converts a string containing underscores/hyphens/spaces into CamelCase.
+    #
+    # @param [String] string
+    # @return [String]
+    def camel_case(string)
+      string.split(/_|-| /)
+            .map { |part| part.sub(/^\w/, &:upcase) }
+            .join
+    end
+
+    # Convert string containing camel case or spaces into snake case.
+    #
+    # @see stackoverflow.com/questions/1509915/converting-camel-case-to-underscore-case-in-ruby
+    #
+    # @param [String] string
+    # @return [String]
+    def snake_case(string)
+      string.gsub(/::/, '/')
+            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .tr('-', '_')
+            .downcase
+    end
+  end
+end

data/lib/arcanus/version.rb

@@ -0,0 +1,4 @@
+# Defines the gem version.
+module Arcanus
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: arcanus
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shane da Silva
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: childprocess
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.6
+- !ruby/object:Gem::Dependency
+  name: tty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+description: Tool for working with encrypted secrets in repositories
+email:
+- shane@dasilva.io
+executables:
+- arcanus
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/arcanus
+- lib/arcanus.rb
+- lib/arcanus/chest.rb
+- lib/arcanus/cli.rb
+- lib/arcanus/command/base.rb
+- lib/arcanus/command/edit.rb
+- lib/arcanus/command/export.rb
+- lib/arcanus/command/help.rb
+- lib/arcanus/command/setup.rb
+- lib/arcanus/command/shared/ensure_key.rb
+- lib/arcanus/command/show.rb
+- lib/arcanus/command/unlock.rb
+- lib/arcanus/command/version.rb
+- lib/arcanus/configuration.rb
+- lib/arcanus/constants.rb
+- lib/arcanus/error_handler.rb
+- lib/arcanus/errors.rb
+- lib/arcanus/input.rb
+- lib/arcanus/key.rb
+- lib/arcanus/output.rb
+- lib/arcanus/repo.rb
+- lib/arcanus/subprocess.rb
+- lib/arcanus/ui.rb
+- lib/arcanus/utils.rb
+- lib/arcanus/version.rb
+homepage: https://github.com/sds/arcanus
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Arcanus command line interface
+test_files: []
+has_rdoc: