picobox 0.1.7

data/lib/picobox/system.rb

@@ -0,0 +1,83 @@
+module Picobox
+  class System
+    include Utils::Visitable
+    include Utils::Output
+
+    attr_reader :os
+
+    def initialize(os)
+      @os = os
+    end
+
+    def install
+      accept(Commands::StartInstall.new)
+      accept(Commands::DownloadDocker.new)
+      accept(Commands::InstallDocker.new)
+      accept(Commands::SetupShell.new)
+      accept(Commands::FinishInstall.new)
+    rescue Errors::ShellNotSupported => e
+      display_shell_not_supported e.message
+      exit 1
+    rescue Exception => e
+      display_info(e, :red)
+      exit 1
+    end
+
+
+    def uninstall
+      accept(Commands::StartUninstall.new)
+      accept(Commands::RemoveSetupShell.new)
+      accept(Commands::FinishUninstall.new)
+    rescue Errors::PicoboxNotInstalled
+      display_picobox_not_installed
+      exit 1
+    rescue Exception => e
+      display_info(e, :red)
+      exit 1
+    end
+
+
+    def start
+      accept(Commands::Start.new)
+    rescue Errors::ProjectNotInitialized
+      display_project_not_initialized
+      exit 1
+    rescue Exception => e
+      display_info(e, :red)
+      exit 1
+    end
+
+
+    def stop
+      accept(Commands::Stop.new)
+    rescue Errors::ProjectNotInitialized
+      display_project_not_initialized
+      exit 1
+    rescue Exception => e
+      display_info(e, :red)
+      exit 1
+    end
+
+
+    def restart
+      accept(Commands::Restart.new)
+    rescue Exception => e
+      display_info(e, :red)
+      exit 1
+    end
+
+
+    def open_shell(service)
+      accept(Commands::OpenShell.new(service))
+    rescue Errors::SystemDownError
+      display_system_down
+      exit 1
+    rescue Errors::ProjectNotInitialized
+      display_project_not_initialized
+      exit 1
+    rescue Exception => e
+      display_info(e, :red)
+      exit 1
+    end
+  end
+end

data/lib/picobox/templates/shell_extensions.bash

