appril-cli 0.1.1 → 0.2.0

data/lib/appril-cli/docker/build.rb

@@ -1,22 +1,27 @@
 module Appril
   class CLI
-    module Docker
+    class Docker
 
-      class Build
+      class Build < self
 
-        def initialize dir, update_runner_only: false, push_opted: false
-          Dir.chdir dir do
+        def initialize path, update_runner_only: false, push_opted: false
+          src, dst = paths(path)
 
-            config = load_config
+          assert_directory_exists(dst)
+          assert_config_file_exists(dst)
+
+          Dir.chdir dst do
+
+            config = load_config()
             validate_config(config)
 
-            build_dir = Pathname.new(File.expand_path('__tmpbuildir__'))
+            build_dir = dst / '__tmpbuildir__'
 
             prepare_build_dir(build_dir)
 
             install_files(build_dir)
 
-            app_dir = Pathname.new(File.expand_path(config['APP_DIR']))
+            app_dir = dst / config['APP_DIR']
 
             if update_runner_only
               puts "Skipping image building"
@@ -49,8 +54,7 @@ module Appril
             'RUN_SCRIPT' => :validate_config__run_script,
           }.each_pair do |key,validator|
             next if send(validator, config[key])
-            puts "", "\t::: Please set #{key} in config.yml :::", ""
-            exit 1
+            fatal_error!("Please set #{key} in config.yml")
           end
         end
 
@@ -70,46 +74,46 @@ module Appril
           !value.nil? && !value.empty?
         end
 
-        def prepare_build_dir dir
-          FileUtils.rm_rf(dir)
-          FileUtils.mkdir_p(dir / 'build')
+        def prepare_build_dir path
+          FileUtils.rm_rf(path)
+          FileUtils.mkdir_p(path / 'build')
         end
 
-        def install_files dir
-          install_dockerfile(dir)
-          install_start_file(dir)
-          install_build_files(dir)
-          install_cleanup_file(dir)
+        def install_files path
+          install_dockerfile(path)
+          install_start_file(path)
+          install_build_files(path)
+          install_cleanup_file(path)
         end
 
-        def install_dockerfile dir
-          FileUtils.cp(DOCKER_DIR / 'Dockerfile', dir)
+        def install_dockerfile path
+          FileUtils.cp(DOCKER_DIR / 'Dockerfile', path)
         end
 
-        def install_start_file dir
-          File.open dir / 'start', 'w' do |f|
+        def install_start_file path
+          File.open path / 'start', 'w' do |f|
             f << File.read(DOCKER_DIR / 'start').sub('{start}', File.read(START_FILE))
           end
         end
 
-        def install_build_files dir
-          FileUtils.cp(PREPARE_BUILD_FILE, dir / 'build')
-          FileUtils.cp(BUILD_FILE, dir / 'build/build')
+        def install_build_files path
+          FileUtils.cp(PREPARE_BUILD_FILE, path / 'build')
+          FileUtils.cp(BUILD_FILE, path / 'build/build')
         end
 
-        def install_cleanup_file dir
-          FileUtils.cp(CLEANUP_FILE, dir / 'build/cleanup')
+        def install_cleanup_file path
+          FileUtils.cp(CLEANUP_FILE, path / 'build/cleanup')
         end
 
-        def prepare_build dir, app_dir
-          Dir.chdir dir / 'build' do
+        def prepare_build path, app_dir
+          Dir.chdir path / 'build' do
             CLI.run "APP_DIR=#{app_dir} #{PREPARE_BUILD_FILE}"
             exit 1 unless $? && $?.success?
           end
         end
 
-        def build_image dir, image_name, build_opts
-          CLI.run "docker build -t #{image_name} #{build_opts} '#{dir}'"
+        def build_image path, image_name, build_opts
+          CLI.run "docker build -t #{image_name} #{build_opts} '#{path}'"
           $? && $?.success?
         end
 
@@ -146,7 +150,7 @@ module Appril
         end
 
       end
