shopify-cli 0.9.0

data/lib/shopify-cli/commands.rb

@@ -0,0 +1,28 @@
+require 'shopify_cli'
+
+module ShopifyCli
+  module Commands
+    Registry = CLI::Kit::CommandRegistry.new(
+      default: 'help',
+      contextual_resolver: nil,
+    )
+    @core_commands = []
+
+    def self.register(const, cmd, path = nil, is_core = false)
+      autoload(const, path) if path
+      Registry.add(->() { const_get(const) }, cmd)
+      @core_commands.push(cmd) if is_core
+    end
+
+    def self.core_command?(cmd)
+      @core_commands.include?(cmd)
+    end
+
+    register :Connect, 'connect', 'shopify-cli/commands/connect', true
+    register :Create, 'create', 'shopify-cli/commands/create', true
+    register :Help, 'help', 'shopify-cli/commands/help', true
+    register :Logout, 'logout', 'shopify-cli/commands/logout', true
+    register :System, 'system', 'shopify-cli/commands/system', true
+    register :Version, 'version', 'shopify-cli/commands/version', true
+  end
+end

data/lib/shopify-cli/commands/connect.rb

@@ -0,0 +1,108 @@
+require 'shopify_cli'
+
+module ShopifyCli
+  module Commands
+    class Connect < ShopifyCli::Command
+      def call(*)
+        project_type = ask_project_type unless Project.has_current?
+
+        if Project.has_current? && Project.current
+          @ctx.puts @ctx.message('core.connect.already_connected_warning')
+          prod_warning = @ctx.message('core.connect.production_warning')
+          @ctx.puts prod_warning if [:rails, :node].include?(Project.current_project_type)
+        end
+
+        env_data = begin
+          Resources::EnvFile.parse_external_env
+                   rescue Errno::ENOENT
+                     {}
+        end
+
+        org = fetch_org
+        id = org['id']
+        app = get_app(org['apps'])
+        shop = get_shop(org['stores'], id)
+
+        write_env(app, shop, env_data[:scopes], env_data[:extra])
+        write_cli_yml(project_type, id) unless Project.has_current?
+
+        @ctx.puts(@ctx.message('core.connect.connected', app.first['title']))
+      end
+
+      def ask_project_type
+        CLI::UI::Prompt.ask(@ctx.message('core.connect.project_type_select')) do |handler|
+          ShopifyCli::Commands::Create.all_visible_type.each do |type|
+            handler.option(type.project_name) { type.project_type }
+          end
+        end
+      end
+
+      def fetch_org
+        orgs = PartnersAPI::Organizations.fetch_with_app(@ctx)
+        org_id = if orgs.count == 1
+          orgs.first["id"]
+        else
+          CLI::UI::Prompt.ask(@ctx.message('core.connect.organization_select')) do |handler|
+            orgs.each do |org|
+              handler.option(
+                ctx.message('core.partners_api.org_name_and_id', org['businessName'], org['id'])
+              ) { org["id"] }
+            end
+          end
+        end
+        org = orgs.find { |o| o["id"] == org_id }
+        org
+      end
+
+      def get_app(apps)
+        app_id = if apps.count == 1
+          apps.first["id"]
+        else
+          CLI::UI::Prompt.ask(@ctx.message('core.connect.app_select')) do |handler|
+            apps.each { |app| handler.option(app["title"]) { app["id"] } }
+          end
+        end
+        apps.select { |app| app["id"] == app_id }
+      end
+
+      def get_shop(shops, id)
+        if shops.count == 1
+          shop = shops.first["shopDomain"]
+        elsif shops.count == 0
+          @ctx.puts(@ctx.message('core.connect.no_development_stores', id))
+        else
+          shop = CLI::UI::Prompt.ask(@ctx.message('core.connect.development_store_select')) do |handler|
+            shops.each { |s| handler.option(s["shopName"]) { s["shopDomain"] } }
+          end
+        end
+        shop
+      end
+
+      def write_env(app, shop, scopes, extra)
+        scopes = 'write_products,write_customers,write_draft_orders' if scopes.nil?
+        extra = {} if extra.nil?
+
+        Resources::EnvFile.new(
+          api_key: app.first["apiKey"],
+          secret: app.first["apiSecretKeys"].first["secret"],
+          shop: shop,
+          scopes: scopes,
+          extra: extra,
+        ).write(@ctx)
+      end
+
+      def write_cli_yml(project_type, org_id)
+        ShopifyCli::Project.write(
+          @ctx,
+          project_type: project_type,
+          organization_id: org_id,
+        )
+        @ctx.done(@ctx.message('core.connect.cli_yml_saved'))
+      end
+
+      def self.help
+        ShopifyCli::Context.message('core.connect.help', ShopifyCli::TOOL_NAME)
+      end
+    end
+  end
+end

