docker_rails_proxy 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3347b8edebbf4f84fcacd12e36816f0727902b68
-  data.tar.gz: 385331e600909f99227598f7b37428020e6ed878
+  metadata.gz: c565af80fd33cee75c95b7ada9c8c7bdb42f0bf0
+  data.tar.gz: 288e91970419af210886a50ab0d78cbd95a3f203
 SHA512:
-  metadata.gz: d6387a4ae7ddd92c832863bdb959286b837032364b21a57ae9b01a7365af3090a0b267685a0427a6b7297ca234c77ee7e4c6125dfd275f8b5d24ee35bc3b3f03
-  data.tar.gz: 9b0f92fc9ec121ccec5fd1f51cd65cca384c904b163cff3e4e32f10755f361aaf3977bf688ac6733a4e26f2e67c8d1f6c9d51c16cc390bc2676b805ccec23224
+  metadata.gz: 4bb58cfef7d4fbf1e344b61c32117323e5730dd879938bf1d10033abb408e8a3e029a833235474d55a0166b61ac1750ff073102246568080ee9437e17b24c45c
+  data.tar.gz: 216df1896cb8ac1fbdef8994c87f50a863e710ef49ef660144ac30eb0f980d2822279332c8855593706b3fdf134abe56e1da681cc542303e7a068bc559c3194d

data/lib/docker_rails_proxy/cli.rb

@@ -0,0 +1,37 @@
+module DockerRailsProxy
+  class Cli
+    class << self
+      def invoke(arguments)
+        command, *args = arguments
+
+        if command.nil?
+          $stderr.puts <<-EOF
+          #{"bin/#{APP_NAME} requires 1 argument.".bold}
+
+          #{"Usage: bin/#{APP_NAME} <command> [<args>]".bold}
+          EOF
+          exit 1
+        end
+
+        if COMMANDS.include? command
+          args << '-h' if args.empty?
+          "DockerRailsProxy::#{command}".constantize.(arguments: args)
+        else
+          $stderr.puts <<-EOS
+          #{'No such command'.yellow}
+
+          #{'COMMANDS'.bold}
+          EOS
+
+          COMMANDS.each do |script|
+            $stderr.puts <<-EOS
+            #{script.parameterize.bold} [<args>]
+            EOS
+          end
+
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/docker_rails_proxy/commands/build.rb

@@ -0,0 +1,77 @@
+require 'optparse'
+
+module DockerRailsProxy
+  class Build < Docker
+    attr_accessor :options
+
+    after_initialize { self.options = {} }
+    after_initialize :parse_options!
+
+    validates do
+      if options[:dockerfile].nil?
+        '--dockerfile is required'
+      elsif !File.exist?(options[:dockerfile])
+        "#{options[:dockerfile]} dockerfile does not exist."
+      end
+    end
+
+    validates { '--tag is required' if options[:tag].nil? }
+
+    validates do
+      options[:build_args] ||= {}
+
+      args = File.readlines(options[:dockerfile]).map do |line|
+        /^ARG/ =~ line ? line.split(' ').last : nil
+      end.compact
+
+      missings = args.select { |arg| options[:build_args][arg].nil? }.compact
+
+      (options[:build_args].keys - args).each { |k| options[:build_args].delete k }
+
+      missings.map { |a| "#{a} is required" }.join(', ') unless missings.empty?
+    end
+
+    def process
+      system <<-EOS
+        docker build \
+          -f '#{options[:dockerfile]}' \
+          -t '#{options[:tag]}' \
+          #{build_args} \
+          '#{APP_PATH}'
+      EOS
+    end
+
+  private
+
+    def build_args
+      options[:build_args].map do |k, v|
+        "--build-arg #{k.upcase}='#{v.strip}'"
+      end.join(' ')
+    end
+
+    def parse_options!
+      opt_parser.parse!(arguments)
+    end
+
+    def opt_parser
+      @opt_parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: bin/#{APP_NAME} build [options]"
+
+        opts.on('--dockerfile DOCKERFILE', 'Dockerfile') do |dockerfile|
+          options[:dockerfile] = dockerfile
+        end
+
+        opts.on('--tag TAG', 'Docker Image Tag') { |tag| options[:tag] = tag }
+
+        opts.on('--build-args A=val,B=val...', Array, 'Docker build-args') do |o|
+          options[:build_args] = Hash[o.map { |s| s.split('=', 2) }]
+        end
+
+        opts.on('-h', '--help', 'Display this screen') do
+          puts opts
+          exit
+        end
+      end
+    end
+  end
+end