-      
+
     end
   end
 end

data/lib/appril-cli/docker/install.rb

@@ -1,23 +1,30 @@
 module Appril
   class CLI
-    module Docker
+    class Docker
 
-      class Install
-        include Helpers
+      class Install < self
 
-        def initialize dir, working_dir_opted: false
-          install(dir, working_dir_opted)
-          make_executable(dir / PREPARE_BUILD_FILE)
-          puts "Done. All files installed into #{dir}"
+        def initialize path
+          src, dst = paths(path)
+
+          install(src, dst)
+          post_install(dst)
+
+          puts "Done. All files installed into #{dst}"
         end
 
-        def install dir, working_dir_opted
-          src = working_dir_opted ? DOCKER_DIR.to_path + '/skel/.' : DOCKER_DIR / 'skel'
-          FileUtils.cp_r(src, dir)
+        def install src, dst
+          create_dirname_for(dst)
+          assert_directory_does_not_exists(dst)
+          FileUtils.cp_r(src, dst)
+        end
+
+        def post_install dst
+          make_executable(dst / PREPARE_BUILD_FILE)
         end
 
       end
-      
+
     end
   end
 end

data/lib/appril-cli/docker/update.rb

@@ -1,26 +1,35 @@
 module Appril
   class CLI
-    module Docker
+    class Docker
 
-      class Update
-        include Helpers
+      class Update < self
 
-        def initialize dir
-          Dir.chdir DOCKER_DIR / 'skel' do
+        def initialize path
+          src, dst = paths(path)
 
+          Dir.chdir src do
             Dir['**/*'].select {|e| File.file?(e)}.each do |file|
-              next if File.file?(dir / file)
-              create_dirname_for(dir / file)
-              puts "Installing #{File.basename(dir)}/#{file}"
-              FileUtils.cp(file, dir / file)
+              update_file(file, dst)
             end
-
           end
+
+          post_update(dst)
           puts "Done"
         end
 
+        private
+        def update_file file, dst
+          return if File.file?(dst / file)
+          create_dirname_for(dst / file)
+          puts "Updating #{File.basename(dst)}/#{file}"
+          FileUtils.cp(file, dst / file)
+        end
+
+        def post_update dst
+          make_executable(dst / PREPARE_BUILD_FILE)
+        end
       end
-      
+
     end
   end
 end

data/lib/appril-cli/docker.rb

@@ -1,61 +1,32 @@
 module Appril
   class CLI
-    module Docker
+    class Docker
+      include Helpers
+      include Assertions
 
-      DOCKER_DIR = BASE_DIR / 'docker'
-      
       CONFIG_FILE = './config.yml'.freeze
       START_FILE  = './start.sh'.freeze
       PREPARE_BUILD_FILE = './prepare_build.sh'.freeze
       BUILD_FILE = './build.sh'.freeze
       CLEANUP_FILE = './cleanup.sh'.freeze
 
-      def docker args
-        opted_dir = args[2]
-        assert_directory_provided(opted_dir)
-        dir = expanded_path(opted_dir)
-
-        case instruction = args[1]
-        when 'i', 'install'
-
-          docker_install(dir, working_dir_opted: working_dir_opted?(opted_dir))
-
-        when 'b', 'build'
-
-          docker_build(dir, {
-            update_runner_only: args.find {|a| a == '-u'},
-            push_opted: args.find {|a| a == '-p'}
-          })
-
-        when 'u', 'update'
-
-          docker_update(dir)
-
+      def paths path
+        if path == WORKING_DIR
+          [
+            DOCKER_DIR.to_path + '/skel/.',
+            path / 'docker'
+          ]
         else
-          unknown_instruction_error!(instruction, 'install (or i)', 'build (or b)', 'update (or u)')
+          [
+            DOCKER_DIR / 'skel',
+            path
+          ]
         end
       end