data/lib/shopify-cli/commands/create.rb

@@ -0,0 +1,50 @@
+require 'shopify_cli'
+
+module ShopifyCli
+  module Commands
+    class Create < ShopifyCli::Command
+      def self.call(args, command_name)
+        ProjectType.load_type(args[0]) unless args.empty?
+        super
+      end
+
+      def call(args, command_name)
+        unless args.empty?
+          @ctx.puts(@ctx.message('core.create.error.invalid_app_type', args[0]))
+          return @ctx.puts(self.class.help)
+        end
+
+        type_name = CLI::UI::Prompt.ask(@ctx.message('core.create.project_type_select')) do |handler|
+          self.class.all_visible_type.each do |type|
+            handler.option(type.project_name) { type.project_type }
+          end
+        end
+
+        klass = ProjectType.load_type(type_name).create_command
+        klass.ctx = @ctx
+        klass.call(args, command_name, 'create')
+      end
+
+      def self.all_visible_type
+        ProjectType
+          .load_all
+          .select { |type| !type.hidden }
+      end
+
+      def self.help
+        project_types = all_visible_type.map(&:project_type).join(" | ")
+        ShopifyCli::Context.message('core.create.help', ShopifyCli::TOOL_NAME, project_types)
+      end
+
+      def self.extended_help
+        <<~HELP
+          #{
+            all_visible_type.map do |type|
+              type.create_command.help
+            end.join("\n")
+          }
+        HELP
+      end
+    end
+  end
+end

data/lib/shopify-cli/commands/help.rb

@@ -0,0 +1,79 @@
+require 'shopify_cli'
+
+module ShopifyCli
+  module Commands
+    class Help < ShopifyCli::Command
+      def call(args, _name)
+        command = args.shift
+        if command && command != 'help'
+          if Registry.exist?(command)
+            cmd, _ = Registry.lookup_command(command)
+            subcmd, _ = cmd.subcommand_registry.lookup_command(args.first)
+            if subcmd
+              display_help(subcmd)
+            else
+              display_help(cmd)
+            end
+            return
+          else
+            @ctx.puts(@ctx.message('core.help.error.command_not_found', command))
+          end
+        end
+
+        preamble = @ctx.message('core.help.preamble', ShopifyCli::TOOL_NAME)
+        @ctx.puts(preamble)
+
+        core_commands.each do |name, klass|
+          next if name == 'help'
+          @ctx.puts("{{command:#{name}}}: #{klass.help}\n")
+        end
+
+        return unless inside_supported_project?
+
+        @ctx.puts("{{bold:Project: #{Project.project_name} (#{project_type_name})}}")
+        @ctx.puts("{{bold:Available commands for #{project_type_name} projects:}}\n\n")
+
+        local_commands.each do |name, klass|
+          next if name == 'help'
+          @ctx.puts("{{command:#{name}}}: #{klass.help}\n")
+        end
+      end
+
+      private
+
+      def project_type_name
+        ProjectType.load_type(Project.current_project_type).project_name
+      end
+
+      def core_commands
+        resolved_commands
+          .select { |_name, c| !c.hidden }
+          .select { |name, _c| Commands.core_command?(name) }
+      end
+
+      def local_commands
+        resolved_commands
+          .reject { |name, _c| Commands.core_command?(name) }
+      end
+
+      def display_help(klass)
+        output = klass.help
+        if klass.respond_to?(:extended_help)
+          output += "\n"
+          output += klass.extended_help
+        end
+        @ctx.puts(output)
+      end
+
+      def resolved_commands
+        ShopifyCli::Commands::Registry
+          .resolved_commands
+          .sort
+      end
+
+      def inside_supported_project?
+        Project.current_project_type && ProjectType.load_type(Project.current_project_type)
+      end
+    end
+  end
+end

data/lib/shopify-cli/commands/logout.rb

