interactive_s3 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 22a4ce5049308ee26440e48c45a0471bcbb6c55b
+  data.tar.gz: 19e81f547625f94a1af33cb8565d267f1be378cb
+SHA512:
+  metadata.gz: c2b434692269b5a03a1841494263344baf717b9d2e9ec4c063705aa89bd0f3cc3228bd9ce5a7a6f160fbef2c3c64861b81eeea4f8a3a4cd47df819484bf545c0
+  data.tar.gz: 12e44e37783b6fa98f7c169dad16548226c122d583ebe729f8c92f2e1402bd5b98fab9075d4fecdcc994b6e96c9b82950147e3b7a220fce5980d8b88aaedc5cd

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1
+  - 2.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in interactive_s3.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 yamayo
+
+MIT License
+
+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,61 @@
+# InteractiveS3 [![Build Status](https://travis-ci.org/yamayo/interactive_s3.svg?branch=master)](https://travis-ci.org/yamayo/interactive_s3)
+InteractiveS3 is an interactive shell that can be easily extended with commands using a `aws s3` in the [AWS Command Line Interface](http://docs.aws.amazon.com/cli/latest/index.html).
+
+## Requirements
+* Ruby (=> 2.0.0)
+* AWS CLI (~> 1.5.1)
+
+## Installation
+```sh
+$ gem install interactive_s3
+```
+
+## Usage
+
+### Start
+InteractiveS3 is run from the command line.
+
+```sh
+$ is3
+```
+
+### Available commands
+
+- **cd** - Change the current path.
+- **pwd** - Show the current path.
+- **lls** - Show local file list.
+- **exit** - Quit InteractiveS3.
+
+And `aws s3` commands.  
+
+### Examples
+
+```sh
+s3> ls
+2014-08-07 00:22:58 my-bucket
+s3> cd my-bucket
+s3://my-bucket> ls
+2014-08-11 00:23:56          4 .
+2014-08-20 01:31:34          5 foo
+s3://my-bucket> lls
+bar.txt
+```
+
+#### `:` - local file prefix
+
+```sh
+s3://my-bucket> cp :bar.txt .
+upload: ./bar.txt to s3://mybucket/bar.txt
+s3://my-bucket> ls
+2014-08-11 00:23:56          4 .
+2014-08-20 01:31:34          5 foo
+2014-10-19 22:37:43         31 bar.txt
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/interactive_s3/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/is3

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('../../lib', __FILE__)
+require 'interactive_s3'
+
+InteractiveS3::CLI.new.start

data/interactive_s3.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'interactive_s3/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "interactive_s3"
+  spec.version       = InteractiveS3::VERSION
+  spec.executables   = ["is3"]
+  spec.authors       = ["yamayo"]
+  spec.email         = ["noorthaven@gmail.com"]
+  spec.summary       = %q{An interactive shell for AWS CLI (aws s3)}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/interactive_s3.rb

@@ -0,0 +1,11 @@
+require 'interactive_s3/cli'
+require 'interactive_s3/command_builder'
+require 'interactive_s3/commands/base'
+require 'interactive_s3/commands/internal_command'
+require 'interactive_s3/commands/s3_command'
+require 'interactive_s3/errors'
+require 'interactive_s3/history'
+require 'interactive_s3/interpreter'
+require 'interactive_s3/s3'
+require 'interactive_s3/s3_path'
+require 'interactive_s3/version'

data/lib/interactive_s3/cli.rb

@@ -0,0 +1,49 @@
+require 'readline'
+
+module InteractiveS3
+  class CLI
+    def start
+      history.load
+      show_version
+      run
+    ensure
+      history.save
+    end
+
+    private
+
+    def run
+      while line = readline
+        next if line.empty?
+        interpreter.execute(line)
+      end
+      puts "\n"
+    rescue Interrupt
+      puts "\n"
+      retry
+    end
+
+    def readline
+      if line = Readline.readline(prompt, true)
+        Readline::HISTORY.pop if /^\s*$/ =~ line.strip
+      end
+      line
+    end
+
+    def show_version
+      puts "InteractiveS3 #{InteractiveS3::VERSION}"
+    end
+
+    def prompt
+      interpreter.root? ? 's3> ' : "#{interpreter.current_path}> "
+    end
+
+    def interpreter
+      @interpreter ||= Interpreter.new
+    end
+
+    def history
+      @history ||= History.new
+    end
+  end
+end

data/lib/interactive_s3/command_builder.rb

@@ -0,0 +1,20 @@
+module InteractiveS3
+  class CommandBuilder
+    def initialize(context, params)
+      @context = context
+      @name, *@arguments = params.split(/\s/)
+    end
+
+    def build
+      command_class.new(context, name, arguments)
+    end
+
+    private
+
+    attr_reader :context, :name, :arguments
+
+    def command_class
+      Commands::InternalCommand.fetch(name.to_sym, Commands::S3Command)
+    end
+  end
+end

data/lib/interactive_s3/commands/base.rb

@@ -0,0 +1,24 @@
+module InteractiveS3::Commands
+  class Base
+    attr_accessor :state, :arguments
+
+    attr_reader :s3, :name
+
+    def initialize(context, name, arguments = [])
+      @s3 = context.s3
+      @state = context.state
+      @name = name
+      @arguments = arguments
+    end
+
+    def execute
+      raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+    end
+
+    private
+
+    def argument_size
+      arguments.size
+    end
+  end
+end

data/lib/interactive_s3/commands/internal_command.rb

@@ -0,0 +1,62 @@
+module InteractiveS3::Commands
+  module InternalCommand
+    def self.fetch(name, default = nil)
+      COMMAND_CLASSES.fetch(name, default)
+    end
+
+    class Chdir < Base
+      def execute
+        state[:previous_stack] ||= []
+
+        if target.nil?
+          state[:previous_stack] = s3.stack
+          s3.reset
+          return
+        end
+
+        if target.strip == '-'
+          s3.stack, state[:previous_stack] = state[:previous_stack], s3.stack
+        else
+          target.sub!('s3://', '/')
+          state[:previous_stack] = s3.stack
+          s3.stack = InteractiveS3::S3Path.new(target, s3.stack).resolve
+        end
+      ensure
+        unless s3.exist?
+          s3.stack = state[:previous_stack]
+        end
+      end
+
+      private
+
+      def target
+        @target ||= arguments.first
+      end
+    end
+
+    class LocalList < Base
+      def execute
+        puts Dir.entries('.').delete_if {|file| file =~ /^(.|..)$/ }
+      end
+    end
+
+    class Pwd < Base
+      def execute
+        puts s3.root? ? '/' : s3.current_path
+      end
+    end
+
+    class Exit < Base
+      def execute
+        exit
+      end
+    end
+
+    COMMAND_CLASSES = {
+      cd: Chdir,
+      lls: LocalList,
+      pwd: Pwd,
+      exit: Exit,
+    }.freeze
+  end
+end

data/lib/interactive_s3/commands/s3_command.rb

@@ -0,0 +1,97 @@
+module InteractiveS3::Commands
+  class S3Command < Base
+    S3_PATH_PREFIX = /^s3:\/\//
+    LOCAL_PATH_PREFIX = /^:/
+    OPTION_PREFIX = /^--/
+    HELP_SUB_COMMAND = /^help$/
+    TARGET_SUB_COMMANDS = %w(mv rb rm).freeze
+
+    def initialize(context, name, arguments = [])
+      super
+      parse_arguments
+    end
+
+    def execute
+      pid = Process.spawn(
+        *command_with_arguments,
+        out: $stdout,
+        err: $stderr
+      )
+      wait_for_process(pid)
+      $? && $?.success?
+    rescue SystemCallError => e
+      puts e.message
+      false
+    ensure
+      if target_sub_command_and_s3_not_exist?
+        s3.reset
+      end
+    end
+
+    private
+
+    alias sub_command name
+
+    def parse_arguments
+      arguments[target] = arguments[target].map {|argument|
+        case argument
+        when S3_PATH_PREFIX, HELP_SUB_COMMAND, OPTION_PREFIX
+          argument
+        when LOCAL_PATH_PREFIX
+          argument.sub(LOCAL_PATH_PREFIX, '')
+        else
+          stack = InteractiveS3::S3Path.new(argument, s3.stack).resolve
+          "s3://#{stack.join('/')}"
+        end
+      }
+    end
+
+    def target
+      @target ||= if option_first?
+                    argument_size-2..argument_size-1
+                  else
+                    0..1
+                  end
+    end
+
+    def option_first?
+      !!(arguments.first =~ OPTION_PREFIX)
+    end
+
+    def command_with_arguments
+      arguments << "#{s3.current_path}/" if list_command_with_no_s3_path?
+      ['aws', 's3', sub_command, arguments].flatten
+    end
+
+    def list_command_with_no_s3_path?
+      list_command? && !help_sub_command? && !include_s3_path?
+    end
+
+    def list_command?
+      sub_command == 'ls'
+    end
+
+    def help_sub_command?
+      arguments.include?('help')
+    end
+
+    def include_s3_path?
+      arguments.any? {|argument| argument.match(S3_PATH_PREFIX) }
+    end
+
+    def target_sub_command?
+      TARGET_SUB_COMMANDS.include?(sub_command)
+    end
+
+    def target_sub_command_and_s3_not_exist?
+      target_sub_command? && !s3.exist?
+    end
+
+    def wait_for_process(pid)
+      Process.wait(pid)
+    rescue Interrupt
+      Process.kill('INT', pid)
+      retry
+    end
+  end
+end

data/lib/interactive_s3/errors.rb

@@ -0,0 +1,3 @@
+module InteractiveS3
+  class CommandError < StandardError; end
+end

data/lib/interactive_s3/history.rb

@@ -0,0 +1,32 @@
+module InteractiveS3
+  class History
+    HISTORY_FILE = "#{Dir.home}/.is3_history"
+    HISTORY_SIZE = 500
+
+    def load
+      if file_exist?
+        File.read(file_path).each_line do |line|
+          Readline::HISTORY << line.chomp
+        end
+      end
+    end
+
+    def save
+      File.write(file_path, Readline::HISTORY.to_a.last(history_size).join("\n"))
+    end
+
+    private
+
+    def file_exist?
+      File.exist?(file_path)
+    end
+
+    def file_path
+      HISTORY_FILE
+    end
+
+    def history_size
+      HISTORY_SIZE.to_i
+    end
+  end
+end

data/lib/interactive_s3/interpreter.rb

@@ -0,0 +1,28 @@
+require 'forwardable'
+
+module InteractiveS3
+  class Interpreter
+    extend Forwardable
+
+    attr_reader :s3, :state
+
+    def_delegators :s3, :current_path, :root?
+
+    def initialize
+      @s3 = S3.new
+      @state = {}
+    end
+
+    def execute(input)
+      build_command(input).execute
+    rescue CommandError => e
+      puts e.class, e.message, e.backtrace.join("\n")
+    end
+
+    private
+
+    def build_command(input)
+      CommandBuilder.new(self, input).build
+    end
+  end
+end

data/lib/interactive_s3/s3.rb

@@ -0,0 +1,34 @@
+require 'open3'
+
+module InteractiveS3
+  class S3
+    attr_accessor :stack
+
+    def initialize
+      @stack = []
+    end
+
+    def current_path
+      empty? ? '' : "s3://#{stack.join('/')}"
+    end
+
+    def empty?
+      stack.empty?
+    end
+    alias root? empty?
+
+    def reset
+      self.stack = []
+    end
+
+    def bucket?
+      stack.size == 1
+    end
+
+    def exist?
+      return true if root?
+      output, error, status = Open3.capture3('aws', 's3', 'ls', current_path)
+      status.success? && (bucket? || output != '')
+    end
+  end
+end

data/lib/interactive_s3/s3_path.rb

@@ -0,0 +1,40 @@
+module InteractiveS3
+  class S3Path
+    def initialize(target_path, current_stack)
+      @target_path = target_path
+      @current_stack = current_stack
+    end
+
+    def resolve
+      scanner = StringScanner.new(target_path.strip)
+      stack = current_stack.dup
+
+      begin
+        bol = scanner.bol?
+        segment = scanner.scan(/[^\/]*/)
+        scanner.getch
+
+        case segment.chomp
+        when ''
+          stack = [] if bol
+        when '.'
+          next
+        when '..'
+          stack.pop
+        else
+          stack << segment
+        end
+      rescue => e
+        raise CommandError.new(e).tap {|ex|
+          ex.set_backtrace(e.backtrace)
+        }
+      end until scanner.eos?
+
+      stack
+    end
+
+    private
+
+    attr_reader :current_stack, :target_path
+  end
+end

data/lib/interactive_s3/version.rb

@@ -0,0 +1,3 @@
+module InteractiveS3
+  VERSION = '0.0.2'
+end

data/spec/interactive_s3/command_builder_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe InteractiveS3::CommandBuilder do
+  let(:builder) { described_class.new(context, params) }
+  let(:context) { double('context') }
+
+  before do
+    allow(context).to receive(:s3)
+    allow(context).to receive(:state)
+  end
+
+  describe '#build' do
+    let(:command_class) { double('command_class') }
+    let(:params) { 'cd -' }
+
+    before do
+      allow(InteractiveS3::Commands::InternalCommand).to receive(:fetch) { command_class }
+    end
+
+    it 'creates a command class and initializes it' do
+      expect(command_class).to receive(:new).with(context, 'cd', ['-'])
+      builder.build
+    end
+  end
+end

data/spec/interactive_s3/commands/base_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe InteractiveS3::Commands::Base do
+  let(:context) { double('context') }
+  let(:name) { double('name') }
+
+  before do
+    allow(context).to receive(:s3)
+    allow(context).to receive(:state)
+  end
+
+  describe '#execute' do
+    context 'when implements the method' do
+      let(:instance) do
+        Class.new(described_class) {
+          def execute; end
+        }.new(context, name)
+      end
+
+      it { expect { instance.execute }.not_to raise_error }
+    end
+
+    context 'when does not implements the method' do
+      let(:instance) do
+        described_class.new(context, name)
+      end
+
+      it { expect { instance.execute }.to raise_error(NotImplementedError) }
+    end
+  end
+end

data/spec/interactive_s3/commands/internal_command_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe InteractiveS3::Commands::InternalCommand do
+  let(:context) { double('context') }
+  let(:s3) { InteractiveS3::S3.new }
+  let(:state) { {} }
+
+  before do
+    allow(context).to receive(:s3).and_return(s3)
+    allow(context).to receive(:state).and_return(state)
+  end
+
+  describe '.fetch' do
+    subject { described_class.fetch(name.to_sym, InteractiveS3::Commands::S3Command) }
+
+    context 'given the params `cd`' do
+      let(:name) { 'cd' }
+
+      it { is_expected.to be described_class::Chdir }
+    end
+
+    context 'given the params `pwd`' do
+      let(:name) { 'pwd' }
+
+      it { is_expected.to be described_class::Pwd }
+    end
+
+    context 'given the params `lls`' do
+      let(:name) { 'lls' }
+
+      it { is_expected.to be described_class::LocalList }
+    end
+
+    context 'given the params `exit`' do
+      let(:name) { 'exit' }
+
+      it { is_expected.to be described_class::Exit }
+    end
+
+    context 'given the params `ls`' do
+      let(:name) { 'ls' }
+
+      it { is_expected.to be InteractiveS3::Commands::S3Command }
+    end
+  end
+
+  describe described_class::Chdir do
+    describe '#execute' do
+      before do
+        allow(s3).to receive(:exist?).and_return(true)
+        s3.stack << 'mybucket' << 'foo' << 'bar'
+      end
+
+      let(:command) { described_class.new(context, 'cd', arguments) }
+
+      context 'target is nil' do
+        let(:arguments) { [] }
+
+        before { command.execute }
+
+        it { expect(s3.stack).to be_empty }
+        it { expect(state[:previous_stack]).to eq %w(mybucket foo bar) }
+      end
+
+      context 'target is `-`' do
+        let(:arguments) { ['-'] }
+
+        before do
+          state[:previous_stack] = %w(xxx yyy)
+          command.execute
+        end
+
+        it { expect(s3.stack).to eq %w(xxx yyy) }
+        it { expect(state[:previous_stack]).to eq %w(mybucket foo bar) }
+      end
+
+      context 'target is `xxx/yyy`' do
+        let(:arguments) { ['xxx', 'yyy'] }
+
+        before do
+          allow_any_instance_of(InteractiveS3::S3Path).to receive(:resolve).and_return(['foo'])
+          command.execute
+        end
+
+        it { expect(s3.stack).to eq %w(foo) }
+        it { expect(state[:previous_stack]).to eq %w(mybucket foo bar) }
+      end
+    end
+  end
+
+  describe described_class::LocalList do
+    describe '#execute' do
+      let(:command) { described_class.new(context, 'lls') }
+
+      before do
+        allow(Dir).to receive(:entries).with('.').and_return(['.', '..', 'foo', 'bar'])
+      end
+
+      it { expect { command.execute }.to output("foo\nbar\n").to_stdout }
+    end
+  end
+
+  describe described_class::Pwd do
+    describe '#execute' do
+      let(:command) { described_class.new(context, 'pwd') }
+
+      context 'when the s3 path is root' do
+        before do
+          allow(s3).to receive(:root?).and_return(true)
+        end
+
+        it { expect { command.execute }.to output("/\n").to_stdout }
+      end
+
+      context 'when the s3 path isn\'t root' do
+        before do
+          allow(s3).to receive(:root?).and_return(false)
+          allow(s3).to receive(:current_path).and_return("s3://mybucket/foo/bar")
+        end
+
+        it { expect { command.execute }.to output("s3://mybucket/foo/bar\n").to_stdout }
+      end
+    end
+  end
+
+  describe described_class::Exit do
+    describe '#execute' do
+      let(:command) { described_class.new(context, 'exit') }
+
+      it { expect { command.execute }.to raise_exception(SystemExit) }
+    end
+  end
+end

data/spec/interactive_s3/commands/s3_command_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe InteractiveS3::Commands::S3Command do
+  let(:s3_command) { described_class.new(context, name, arguments) }
+  let(:context) { double('context') }
+  let(:s3) { InteractiveS3::S3.new }
+  let(:state) { {} }
+
+  before do
+    allow(context).to receive(:s3).and_return(s3)
+    allow(context).to receive(:state).and_return(state)
+    allow(Process).to receive(:spawn)
+    allow(Process).to receive(:wait)
+    allow_any_instance_of(InteractiveS3::S3Path).to receive(:resolve).and_return(['mybucket', 'bar'])
+  end
+
+  shared_examples_for 'parses commands with arguments and executes it' do |command_with_arguments|
+    it do
+      expect(Process).to receive(:spawn).with(*command_with_arguments, out: $stdout, err: $stderr)
+      expect(s3_command.execute).to be_truthy
+    end
+  end
+
+  describe '#execute' do
+    context 'ls' do
+      let(:name) { 'ls' }
+
+      context 'with no sub command' do
+        let(:arguments) { [] }
+
+        it_behaves_like 'parses commands with arguments and executes it', ['aws', 's3', 'ls', '/']
+      end
+
+      context 'with help sub command' do
+        let(:arguments) { ['help'] }
+
+        it_behaves_like 'parses commands with arguments and executes it', ['aws', 's3', 'ls', 'help']
+      end
+    end
+
+    context 'cp' do
+      let(:name) { 'cp' }
+
+      context 'with local path and s3 path and option' do
+        let(:arguments) { [':foo', 'bar', '--option'] }
+
+        it_behaves_like 'parses commands with arguments and executes it', ['aws', 's3', 'cp', 'foo', 's3://mybucket/bar', '--option']
+      end
+
+      context 'with help sub command' do
+        let(:arguments) { ['help'] }
+
+        it_behaves_like 'parses commands with arguments and executes it', ['aws', 's3', 'cp', 'help']
+      end
+    end
+  end
+end

data/spec/interactive_s3/history_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'tempfile'
+
+describe InteractiveS3::History do
+  let(:history) { described_class.new }
+  let(:file) { Tempfile.new('history') }
+
+  before do
+    stub_const('Readline::HISTORY', [])
+    stub_const('InteractiveS3::History::HISTORY_FILE', file.path)
+  end
+
+  after do
+    file.delete
+  end
+
+  describe '#load' do
+    context 'when the file exists' do
+      before do
+        file.write("pwd\n")
+        file.write("ls\n")
+        file.rewind
+        history.load
+      end
+
+      it 'load into the Readline from the file' do
+        expect(Readline::HISTORY.to_a).to eq %w(pwd ls)
+      end
+    end
+
+    context 'when the file is empty' do
+      before { history.load }
+
+      it 'does not load into the Readline' do
+        expect(Readline::HISTORY.to_a).to be_empty
+      end
+    end
+  end
+
+  describe '#save' do
+    context 'when the file exists' do
+      before do
+        Readline::HISTORY << 'ls' << 'exit'
+        history.save
+      end
+
+      it 'saves the history from Readline to file' do
+        expect(file.each_line.to_a.each(&:chomp!)).to eq %w(ls exit)
+      end
+    end
+  end
+end

data/spec/interactive_s3/interpreter_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe InteractiveS3::Interpreter do
+  let(:interpreter) { described_class.new }
+  let(:input) { double('input') }
+  let(:command) { double('command') }
+
+  describe '#execute' do
+    before do
+      allow(InteractiveS3::CommandBuilder).to receive_message_chain(:new, :build) { command }
+    end
+
+    it 'build the command and executes it' do
+      expect(command).to receive(:execute)
+      interpreter.execute(input)
+    end
+
+    it 'handles command error' do
+      allow(command).to receive(:execute).and_raise(InteractiveS3::CommandError)
+      expect { interpreter.execute(input) }.to output.to_stdout
+    end
+  end
+end

data/spec/interactive_s3/s3_path_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe InteractiveS3::S3Path do
+  describe '#resolve' do
+    subject { described_class.new(path, stack).resolve }
+
+    let(:stack) { ['foo', 'bar'] }
+
+    context 'with path is `baz`' do
+      let(:path) { 'baz' }
+
+      it { is_expected.to eq %w(foo bar baz) }
+    end
+
+    context 'with path is `baz/qux`' do
+      let(:path) { 'baz/qux' }
+
+      it { is_expected.to eq %w(foo bar baz qux) }
+    end
+
+    context 'with path is `../..`' do
+      let(:path) { '../..' }
+
+      it { is_expected.to be_empty }
+    end
+
+    context 'with path is empty' do
+      let(:path) { '' }
+
+      it { is_expected.to be_empty }
+    end
+
+    context 'with path is `./baz`' do
+      let(:path) { './baz' }
+
+      it { is_expected.to eq %w(foo bar baz) }
+    end
+  end
+end

data/spec/interactive_s3/s3_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe InteractiveS3::S3 do
+  let(:s3) { described_class.new }
+
+  def stack_to_s3
+    s3.stack << 'mybucket' << 'foo' << 'bar'
+  end
+
+  describe '#current_path' do
+    context 'when the stack exists' do
+      before { stack_to_s3 }
+
+      it { expect(s3.current_path).to eq('s3://mybucket/foo/bar') }
+    end
+
+    context 'when the stack does not exists' do
+      it { expect(s3.current_path).to be_empty }
+    end
+  end
+
+  describe '#empty?' do
+    context 'when the stack exists' do
+      before { stack_to_s3 }
+
+      it { expect(s3.empty?).to be_falsey }
+    end
+
+    context 'when the stack does not exists' do
+      it { expect(s3.empty?).to be_truthy }
+    end
+  end
+
+  describe '#reset' do
+    before do
+      stack_to_s3
+      s3.reset
+    end
+
+    it { expect(s3.stack).to be_empty }
+  end
+
+  describe '#bucket?' do
+    context 'when size of the stack is 1' do
+      before { s3.stack << 'mybucket' }
+
+      it { expect(s3.bucket?).to be_truthy }
+    end
+
+    context 'when size of the stack is greater than 1' do
+      before { stack_to_s3 }
+
+      it { expect(s3.bucket?).to be_falsey }
+    end
+
+    context 'when the stack does not exists' do
+      it { expect(s3.bucket?).to be_falsey }
+    end
+  end
+
+  describe '#exist?' do
+    subject { s3.exist? }
+
+    context 'when the s3 path is root' do
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when the s3 path isn\'t root' do
+      let(:error) { double('error') }
+      let(:status) { double('status') }
+
+      before do
+        allow(Open3).to receive(:capture3).and_return([output, error, status])
+        allow(s3).to receive(:root?).and_return(false)
+      end
+
+      context 'status is success and output exists' do
+        let(:output) { 'output' }
+
+        before do
+          allow(status).to receive(:success?).and_return(true)
+        end
+
+        it { is_expected.to be_truthy }
+      end
+
+      context 'status is success and output does not exists' do
+        let(:output) { '' }
+
+        before do
+          allow(status).to receive(:success?).and_return(true)
+        end
+
+        it { is_expected.to be_falsey }
+      end
+
+      context 'status is success and current_path is bucket and output exists' do
+        let(:output) { '' }
+
+        before do
+          allow(status).to receive(:success?).and_return(true)
+          allow(s3).to receive(:bucket?).and_return(true)
+        end
+
+        it { is_expected.to be_truthy }
+      end
+
+      context 'status is not success' do
+        before do
+          allow(status).to receive(:success?).and_return(false)
+        end
+
+        it { is_expected.to be_falsey }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'interactive_s3'

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: interactive_s3
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- yamayo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- noorthaven@gmail.com
+executables:
+- is3
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/is3
+- interactive_s3.gemspec
+- lib/interactive_s3.rb
+- lib/interactive_s3/cli.rb
+- lib/interactive_s3/command_builder.rb
+- lib/interactive_s3/commands/base.rb
+- lib/interactive_s3/commands/internal_command.rb
+- lib/interactive_s3/commands/s3_command.rb
+- lib/interactive_s3/errors.rb
+- lib/interactive_s3/history.rb
+- lib/interactive_s3/interpreter.rb
+- lib/interactive_s3/s3.rb
+- lib/interactive_s3/s3_path.rb
+- lib/interactive_s3/version.rb
+- spec/interactive_s3/command_builder_spec.rb
+- spec/interactive_s3/commands/base_spec.rb
+- spec/interactive_s3/commands/internal_command_spec.rb
+- spec/interactive_s3/commands/s3_command_spec.rb
+- spec/interactive_s3/history_spec.rb
+- spec/interactive_s3/interpreter_spec.rb
+- spec/interactive_s3/s3_path_spec.rb
+- spec/interactive_s3/s3_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: An interactive shell for AWS CLI (aws s3)
+test_files:
+- spec/interactive_s3/command_builder_spec.rb
+- spec/interactive_s3/commands/base_spec.rb
+- spec/interactive_s3/commands/internal_command_spec.rb
+- spec/interactive_s3/commands/s3_command_spec.rb
+- spec/interactive_s3/history_spec.rb
+- spec/interactive_s3/interpreter_spec.rb
+- spec/interactive_s3/s3_path_spec.rb
+- spec/interactive_s3/s3_spec.rb
+- spec/spec_helper.rb