data/lib/docker_rails_proxy/commands/bundle.rb

@@ -0,0 +1,8 @@
+module DockerRailsProxy
+  class Bundle < SyncBack
+    def process
+      command, *args = arguments
+      system "docker exec -it #{APP_NAME} bundle #{command} #{args.join(' ')}"
+    end
+  end
+end

data/lib/docker_rails_proxy/commands/compose/down.rb

@@ -0,0 +1,15 @@
+module DockerRailsProxy
+  class Compose < Docker
+    class Down < self
+      def process
+        containers = %x(
+          docker-compose ps | grep '#{APP_NAME}' | awk '{print $1}' | xargs
+        ).strip.split(' ')
+
+        system "docker stop #{containers.join(' ')}"
+        system "docker rm -v #{containers.join(' ')}"
+        system 'docker-compose down'
+      end
+    end
+  end
+end

data/lib/docker_rails_proxy/commands/compose/override.rb

@@ -0,0 +1,20 @@
+module DockerRailsProxy
+  class Compose < Docker
+    class Override < self
+      OVERRIDE_PATH = build_path('docker-compose.override.yml')
+      OVERRIDE_FILE = <<EOS.freeze
+version: "2"
+services:
+  app:
+    volumes:
+      - #{build_path(".data-bags/certs/localhost.#{APP_NAME}/cert.crt:/certs/cert.crt")}
+      - #{build_path(".data-bags/certs/localhost.#{APP_NAME}/cert.key:/certs/cert.key")}
+EOS
+
+      def process
+        File.write(OVERRIDE_PATH, OVERRIDE_FILE)
+        puts "#{OVERRIDE_PATH} was created"
+      end
+    end
+  end
+end

data/lib/docker_rails_proxy/commands/compose/proxy.rb

@@ -0,0 +1,10 @@
+module DockerRailsProxy
+  class Compose < Docker
+    class Proxy < self
+      def process
+        command, *args = arguments
+        system "docker-compose #{command} #{args.join(' ')}"
+      end
+    end
+  end
+end

data/lib/docker_rails_proxy/commands/compose/up.rb