-
-      def docker_install dir, opts
-        create_dirname_for(dir)
-        assert_installable_dir(dir, opts[:working_dir_opted])
-        Docker::Install.new(dir, opts)
-      end
-
-      def docker_build dir, opts
-        assert_directory_exists(dir)
-        assert_config_file_exists(dir)
-        Docker::Build.new(dir, opts)
-      end
-
-      def docker_update dir
-        assert_is_docker_dir(dir)
-        Docker::Update.new(dir)
-      end
     end
   end
 end
 
 require 'appril-cli/docker/install'
-require 'appril-cli/docker/build'
 require 'appril-cli/docker/update'
+require 'appril-cli/docker/build'

data/lib/appril-cli/helpers.rb

@@ -2,13 +2,15 @@ module Appril
   class CLI
     module Helpers
 
-      def display_error error
-        puts "", "\t::: #{error} :::", ""
+      def format_error *lines
+        lines.flatten!
+        header = lines.shift()
+        "\t::: %s :::%s" % [header, lines.any? ? ([''] + lines).join("\n\t") : ""]
       end
 
-      def fatal_error! error, exit_code = 1
-        display_error(error)
-        exit exit_code
+      def fatal_error! *lines
+        puts '', format_error(lines), ''
+        exit 1
       end
 
       def expanded_path *path
@@ -23,10 +25,6 @@ module Appril
         entries.flatten.each {|e| FileUtils.chmod('+x', e)}
       end
 
-      def working_dir_opted? opted_dir
-        opted_dir == '.'
-      end
-
       def extract_namespace args
         return unless index = args.index('-n')
         return unless namespace = args[index + 1]

data/lib/appril-cli/install.rb

@@ -0,0 +1,30 @@
+module Appril
+  class CLI
+
+    class Install
+      include Helpers
+
+      def initialize path
+        install(path)
+        post_install(path)
+        puts "Done. All files installed into #{path}"
+      end
+
+      private
+      def install path
+        src = path == WORKING_DIR ? APP_DIR.to_path + '/.' : APP_DIR
+        FileUtils.cp_r(src, path)
+      end
+
+      def post_install path
+        make_executable(path / 'core/generate_configs.rb')
+        cleanup(path)
+      end
+
+      def cleanup path
+        Dir["#{path}/**/.ignore"].each {|f| FileUtils.rm_f(f)}
+      end
+
+    end
+  end
+end

data/lib/appril-cli/update.rb

@@ -0,0 +1,34 @@
+module Appril
+  class CLI
+
+    class Update
+      include Helpers
+
+      def initialize path
+        FileUtils.rm_rf(path / 'core')
+
+        Dir.chdir APP_DIR do
+          Dir['**/*'].select {|e| File.file?(e)}.each do |file|
+            update_file(path, file)
+          end
+        end
+
+        post_update(path)
+        puts "Done"
+      end
+
+      private
+      def update_file path, file
+        return if File.file?(path / file)
+        create_dirname_for(path / file)
+        puts "Updating #{File.basename(path)}/#{file}"
+        FileUtils.cp(file, path / file)
+      end
+
+      def post_update path
+        make_executable(path / 'core/generate_configs.rb')
+      end
+
+    end
+  end
+end

data/lib/appril-cli/version.rb

@@ -1,5 +1,5 @@
 module Appril
   class CLI
-    VERSION = '0.1.1'.freeze
+    VERSION = '0.2.0'.freeze
   end
 end

data/lib/appril-cli.rb

@@ -5,98 +5,113 @@ require 'pty'
 
 module Appril
   class CLI
+
     BASE_DIR = Pathname.new(File.expand_path('../..', __FILE__))
-    BOILERPLATE_DIR = BASE_DIR / 'boilerplate'
+    APP_DIR = BASE_DIR / 'app'
+    DOCKER_DIR = BASE_DIR / 'docker'
+    WORKING_DIR = Pathname.new(Dir.pwd)
+
+    def self.run cmd
+      puts "", "$ #{cmd}"
+      PTY.spawn cmd do |r, w, pid|
+        begin
+          r.sync
+          r.each_char do |char|
+            print(char)
+          end
+        rescue Errno::EIO => e
+          # simply ignoring this
+        ensure
+          Process.wait(pid)
+        end
+      end
+    end
   end
 end
 
 require 'appril-cli/version'
 require 'appril-cli/helpers'
 require 'appril-cli/assertions'