@@ -0,0 +1,125 @@
+#!/bin/bash
+#
+# setup picobox proxies
+#
+
+###
+### settings
+###
+DEV="dev"
+TEST="test"
+##
+## functions
+##
+project_root() {
+  slashes=${PWD//[^\/]/}
+  directory="$PWD"
+  for (( n=${#slashes}; n>0; --n ))
+  do
+    test -e "$directory/.picobox" && echo "$directory/.picobox" && return
+    directory="$directory/.."
+  done
+}
+
+can_execute () {
+  if [ -e "$(project_root)/project.ini" ]; then
+    true
+  else
+    false
+  fi
+}
+
+picobox_proxy () {
+  if can_execute; then
+    docker-compose exec $1 $2 "${@:3}"
+  else
+    if [ "$ZSH_NAME" ]; then
+      `whence -p $2` "${@:3}"
+    else
+      `type -P $2` "${@:3}"
+    fi
+  fi
+}
+
+##
+## ruby proxies
+##
+picobox_gem ()    { picobox_proxy $DEV "gem" "$@" ; }
+picobox_rake ()   { picobox_proxy $DEV "rake" "$@" ; }
+picobox_bundle () { picobox_proxy $DEV "bundle" "$@" ; }
+picobox_irb()     { picobox_proxy $DEV "irb" "$@" ;}
+picobox_ruby()    { picobox_proxy $DEV "ruby" "$@" ;}
+
+alias gem=picobox_gem
+alias rake=picobox_rake
+alias bundle=picobox_bundle
+alias irb=picobox_irb
+alias ruby=picobox_ruby
+
+
+###
+## rails proxies
+##
+picobox_rails ()  { picobox_proxy $DEV "bundle exec rails" "$@" ; }
+picobox_spring () { picobox_proxy $DEV "bundle exec spring" "$@" ; }
+picobox_yarn () { picobox_proxy $DEV "bundle exec yarn" "$@" ; }
+picobox_webpack () { picobox_proxy $DEV "bundle exec webpack" "$@" ; }
+picobox_guard () { picobox_proxy $TEST "bundle exec guard" "$@" ; }
+picobox_rspec () { picobox_proxy $TEST "bundle exec rspec" "$@" ; }
+picobox_webpack_dev_server() { picobox_proxy "webpack" "bundle exec webpack-dev-server" "$@"; }
+picobox_webpack_watcher () { picobox_proxy "webpack" "bundle exec webpack-watcher" "$@" ; }
+
+alias rails=picobox_rails
+alias rspec=picobox_rspec
+alias spring=picobox_spring
+alias yarn=picobox_yarn
+alias webpack=picobox_webpack
+alias webpack-dev-server=picobox_webpack_dev_server
+alias webpack-watcher=picobox_webpack_watcher
+alias guard=picobox_guard
+
+##
+## redis proxies
+##
+picobox_redis_cli () { picobox_proxy "redis" "redis-cli" "$@" ; }
+
+alias redis-cli=picobox_redis_cli
+
+##
+## postgres proxies
+##
+picobox_psql () { picobox_proxy "postgres" "psql" "$@" ; }
+
+alias psql=picobox_psql
+
+##
+## mysql proxies
+##
+picobox_mysql () { picobox_proxy "mysql" "mysql" "$@" ; }
+
+alias psql=picobox_mysql
+
+
+##
+## elixir proxies
+##
+picobox_elixir() { picobox_proxy $DEV "elixir" "$@" ; }
+picobox_mix()    { picobox_proxy $DEV "mix" "$@" ; }
+picobox_iex()    { picobox_proxy $DEV "iex" "$@" ; }
+picobox_erl()    { picobox_proxy $DEV "erl" "$@" ; }
+
+alias elixir=picobox_elixir
+alias mix=picobox_mix
+alias iex=picobox_iex
+alias erl=picobox_erl
+
+
+##
+## python proxies
+##
+picobox_python() { picobox_proxy $DEV "python" "$@" ; }
+picobox_pip()    { picobox_proxy $DEV "pip" "$@" ; }
+
+alias python=picobox_python
+alias pip=picobox_pip
+

data/lib/picobox/utils/domain_event_publisher.rb

@@ -0,0 +1,11 @@
+module Picobox
+  module Utils
+    module DomainEventPublisher
+      include Wisper::Publisher
+
+      def publish_event(event_name, *event_params)
+        broadcast(event_name, *event_params)
+      end
+    end
+  end
+end

data/lib/picobox/utils/output.rb

@@ -0,0 +1,69 @@
+module Picobox
+  module Utils
+    module Output
+      def display_line(line)
+        thor.say line
+      end
+
+
+      def display_info(info, color=nil)
+        thor.say "  #{info}", color
+      end
+
+
+      def display_status(status, line, log_status=true)
+        return if line.nil? || line.strip == ""
+        thor.say_status status, line, log_status
+      end
+
+
+      def display_project_not_initialized
+        display_status('error', 'no project found', :red)
+        display_info("Run command in a project directory or create new project with 'picobox init [BOX]'", :green)
+      end
+
+
+      def display_box_not_available(type)
+        display_status('error', "#{type.capitalize} boxes are not available...yet", :red)
+      end
+
+
+      def display_service_not_available(type)
+        display_status('error', "#{type} service is not available...yet", :red)
+      end
+
+
+      def display_file_not_found(message)
+        display_status('error', message, :red)
+      end
+
+
+      def display_system_down
+        display_info("Picobox is not running!", :red)
+      end
+
+
+      def display_service_not_installed(type)
+        display_status('info', "#{type} not installed", :yellow)
+      end
+
+      def display_shell_not_supported(type)
+        display_status('error', "shell not supported #{type}", :red)
+        display_line ''
+
+        display_line "You can file a request at: #{Picobox::HOMEPAGE}"
+        display_line "and we'll get right on it!"
+        display_line ''
+      end
+
+      def display_picobox_not_installed
+        display_info "Picobox not installed!", :red
+      end
+
+      private
+      def thor
+        @thor ||= Thor::Shell::Color.new
+      end
+    end
+  end
+end

data/lib/picobox/utils/progress_bar.rb

@@ -0,0 +1,31 @@
+module Picobox
+  module Utils
+    class ProgressBar
+      class << self
+        def new(size)
+          @progress_bar = ::ProgressBar.create(
+            format:         "%b\u{15E7}%i %p%% %t",
+            progress_mark:  ' ',
+            remainder_mark: "\u{FF65}",
+            total:          size
+          )
+        end
+
+        def step(step)
+          @progress_bar.progress = step
+        end
+
+
+        def increment
+          @progress_bar.progress += 1
+        end
+
+        def reset()
+        end
+
+        private
+        attr_accessor :progress_bar
+      end
+    end
+  end
+end

data/lib/picobox/utils/project.rb

@@ -0,0 +1,55 @@
+module Picobox
+  module Utils
+    class Project
+      def initialize(os)
+        @os = os
+      end
+
+
+      def project_initialized?
+        return false if os.project_root.nil?
+        root   = os.project_root
+        target = os.current_dir
+
+        target[0...root.size] == root &&
+          (target.size == root.size || target[root.size] == ?/)
+      end
+
+
+      def root
+        find_root_from Pathname.new(os.current_dir)
+      end
+
+
+      def running?
+        result = %x[docker-compose ps]
+
+        result = result.split("\n")
+        result = result.select { |line| line.match /_dev|_test/  }
+        result = result.map { |line| line.split(' ')[2] }
+
+        result.uniq!
+
+        # There are no container stopped or started (all removed or first run)
+        return false if result.empty?
+
+        # Get the status and return the correct value
+        (result.include? 'Exit') ? false : true
+      end
+
+      private
+      attr_reader :os
+
+      def find_root_from(dir)
+        return nil if dir.root?
+
+        if Pathname.new("#{dir}/#{Picobox::CONFIG_DIR}/#{Picobox::PROJECT_INI}").exist?
+          return dir.to_s
+        else
+          dir, base = dir.split
+          find_root_from dir
+        end
+      end
+    end
+  end
+end

data/lib/picobox/utils/shell.rb

@@ -0,0 +1,18 @@
+module Picobox
+  module Utils
+    class Shell
+      def initialize(os)
+        @os = os
+      end
+
+
+      def reload
+        # hack to load newly set aliases into shell
+        os.reload_shell
+      end
+
+      private
+      attr_reader :os
+    end
+  end
+end

data/lib/picobox/utils/visitable.rb

@@ -0,0 +1,9 @@
+module Picobox
+  module Utils
+    module Visitable
+      def accept visitor
+        visitor.visit(self)
+      end
+    end
+  end
+end

data/lib/picobox/utils/visitor_by_os.rb

@@ -0,0 +1,29 @@
+module Picobox
+  module Utils
+    class VisitorByOs
+      include Utils::DomainEventPublisher
+
+      def visit subject
+        method_name = "visit_#{subject.os.to_s}".intern
+        send(method_name, subject )
+      end
+
+      def visit_darwin subject
+        raise ::NotImplementedError, 'mac not supported'
+      end
+
+      def visit_linux subject
+        raise ::NotImplementedError, 'linux not supported'
+      end
+
+      def visit_windows subject
+        raise ::NotImplementedError, 'windows not supported'
+      end
+
+      def visit_unsupported subject
+        os = TTY::Platform.new.os
+        raise Errors::UnsupportedOsError, "#{os} is not yet supported :("
+      end
+    end
+  end
+end

data/lib/runner.rb

@@ -0,0 +1,51 @@
+module Picobox
+  require 'picobox'
+
+  class Runner
+    # Allow everything fun to be injected from the outside while defaulting to normal implementations.
+    def initialize(argv, stdin = STDIN, stdout = STDOUT, stderr = STDERR, kernel = Kernel)
+      @argv, @stdin, @stdout, @stderr, @kernel = argv, stdin, stdout, stderr, kernel
+    end
+
+    def execute!
+      exit_code = begin
+        # Thor accesses these streams directly rather than letting them be injected, so we replace them...
+        $stderr = @stderr
+        $stdin = @stdin
+        $stdout = @stdout
+
+        # Let TTY::File know about the stdout switch
+        TTY::File.instance_variable_set :"@output", $stdout
+
+        # Run our normal Thor app the way we know and love.
+        Picobox::CLI.start(@argv)
+        # Thor::Base#start does not have a return value, assume success if no exception is raised.
+        0
+      rescue StandardError => e
+        # The ruby interpreter would pipe this to STDERR and exit 1 in the case of an unhandled exception
+        b = e.backtrace
+        @stderr.puts("#{b.shift}: #{e.message} (#{e.class})")
+        @stderr.puts(b.map{|s| "\tfrom #{s}"}.join("\n"))
+        1
+      rescue SystemExit => e
+        e.status
+      ensure
+        # TODO: reset your app here, free up resources, etc.
+        # Examples:
+        # MyApp.logger.flush
+        # MyApp.logger.close
+        # MyApp.logger = nil
+        #
+        # MyApp.reset_singleton_instance_variables
+
+        # ...then we put the streams back.
+        $stderr = STDERR
+        $stdin = STDIN
+        $stdout = STDOUT
+      end
+
+      # Proxy our exit code back to the injected kernel.
+      @kernel.exit(exit_code)
+    end
+  end
+end