@@ -0,0 +1,131 @@
+require 'pty'
+require 'optparse'
+
+module DockerRailsProxy
+  class Compose < Docker
+    class Up < self
+      FSWATCH_CMD = <<-EOS.strip.freeze
+        fswatch -r -0 \
+          --latency=0.1 \
+          --exclude '.git' \
+          --exclude '4913' \
+          "#{APP_PATH}" "#{GEMS_PATH}" | xargs -0 -n1 -I{} echo {}
+      EOS
+
+      EIO_ERROR = %(
+        Errno:EIO error, but this probably just means that the process
+        has finished giving output
+      ).freeze
+
+      attr_accessor :branch_name, :stopping, :options, :from_scratch
+
+      alias_method :stopping?, :stopping
+      alias_method :from_scratch?, :from_scratch
+
+      before_initialize do
+        unless system 'type fswatch &> /dev/null'
+          'fswatch is required, `brew install fswatch`'
+        end
+      end
+
+      after_initialize { self.options = {} }
+      after_initialize { self.branch_name = current_branch }
+
+      after_initialize :parse_options!, :set_defaults
+
+      before_process do
+        self.from_scratch = %x(docker-compose ps | grep -c #{APP_NAME}).to_i.zero?
+      end
+
+      after_process { fswatch_start }
+
+      def process
+        system 'docker-compose up -d'
+        sync_app_and_gems_folders
+        run_bundle_install if options[:bundle]
+        seed if from_scratch?
+      end
+
+    private
+
+      def seed
+        system <<-EOS.strip.freeze
+          docker exec #{APP_NAME} bin/rake db:drop db:create db:migrate db:seed
+        EOS
+      end
+
+      def sync_app_and_gems_folders
+        rsync_app
+        sync source: GEMS_PATH
+      end
+
+      def rsync_app
+        loop do
+          break if sync(source: APP_PATH)
+          puts "waiting for rsync-volume service on #{rsync_host}"
+          sleep 2
+        end
+      end
+
+      def fswatch_start
+        PTY.spawn(FSWATCH_CMD) do |stdout, stdin, pid|
+          begin
+            stdout.each { |path| sync_or_kill(path: path, pid: pid) }
+          rescue Errno::EIO
+            $stderr.puts EIO_ERROR
+          end
+        end
+      rescue PTY::ChildExited
+        $stderr.puts '"The fswatch process exited!'
+      end
+
+      def sync_or_kill(path:, pid:)
+        return if stopping?
+
+        if branch_name == (branch = current_branch)
+          sync source: path
+        else
+          $stderr.puts %(
+          `git checkout #{branch}` was detected, stopping fswatch
+          Previous branch was '#{branch_name}'
+          )
+          Process.kill(9, pid)
+          self.stopping = true
+        end
+      end
+
+      def current_branch
+        %x(git rev-parse --abbrev-ref HEAD).strip
+      end
+
+      # since new gems may have been added, we need bundle install
+      def run_bundle_install
+        system "docker exec #{APP_NAME} bundle install"
+      end
+
+      def parse_options!
+        opt_parser.parse!(arguments)
+      end
+
+      def set_defaults
+        options[:bundle] = true if options[:bundle].nil?
+      end
+
+      def opt_parser
+        @opt_parser ||= OptionParser.new do |opts|
+          opts.banner = "Usage: bin/#{APP_NAME} compose up [options]"
+
+          opts.on(
+            '--[no-]bundle',
+            'Run bundle install in all related containers'
+          ) { |bundle| options[:bundle] = bundle }
+
+          opts.on('-h', '--help', 'Display this screen') do
+            puts opts
+            exit
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docker_rails_proxy/commands/compose.rb

@@ -0,0 +1,18 @@
+module DockerRailsProxy
+  class Compose < Docker
+    autoload :Down,     'docker_rails_proxy/commands/compose/down'
+    autoload :Override, 'docker_rails_proxy/commands/compose/override'
+    autoload :Proxy,    'docker_rails_proxy/commands/compose/proxy'
+    autoload :Up,       'docker_rails_proxy/commands/compose/up'
+
+    builds -> (params:) do
+      case params[:arguments].first
+      when 'down'     then Down
+      when 'override' then Override
+      when 'up'       then Up
+      else
+        Proxy
+      end
+    end
+  end
+end

data/lib/docker_rails_proxy/commands/data_bags.rb

@@ -0,0 +1,91 @@
+require 'optparse'
+
+module DockerRailsProxy
+  class DataBags < AwsCli
+    attr_accessor :options
+
+    after_initialize { self.options = {} }
+    after_initialize :parse_options!, :set_defaults
+
+    before_process :set_folder_and_bucket
+
+    validates { '--profile is required.' if options[:profile].nil? }
+    validates { '--bucket is required.'  if options[:bucket].nil?  }
+
+    def process
+      case arguments.first
+      when 'pull' then pull
+      when 'push' then push
+      else
+        opt_parser.parse %w(-h)
+      end
+    end
+
+  private
+
+    def pull
+      if system <<-EOS.strip
+        aws s3 sync '#{options[:bucket]}' '#{options[:folder]}' \
+          --delete \
+          --exact-timestamps \
+          --profile '#{options[:profile]}'
+      EOS
+
+        puts "Data bags pulled from #{options[:bucket]} to #{options[:folder]}"
+      end
+    end
+
+    def push
+      puts "#{options[:bucket]} will be synced with #{options[:folder]}, are you sure?: [yes]"
+      confirm = $stdin.gets.chomp
+
+      exit unless confirm == 'yes'
+
+      if system <<-EOS
+        aws s3 sync '#{options[:folder]}' '#{options[:bucket]}' \
+          --delete \
+          --exact-timestamps \
+          --profile '#{options[:profile]}' \
+          --sse aws:kms
+      EOS
+
+        puts "Data bags pushed from #{options[:folder]} to #{options[:bucket]}"
+      end
+    end
+
+    def set_defaults
+      options[:profile] ||= APP_NAME
+      options[:bucket]  ||= "#{APP_NAME}-data-bags"
+    end
+
+    def set_folder_and_bucket
+      options[:folder] = build_path('.data-bags')
+      options[:bucket] = "s3://#{options[:bucket]}"
+    end
+
+    def parse_options!
+      opt_parser.parse!(arguments)
+    end
+
+    def opt_parser
+      @opt_parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: bin/#{APP_NAME} data-bags <pull|push> [options]"
+
+        opts.on(
+          '--profile [PROFILE]',
+          "Aws profile (Default: #{APP_NAME})"
+        ) { |profile| options[:profile] = profile }
+
+        opts.on(
+          '--bucket [BUCKET]',
+          "AWS S3 Data bags bucket (Default: #{APP_NAME}-data-bags)"
+        ) { |bucket| options[:bucket] = bucket }
+
+        opts.on('-h', '--help', 'Display this screen') do
+          puts opts
+          exit
+        end
+      end
+    end
+  end
+end

data/lib/docker_rails_proxy/commands/rails.rb

@@ -0,0 +1,39 @@
+module DockerRailsProxy
+  class Rails < SyncBack
+    def process
+      command, *args = arguments
+
+      case command
+      when 'c',  'console'    then console args
+      when 'db', 'dbconsole'  then db args
+      when 'logs'             then logs args
+      when 'restart', 'touch' then restart
+      else
+        system "docker exec -it #{APP_NAME} bin/rails #{command} #{args.join(' ')}"
+      end
+    end
+
+  private
+
+    def console(args)
+      exec "docker exec -it #{APP_NAME} bin/rails c #{args.join(' ')}"
+    end
+
+    def db(args)
+      exec <<-EOS
+        docker exec -it #{APP_NAME}_db \
+          mysql #{args.first || "#{APP_NAME}_development"}
+      EOS
+    end
+
+    def logs(args)
+      exec <<-EOS
+        docker exec #{APP_NAME} tail -f log/#{args.first || 'development'}.log
+      EOS
+    end
+
+    def restart
+      exec "docker exec #{APP_NAME} touch tmp/restart.txt"
+    end
+  end
+end

data/lib/docker_rails_proxy/commands/rake.rb

@@ -0,0 +1,8 @@
+module DockerRailsProxy
+  class Rake < SyncBack
+    def process
+      command, *args = arguments
+      system "docker exec -it #{APP_NAME} bin/rake #{command} #{args.join(' ')}"
+    end
+  end
+end

data/lib/docker_rails_proxy/commands/rspec.rb

@@ -0,0 +1,8 @@
+module DockerRailsProxy
+  class Rspec < SyncBack
+    def process
+      command, *args = arguments
+      system "docker exec #{APP_NAME} bin/rspec #{command} #{args.join(' ')}"
+    end
+  end
+end

data/lib/docker_rails_proxy/commands/spring.rb

@@ -0,0 +1,8 @@
+module DockerRailsProxy
+  class Spring < DockerMainApp
+    def process
+      command, *args = arguments
+      system "docker exec #{APP_NAME} bin/spring #{command} #{args.join(' ')}"
+    end
+  end
+end

data/lib/docker_rails_proxy/commands/ssh.rb

@@ -0,0 +1,29 @@
+require 'optparse'
+
+module DockerRailsProxy
+  class Ssh < DockerMainApp
+    def process
+      command, *args = arguments
+
+      case command
+      when '-h', '--help'
+        opt_parser.parse %w(-h)
+      else
+        system "docker exec -it #{APP_NAME} #{command} #{args.join(' ')}"
+      end
+    end
+
+  private
+
+    def opt_parser
+      @opt_parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: bin/#{APP_NAME} ssh COMMAND [options]"
+
+        opts.on('-h', '--help', 'Display this screen') do
+          puts opts
+          exit
+        end
+      end
+    end
+  end
+end

data/lib/docker_rails_proxy/concerns/callbacks.rb

@@ -0,0 +1,115 @@
+module DockerRailsProxy
+  module Callbacks
+    INHERITABLE_CALLBACKS = %w(
+      _before_initialize
+      _after_initialize
+      _validates
+      _before_process
+      _after_process
+    ).freeze
+
+    UNINHERITABLE_CALLBACKS = %w(
+      _builds
+    ).freeze
+
+    def self.included(base)
+      base.extend(ClassMethods)
+
+      INHERITABLE_CALLBACKS.each do |callback|
+        base.inheritable_attributes callback.to_sym
+        base.send "#{callback}=", []
+      end
+
+      UNINHERITABLE_CALLBACKS.each do |callback|
+        base.uninheritable_attributes callback.to_sym
+      end
+    end
+
+    module ClassMethods
+    private
+
+      INHERITABLE_CALLBACKS.each do |type|
+        define_method(type.sub('_', '').to_sym) do |*callbacks, &block|
+          _add_callbacks type: type, callbacks: callbacks, &block
+        end
+      end
+
+      UNINHERITABLE_CALLBACKS.each do |type|
+        define_method(type.sub('_', '').to_sym) do |*callbacks, &block|
+          send("#{type}=", []) if send(type).nil?
+          _add_callbacks type: type, callbacks: callbacks, &block
+        end
+      end
+
+      def _add_callbacks(type:, callbacks:, &block)
+        callbacks.each { |c| send(type) << _make_lambda(callback: c) }
+        send(type) << _make_lambda(callback: block) if block_given?
+        send type
+      end
+
+      def _make_lambda(callback:)
+        case callback
+        when Symbol
+          -> (resource, *rest) { resource.send(callback, *rest) }
+        when ::Proc
+          if callback.arity <= 0
+            -> (resource) { resource.instance_exec(&callback) }
+          else
+            -> (resource, *rest) do
+              if rest.empty?
+                resource.instance_exec(resource, &callback)
+              else
+                resource.instance_exec(*rest, &callback)
+              end
+            end
+          end
+        else
+          -> (*) {}
+        end
+      end
+
+      def _run_before_initialize_callbacks
+        Array(_before_initialize).each do |callback|
+          if (result = callback.call(self)).is_a? String
+            $stderr.puts %(
+              #{result}
+            )
+            exit 1
+          end
+        end
+      end
+
+      def _run_after_initialize_callbacks(resource:)
+        Array(_after_initialize).each { |c| c.call(resource) }
+      end
+
+      def _run_validation_callbacks(resource:)
+        Array(_validates).each do |callback|
+          if (result = callback.call(resource)).is_a? String
+            $stderr.puts %(
+              #{result}
+            )
+            exit 1
+          end
+        end
+      end
+
+      def _run_before_process_callbacks(resource:)
+        Array(_before_process).each { |c| c.call(resource) }
+      end
+
+      def _run_after_process_callbacks(resource:)
+        Array(_after_process).each { |c| c.call(resource) }
+      end
+
+      def _run_build_callbacks(params:)
+        Array(_builds).each do |callback|
+          result = callback.call(self, params: params)
+          return result if result.is_a?(Class)
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/docker_rails_proxy/concerns/inheritable_attributes.rb

@@ -0,0 +1,46 @@
+module DockerRailsProxy
+  module InheritableAttributes
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def inheritable_attributes(*args)
+        @inheritable_attributes ||= [:inheritable_attributes]
+        @inheritable_attributes += args
+        args.each do |arg|
+          class_eval %(class << self; attr_accessor :#{arg} end)
+        end
+        @inheritable_attributes
+      end
+
+      def uninheritable_attributes(*args)
+        @uninheritable_attributes ||= [:uninheritable_attributes]
+        @uninheritable_attributes += args
+        args.each do |arg|
+          class_eval %(class << self; attr_accessor :#{arg} end)
+        end
+        @uninheritable_attributes
+      end
+
+      def inherited(subclass)
+        @inheritable_attributes.each do |inheritable_attribute|
+          instance_name  = "@#{inheritable_attribute}"
+          instance_value = instance_variable_get(instance_name).dup
+          subclass.instance_variable_set(instance_name, instance_value)
+        end
+
+        @uninheritable_attributes.each do |uninheritable_attribute|
+          instance_name = "@#{uninheritable_attribute}"
+
+          if instance_name == '@uninheritable_attributes'
+            instance_value = instance_variable_get(instance_name).dup
+            subclass.instance_variable_set(instance_name, instance_value)
+          else
+            subclass.instance_variable_set(instance_name, nil)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docker_rails_proxy/concerns/rsync.rb

@@ -0,0 +1,91 @@
+module DockerRailsProxy
+  module Rsync
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+    end
+
+    def sync(source:, reverse: false, silent: false)
+      _rsync.sync source: source, reverse: reverse, silent: silent
+    end
+
+  private
+
+    def _rsync_host
+      @_rsync_host ||= begin
+        "rsync://#{ENV['DOCKER_HOST'].to_s.sub('tcp://', '').sub(/:\d+$/, '')}:10873"
+      end
+    end
+
+    def _rsync
+      @_rsync ||= Sync.new(rsync_host: _rsync_host)
+    end
+
+    class Sync
+      attr_reader :rsync_host
+
+      def initialize(rsync_host:)
+        @rsync_host = rsync_host
+      end
+
+      def self.call(rsync_host:, **options)
+        new(rsync_host: rsync_host).sync(options)
+      end
+
+      def sync(options)
+        source, target, volume = normalize_options(options)
+
+        result = send "sync_#{volume}", source: source, target: target
+
+        if result && options[:silent].eql?(false)
+          puts "#{source}   =======>   #{target}"
+        end
+
+        result
+      end
+
+    private
+
+      def normalize_options(source:, reverse: false, **)
+        values = if source.include? APP_PATH
+                   ["#{APP_PATH}/", 'app']
+                 elsif source.include? GEMS_PATH
+                   ["#{GEMS_PATH}/", 'gems']
+                 else
+                   $stderr.puts "There is no rsync volume related with this path: #{source}"
+                   exit 1
+                 end
+
+        paths = [values.first, "#{rsync_host}/#{values.last}"]
+
+        [paths.send(reverse ? :reverse : :to_a), values.last].flatten
+      end
+
+      def sync_app(source:, target:)
+        system <<-EOS
+        rsync -avqP --no-owner --no-group \
+          --exclude 'tmp/cache' \
+          --exclude 'tmp/letter_opener' \
+          --exclude 'tmp/pids' \
+          --exclude 'log' \
+          --exclude '.git*' \
+          --force \
+          --delete \
+          #{source} #{target}
+        EOS
+      end
+
+      def sync_gems(source:, target:)
+        system <<-EOS
+        rsync -avqP --no-owner --no-group \
+          --exclude '.git*' \
+          --force \
+          --delete \
+          #{source} #{target}
+        EOS
+      end
+    end
+  end
+end

data/lib/docker_rails_proxy/extends/colorization.rb

@@ -0,0 +1,36 @@
+class String
+  def red
+    colorize(31)
+  end
+
+  def green
+    colorize(32)
+  end
+
+  def yellow
+    colorize(33)
+  end
+
+  def blue
+    colorize(34)
+  end
+
+  def pink
+    colorize(35)
+  end
+
+  def light_blue
+    colorize(36)
+  end
+
+  def bold
+    "\033[1m#{self}\033[0m"
+  end
+
+private
+
+  # colorization
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+end

data/lib/docker_rails_proxy/extends/string_support.rb

@@ -0,0 +1,21 @@
+class String
+  def parameterize(separator = '-'.freeze)
+    downcase.gsub(/\W/, separator).gsub('_'.freeze, separator)
+  end
+
+  def classify
+    gsub(/\W/, ''.freeze)
+      .gsub('_'.freeze, ''.freeze)
+      .sub(/^[a-z\d]*/, &:capitalize)
+  end
+
+  def constantize
+    split('::'.freeze).inject(Object) do |constant, name|
+      constant.const_get(name.classify)
+    end
+  end
+
+  def underscore
+    downcase.gsub('::'.freeze, '/'.freeze).gsub('-'.freeze, '_'.freeze)
+  end
+end

data/lib/docker_rails_proxy/version.rb

@@ -0,0 +1,3 @@
+module DockerRailsProxy
+  VERSION = '0.0.1'
+end

data/lib/docker_rails_proxy.rb

@@ -1,2 +1,105 @@
+require 'docker_rails_proxy/extends/colorization'
+require 'docker_rails_proxy/extends/string_support'
+
 module DockerRailsProxy
+  COMMANDS = Dir[File.expand_path('../docker_rails_proxy/commands/*.rb', __FILE__)].map do |f|
+    File.basename(f, '.rb').parameterize
+  end.freeze
+
+  COMMANDS.each do |c|
+    autoload c.classify.to_sym, "docker_rails_proxy/commands/#{c.underscore}"
+  end
+
+  autoload :InheritableAttributes, 'docker_rails_proxy/concerns/inheritable_attributes'
+  autoload :Callbacks,             'docker_rails_proxy/concerns/callbacks'
+  autoload :Rsync,                 'docker_rails_proxy/concerns/rsync'
+
+  autoload :Cli,     'docker_rails_proxy/cli'
+  autoload :VERSION, 'docker_rails_proxy/version'
+
+  class Base
+    include InheritableAttributes
+    include Callbacks
+    include Rsync
+
+    attr_reader :arguments
+
+    def initialize(arguments:)
+      @arguments = arguments
+    end
+
+    class << self
+      def build_path(path = nil)
+        File.join(APP_PATH, block_given? ? yield : path)
+      end
+
+      def call(options)
+        klass = _run_build_callbacks params: options
+
+        klass.send :_run_before_initialize_callbacks
+
+        resource = klass.new(options)
+
+        klass.send :_run_after_initialize_callbacks, resource: resource
+
+        klass.send :_run_validation_callbacks, resource: resource
+
+        klass.send :_run_before_process_callbacks, resource: resource
+
+        result = resource.process
+
+        klass.send :_run_after_process_callbacks, resource: resource
+        result
+      end
+    end
+
+    def process
+      raise NotImplementedError, 'Subclasses must implement a process method'
+    end
+
+  private
+
+    def build_path(*args, &block)
+      self.class.build_path(*args, &block)
+    end
+  end
+
+  class AwsCli < Base
+    before_initialize do
+      unless system 'type aws &> /dev/null'
+        'aws is required, `brew install awscli`'
+      end
+    end
+  end
+
+  class Docker < Base
+    before_initialize do
+      if ENV['DOCKER_HOST'].nil?
+        %(
+        Couldn't connect to Docker daemon you might need to run:
+          docker-machine start default
+          eval $(docker-machine env default)
+        )
+      end
+    end
+  end
+
+  class DockerMainApp < Docker
+    before_initialize do
+      unless system "docker ps | grep '#{APP_NAME}$' &> /dev/null"
+        %(
+        Couldn't connect to #{APP_NAME} container you might need to run:
+          bin/#{APP_NAME} compose up
+        )
+      end
+    end
+
+    # Makes sure the container is in sync with the APP_PATH
+    before_process { sync source: APP_PATH, silent: true }
+  end
+
+  class SyncBack < DockerMainApp
+    after_process { system "docker exec #{APP_NAME} chown -R nobody:nogroup ." }
+    after_process { sync source: APP_PATH, reverse: true }
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: docker_rails_proxy
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - Jairo
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-27 00:00:00.000000000 Z
+date: 2016-09-30 00:00:00.000000000 Z
 dependencies: []
 description: Configures docker-compose and provides rails command helpers
 email:
@@ -22,6 +22,26 @@ files:
 - MIT-LICENSE
 - README.md
 - lib/docker_rails_proxy.rb
+- lib/docker_rails_proxy/cli.rb
+- lib/docker_rails_proxy/commands/build.rb
+- lib/docker_rails_proxy/commands/bundle.rb
+- lib/docker_rails_proxy/commands/compose.rb
+- lib/docker_rails_proxy/commands/compose/down.rb
+- lib/docker_rails_proxy/commands/compose/override.rb
+- lib/docker_rails_proxy/commands/compose/proxy.rb
+- lib/docker_rails_proxy/commands/compose/up.rb
+- lib/docker_rails_proxy/commands/data_bags.rb
+- lib/docker_rails_proxy/commands/rails.rb
+- lib/docker_rails_proxy/commands/rake.rb
+- lib/docker_rails_proxy/commands/rspec.rb
+- lib/docker_rails_proxy/commands/spring.rb
+- lib/docker_rails_proxy/commands/ssh.rb
+- lib/docker_rails_proxy/concerns/callbacks.rb
+- lib/docker_rails_proxy/concerns/inheritable_attributes.rb
+- lib/docker_rails_proxy/concerns/rsync.rb
+- lib/docker_rails_proxy/extends/colorization.rb
+- lib/docker_rails_proxy/extends/string_support.rb
+- lib/docker_rails_proxy/version.rb
 homepage: https://github.com/jairovm/docker_rails_proxy
 licenses:
 - MIT