-require 'appril-cli/app'
-require 'appril-cli/generator'
+require 'appril-cli/install'
+require 'appril-cli/update'
 require 'appril-cli/docker'
 
 module Appril
   class CLI
-
     include Helpers
-    include Assertions
-    include Docker
-    include App
-    include Generator
 
     def initialize args
+      opts, args = args.partition {|a| a =~ /\A\-/}
+
       case command = args[0]
-      when 'a', 'app'
-        app(args)
-      when 'g', 'gen', 'generate'
-        generator(args)
+      when 'i', 'install'
+        Install.new(Pathname.new(args[1] || WORKING_DIR))
+
+      when 'u', 'update'
+        Update.new(Pathname.new(args[1] || WORKING_DIR))
+
+
       when 'd', 'docker'
-        docker(args)
-      when 'v', '-v', '--version'
+        path = Pathname.new(args[2] || WORKING_DIR)
+
+        case subcommand = args[1]
+        when 'i', 'install'
+          Docker::Install.new(path)
+
+        when 'u', 'update'
+          Docker::Update.new(path)
+
+        when 'b', 'build'
+          Docker::Build.new(path, {
+            update_runner_only: opts.include?('-u'),
+            push_opted: opts.include?('-p')
+          })
+        else
+          puts format_error("Unknown subcommand #{subcommand}")
+          usage
+        end
+      when '-v', '--version'
         puts VERSION
       when nil, '-h', '--help'
         usage
       else
-        display_error "Unknown command #{command}"
+        puts format_error("Unknown command #{command}")
         usage
       end
     end
 
-
     def usage
       puts "
       Arguments in round brackets are required.
       Arguments in square brackets are optional.
 
+      All operations accepts a path as last argument.
+      If no path given current folder will be used.
+
 
       === Install a new app ===
-      $ appril (app || a) (install || i) (dir || .) [-crudle]
-      * If -crudle option provided it will install a Crudle app
+      $ appril (install || i) [path]
 
       === Update existing app ===
-      $ appril (app || a) (update || u) (dir || .)
-
-      === Generate a new API ===
-      $ appril (generate || g) (api) (api name) (dir || .)
+      $ appril (update || u) [path]
 
       === Install Docker builder ===
-      $ appril (docker || d) (install || i) (dir || .)
+      $ appril (docker || d) (install || i) [path]
 
       === Update Docker builder ===
-      $ appril (docker || d) (update || u) (dir || .)
+      $ appril (docker || d) (update || u) [path]
 
       === Build Docker image and install run script ===
-      $ appril (docker || d) (build || b) (dir || .) [-u] [-p]
+      $ appril (docker || d) (build || b) [path] [-u] [-p]
       * If -u option provided it will only update the run script without building the image.
       * If -p option provided it will try to push the image to Docker registry after successful build.
 
       === Usage ===
       $ appril [-h || --help]
-      ".split("\n").map {|l| "\t" + l.strip}.join("\n")
-    end
-
-
-    def unknown_instruction_error! instruction, *available_instructions
-      fatal_error! "Unknown instruction #{instruction}. Use one of #{available_instructions*', '}"
-    end
-
 
-    def self.run cmd
-      puts "", "$ #{cmd}"
-      PTY.spawn cmd do |r, w, pid|
-        begin
-          r.sync
-          r.each_char do |char|
-            print(char)
-          end
-        rescue Errno::EIO => e
-          # simply ignoring this
-        ensure
-          Process.wait(pid)
-        end
-      end
+      === Version ===
+      $ appril [-v || --version]
+      ".split("\n").map {|l| "\t" + l.strip}.join("\n")
     end
   end
 end