@@ -0,0 +1,23 @@
+require 'shopify_cli'
+
+module ShopifyCli
+  module Commands
+    class Logout < ShopifyCli::Command
+      LOGIN_TOKENS = [
+        :identity_access_token, :identity_refresh_token, :identity_exchange_token,
+        :admin_access_token, :admin_refresh_token, :admin_exchange_token
+      ]
+
+      def call(*)
+        LOGIN_TOKENS.each do |token|
+          ShopifyCli::DB.del(token) if ShopifyCli::DB.exists?(token)
+        end
+        @ctx.puts(@ctx.message('core.logout.success'))
+      end
+
+      def self.help
+        ShopifyCli::Context.message('core.logout.help', ShopifyCli::TOOL_NAME)
+      end
+    end
+  end
+end

data/lib/shopify-cli/commands/system.rb

@@ -0,0 +1,135 @@
+require 'shopify_cli'
+require 'rbconfig'
+
+module ShopifyCli
+  module Commands
+    class System < ShopifyCli::Command
+      hidden_command
+
+      def call(args, _name)
+        show_all_details = false
+        flag = args.shift
+        if flag && flag != 'all'
+          @ctx.puts(@ctx.message('core.system.error.unknown_option', flag))
+          @ctx.puts("\n" + self.class.help)
+          return
+        end
+
+        show_all_details = true if flag == 'all'
+
+        display_environment if show_all_details
+
+        display_cli_constants(show_all_details)
+        display_cli_ruby(show_all_details)
+        display_utility_commands(show_all_details)
+        display_project_commands(show_all_details)
+      end
+
+      def self.help
+        ShopifyCli::Context.message('core.system.help', ShopifyCli::TOOL_NAME)
+      end
+
+      private
+
+      def display_cli_constants(show_all_details)
+        cli_constants = %w(ROOT)
+        cli_constants_extra = %w(
+          PROJECT_TYPES_DIR
+          TEMP_DIR
+          CACHE_DIR
+          TOOL_CONFIG_PATH
+          LOG_FILE
+          DEBUG_LOG_FILE
+        )
+
+        cli_constants += cli_constants_extra if show_all_details
+
+        @ctx.puts(@ctx.message('core.system.header'))
+        cli_constants.each do |s|
+          @ctx.puts("  " + @ctx.message('core.system.const', s, ShopifyCli.const_get(s.to_sym)) + "\n")
+        end
+      end
+
+      def display_cli_ruby(_show_all_details)
+        rbconfig_constants = %w(host RUBY_VERSION_NAME)
+
+        @ctx.puts("\n" + @ctx.message('core.system.ruby_header', RbConfig.ruby))
+        rbconfig_constants.each do |s|
+          @ctx.puts("  " + @ctx.message('core.system.rb_config', RbConfig::CONFIG[s], s))
+        end
+      end
+
+      def display_utility_commands(_show_all_details)
+        commands = %w(git curl tar unzip)
+
+        @ctx.puts("\n" + @ctx.message('core.system.command_header'))
+        commands.each do |s|
+          output, status = @ctx.capture2e('which', s)
+          if status.success?
+            @ctx.puts("  " + @ctx.message('core.system.command_with_path', s, output))
+          else
+            @ctx.puts("  " + @ctx.message('core.system.command_not_found', s))
+          end
+        end
+      end
+
+      def display_ngrok
+        ngrok_location = File.join(ShopifyCli::CACHE_DIR, 'ngrok')
+        if File.exist?(ngrok_location)
+          @ctx.puts("  " + @ctx.message('core.system.ngrok_available', ngrok_location))
+        else
+          @ctx.puts("  " + @ctx.message('core.system.ngrok_not_available'))
+        end
+      end
+
+      def display_project_commands(_show_all_details)
+        case Project.current_project_type
+        when :node
+          display_project('Node.js', %w(npm node yarn))
+        when :rails
+          display_project('Rails', %w(gem rails rake ruby))
+        end
+      end
+
+      def display_project(project_type, commands)
+        @ctx.puts("\n" + @ctx.message('core.system.project.header', project_type))
+        commands.each do |s|
+          output, status = @ctx.capture2e('which', s)
+          if status.success?
+            version_output, _ = @ctx.capture2e(s, '--version')
+            version = version_output.match(/(\d+\.[^\s]+)/)[0]
+            @ctx.puts("  " + @ctx.message('core.system.project.command_with_path', s, output.strip, version.strip))
+          else
+            @ctx.puts("  " + @ctx.message('core.system.project.command_not_found', s))
+          end
+        end
+        display_ngrok
+        display_project_environment
+      end
+
+      def display_project_environment
+        @ctx.puts("\n  " + @ctx.message('core.system.project.env_header'))
+        if File.exist?('./.env')
+          Project.current.env.to_h.each do |k, v|
+            display_value = if v.nil? || v.strip == ''
+              @ctx.message('core.system.project.env_not_set')
+            else
+              k.match(/^SHOPIFY_API/) ? "********" : v
+            end
+            @ctx.puts("  " + @ctx.message('core.system.project.env', k, display_value))
+          end
+        else
+          @ctx.puts("  " + @ctx.message('core.system.project.no_env'))
+        end
+      end
+
+      def display_environment
+        @ctx.puts(@ctx.message('core.system.environment_header'))
+        %w(TERM SHELL PATH USING_SHOPIFY_CLI LANG).each do |k|
+          @ctx.puts("  " + @ctx.message('core.system.env', k, ENV[k])) unless ENV[k].nil?
+        end
+        @ctx.puts("")
+      end
+    end
+  end
+end

data/lib/shopify-cli/commands/version.rb

@@ -0,0 +1,15 @@
+require 'shopify_cli'
+
+module ShopifyCli
+  module Commands
+    class Version < ShopifyCli::Command
+      def self.help
+        ShopifyCli::Context.message('core.version.help', ShopifyCli::TOOL_NAME)
+      end
+
+      def call(_args, _name)
+        @ctx.puts(ShopifyCli::VERSION.to_s)
+      end
+    end
+  end
+end

data/lib/shopify-cli/context.rb

@@ -0,0 +1,372 @@
+# frozen_string_literal: true
+require 'shopify_cli'
+require 'fileutils'
+require 'rbconfig'
+
+module ShopifyCli
+  ##
+  # Context captures a lot about the current running command. It captures the
+  # environment, output, system and file operations. It is useful to have the
+  # context especially in tests so that you have a single access point to these
+  # resoures.
+  #
+  class Context
+    class << self
+      attr_reader :messages
+
+      # adds a new set of messages to be used by the CLI. The messages are expected to be a hash of symbols, and
+      # multiple levels are allowed. When fetching messages a dot notation is used to separate different levels. See
+      # Context::message for more information.
+      #
+      # #### Parameters
+      # * `messages` - Hash containing the new keys to register
+      def load_messages(messages)
+        @messages ||= {}
+        @messages = @messages.merge(messages) do |key|
+          Context.new.abort("Message key '#{key}' already exists and cannot be registered") if @messages.key?(key)
+        end
+      end
+
+      # returns the user-facing messages for the given key. Returns the key if no message is available.
+      #
+      # #### Parameters
+      # * `key` - a symbol representing the message
+      # * `params` - the parameters to format the string with
+      def message(key, *params)
+        key_parts = key.split('.').map(&:to_sym)
+        str = Context.messages.dig(*key_parts)
+        str ? str % params : key
+      end
+    end
+
+    # is the directory root that the current command is running in. If you want to
+    # simulate a `cd` for the file operations, you can change this variable.
+    attr_accessor :root
+    # is an accessor for environment variables. These variables are also added to
+    # any command run by the context.
+    attr_accessor :env
+
+    def initialize(root: Dir.pwd, env: ($original_env || ENV).clone) # :nodoc:
+      self.root = root
+      self.env = env
+    end
+
+    # will return which operating system that the cli is running on [:mac, :linux]
+    def os
+      host = uname
+      return :mac if /darwin/.match(host)
+      return :linux if /linux/.match(host)
+    end
+
+    # will return true if the cli is running on an apple computer.
+    def mac?
+      os == :mac
+    end
+
+    # will return true if the cli is running on a linux distro
+    def linux?
+      os == :linux
+    end
+
+    # will return true if the cli is being run from an installation, and not a
+    # development instance. The gem installation will not have a 'test' directory.
+    # See `#development?` for checking for development environment.
+    #
+    def system?
+      !Dir.exist?(File.join(ShopifyCli::ROOT, 'test'))
+    end
+
+    # will return true if the cli is running on your development instance.
+    #
+    def development?
+      !system? && !testing?
+    end
+
+    # will return true while tests are running, either locally or on CI
+    def testing?
+      ci? || ENV['TEST']
+    end
+
+    ##
+    # will return true if the cli is being tested on CI
+    def ci?
+      ENV['CI']
+    end
+
+    # get a environment variable value by name.
+    #
+    # #### Parameters
+    # * `name` - the name of the environment variable that you want to fetch
+    #
+    # #### Returns
+    # * `value` - will return the value, or nil if the variable does not exist
+    #
+    def getenv(name)
+      v = @env[name]
+      v == '' ? nil : v
+    end
+
+    # set a environment variable value by name.
+    #
+    # #### Parameters
+    # * `key` - the name of the environment variable that you want to set
+    # * `value` - the value of the variable
+    #
+    def setenv(key, value)
+      @env[key] = value
+    end
+
+    # will write/overwrite a file with the provided contents, relative to the context root
+    # unless the file path is absolute.
+    #
+    # #### Parameters
+    # * `fname` - filename of the file that you are writing, relative to root unless it is absolute.
+    # * `content` - the body contents of the file that you are writing
+    #
+    # #### Example
+    #
+    #   @ctx.write('new.txt', 'hello world')
+    #
+    def write(fname, content)
+      File.write(ctx_path(fname), content)
+    end
+
+    # will rename a file from one place to another, relative to the command root
+    # unless the path is absolute.
+    #
+    # #### Parameters
+    # * `from` - the path of the original file
+    # * `to` - the destination path
+    #
+    def rename(from, to)
+      File.rename(ctx_path(from), ctx_path(to))
+    end
+
+    # will remove a plain file from the FS, the filepath is relative to the command
+    # root unless absolute.
+    #
+    # #### Parameters
+    # * `fname` - the file path relative to the context root to remove from the FS
+    #
+    def rm(fname)
+      FileUtils.rm(ctx_path(fname))
+    end
+
+    # will remove a directory from the FS, the filepath is relative to the command
+    # root unless absolute
+    #
+    # #### Parameters
+    # * `fname` - the file path to a directory, relative to the context root to remove from the FS
+    #
+    def rm_r(fname)
+      FileUtils.rm_r(ctx_path(fname))
+    end
+
+    # will create a directory, recursively if it does not exist. So if you create
+    # a directory `foo/bar/dun`, this will also create the directories `foo` and
+    # `foo/bar` if they do not exist. The path will be made relative to the command
+    # root unless absolute
+    #
+    # #### Parameters
+    # * `path` - file path of the directory that you want to create
+    #
+    def mkdir_p(path)
+      FileUtils.mkdir_p(path)
+    end
+
+    # will output to the console a link for the user to either copy/paste
+    # or click on.
+    #
+    # #### Parameters
+    # * `uri` - a http URI to open in a browser
+    #
+    def open_url!(uri)
+      help = message('core.context.open_url', uri)
+      puts(help)
+    end
+
+    # will output a message, prefixed by a yellow star, indicating that task
+    # started.
+    #
+    # #### Parameters
+    # * `text` - a string message to output
+    #
+    def print_task(text)
+      puts "{{yellow:*}} #{text}"
+    end
+
+    # a wrapper around Kernel.puts to allow for easy formatting
+    #
+    # #### Parameters
+    # * `text` - a string message to output
+    #
+    def puts(*args)
+      Kernel.puts(CLI::UI.fmt(*args))
+    end
+
+    # outputs a message, prefixed by a checkmark indicating that something completed
+    #
+    # #### Parameters
+    # * `text` - a string message to output
+    #
+    def done(text)
+      puts("{{v}} #{text}")
+    end
+
+    # aborts the current running command and outputs an error message, prefixed
+    # by a red x
+    #
+    # #### Parameters
+    # * `text` - a string message to output
+    #
+    def abort(text)
+      raise ShopifyCli::Abort, "{{x}} #{text}"
+    end
+
+    # outputs a message, prefixed by a red `DEBUG` tag. This will only output to
+    # the console if you have `DEBUG=1` set in your shell environment.
+    #
+    # #### Parameters
+    # * `text` - a string message to output
+    #
+    def debug(text)
+      puts("{{red:DEBUG}} #{text}") if getenv('DEBUG')
+    end
+
+    # proxy call to Context.message.
+    #
+    # #### Parameters
+    # * `key` - a symbol representing the message
+    # * `params` - the parameters to format the string with
+    def message(key, *params)
+      Context.message(key, *params)
+    end
+
+    # will grab the host info of the computer running the cli. This indicates the
+    # computer architecture and operating system
+    def uname
+      @uname ||= RbConfig::CONFIG["host"]
+    end
+
+    # Execute a command in the user's environment
+    # Outputs result of the command without capturing it
+    #
+    # #### Parameters
+    # - `*args`: A splat of arguments evaluated as a command. (e.g. `'rm', folder` is equivalent to `rm #{folder}`)
+    # - `**kwargs`: additional keyword arguments to pass to Process.spawn
+    #
+    # #### Returns
+    # - `status`: boolean success status of the command execution
+    #
+    # #### Usage
+    #
+    #   stat = @ctx.system('ls', 'a_folder')
+    #
+    def system(*args, **kwargs)
+      CLI::Kit::System.system(*args, env: @env, **kwargs)
+    end
+
+    # Execute a command in the user's environment
+    # This is meant to be largely equivalent to backticks, only with the env passed in.
+    # Captures the results of the command without output to the console
+    #
+    # #### Parameters
+    # - `*args`: A splat of arguments evaluated as a command. (e.g. `'rm', folder` is equivalent to `rm #{folder}`)
+    # - `**kwargs`: additional arguments to pass to Open3.capture2
+    #
+    # #### Returns
+    # - `output`: output (STDOUT) of the command execution
+    # - `status`: boolean success status of the command execution
+    #
+    # #### Usage
+    #
+    #   out, stat = @ctx.capture2('ls', 'a_folder')
+    #
+    def capture2(*args, **kwargs)
+      CLI::Kit::System.capture2(*args, env: @env, **kwargs)
+    end
+
+    # Execute a command in the user's environment
+    # This is meant to be largely equivalent to backticks, only with the env passed in.
+    # Captures the results of the command without output to the console
+    #
+    # #### Parameters
+    # - `*args`: A splat of arguments evaluated as a command. (e.g. `'rm', folder` is equivalent to `rm #{folder}`)
+    # - `**kwargs`: additional arguments to pass to Open3.capture2e
+    #
+    # #### Returns
+    # - `output`: output (STDOUT merged with STDERR) of the command execution
+    # - `status`: boolean success status of the command execution
+    #
+    # #### Usage
+    #
+    #   out_and_err, stat = @ctx.capture2e('ls', 'a_folder')
+    #
+    def capture2e(*args, **kwargs)
+      CLI::Kit::System.capture2e(*args, env: @env, **kwargs)
+    end
+
+    # Execute a command in the user's environment
+    # This is meant to be largely equivalent to backticks, only with the env passed in.
+    # Captures the results of the command without output to the console
+    #
+    # #### Parameters
+    # - `*args`: A splat of arguments evaluated as a command. (e.g. `'rm', folder` is equivalent to `rm #{folder}`)
+    # - `**kwargs`: additional arguments to pass to Open3.capture3
+    #
+    # #### Returns
+    # - `output`: STDOUT of the command execution
+    # - `error`: STDERR of the command execution
+    # - `status`: boolean success status of the command execution
+    #
+    # #### Usage
+    #
+    #   out, err, stat = @ctx.capture3('ls', 'a_folder')
+    #
+    def capture3(*args, **kwargs)
+      CLI::Kit::System.capture3(*args, env: @env, **kwargs)
+    end
+
+    # captures the info signal (ctrl-T) and provide a handler to it.
+    #
+    # #### Example
+    #
+    #   @ctx.on_siginfo do
+    #     @ctx.open_url!("http://google.com")
+    #   end
+    #
+    def on_siginfo
+      # Reset any previous SIGINFO handling we had so the only action we take is the given block
+      trap('INFO', 'DEFAULT')
+
+      fork do
+        begin
+          r, w = IO.pipe
+          @signal = false
+          trap('SIGINFO') do
+            @signal = true
+            w.write(0)
+          end
+          while r.read(1)
+            next unless @signal
+            @signal = false
+            yield
+          end
+        rescue Interrupt
+          exit(0)
+        end
+      end
+    end
+
+    private
+
+    def ctx_path(fname)
+      require 'pathname'
+      if Pathname.new(fname).absolute?
+        fname
+      else
+        File.join(root, fname)
+      end
+    end
+  end
+end