release-gem 0.1.0 → 0.1.1

data/lib/release/gem/vcs_action.rb

@@ -0,0 +1,224 @@
+
+require 'gvcs'
+require 'git_cli'
+
+module Release
+  module Gem
+    module Action
+
+      class VcsActionError < StandardError; end
+      
+      class VcsAction
+        include TR::CondUtils
+
+        attr_accessor :ui
+
+        def initialize(root, opts = {  })
+          raise VcsActionError, "root cannot be null" if is_empty?(root)
+          @ws = Gvcs::Workspace.new(root) 
+
+          oopts = opts || {}
+          @ui = oopts[:ui]
+          @engine = oopts[:engine]
+          st, path = @ws.workspace_root
+
+          #@gitDir = File.join(path.strip,".git")
+          #p @gitDir
+          #@gitBack = File.join(path.strip,".git_bak")
+          #p @gitBack
+        end
+
+        #def enable_dev_mode
+        #  FileUtils.cp_r(@gitDir,@gitBack, remove_destination: true)
+        #end
+
+        #def dev_mode_end
+        #  if File.exist?(@gitBack)
+        #    FileUtils.mv(@gitBack, @gitDir)
+        #  end
+        #end
+
+        def exec(&block)
+          instance_eval(&block) if block
+        end
+
+        def commit(msg = nil, &block)
+
+          res = :value
+          if block
+
+            counter = 0
+            loop do
+
+              stgDir, stgFiles = @ws.staged_files
+              modDir, modFiles = @ws.modified_files
+              newDir, newFiles = @ws.new_files
+              delDir, delFiles = @ws.deleted_files
+
+              modFiles.delete_if { |f| stgFiles.include?(f) }
+              modDir.delete_if { |f| stgDir.include?(f) }
+
+              # block should call vcs for add, remove, ignore and other operations
+              res = block.call(:select_files_to_commit, { modified: { files: modFiles, dirs: modDir }, new: { files: newFiles, dirs: newDir }, deleted: { files: delFiles, dirs: delDir }, staged: { files: stgFiles, dirs: stgDir }, vcs: self, counter: counter } )
+
+              break if res == :skip or res == :done
+
+              counter += 1
+
+            end
+
+            if res == :done
+
+              stgDir, stgFiles = @ws.staged_files
+              block.call(:staged_elements_of_commit, { files: stgFiles, dirs: stgDir })
+
+              msg = block.call(:commit_message) if is_empty?(msg) 
+              raise VcsActionError, "Commit message is empty" if is_empty?(msg)
+
+              cp "Commit with user message : #{msg}"
+              st, res = @ws.commit(msg)
+              if st
+                block.call(:commit_successful, res) if block
+              else
+                block.call(:commit_failed, res) if block
+              end
+              [st, res]
+
+            end
+
+          else
+
+            msg = "Auto commit all ('-am' flag) by gem-release gem" if is_empty?(msg)
+            cp msg
+            # changed files only without new files
+            @ws.commit_all(msg)
+          end
+
+          res
+
+        end
+
+        def tag(*args, &block)
+        
+          opts = args.first || {  }
+          tag = opts[:tag]
+          msg = opts[:message]
+
+          if not @ws.tag_points_at?("HEAD")
+
+            if is_empty?(tag)
+              raise VcsActionError, "tag name cannot be empty" if not block
+              tag = block.call(:tag_name)
+              raise VcsActionError, "tag name cannot be empty" if is_empty?(tag)
+            end
+
+            if is_empty?(msg)
+              if block
+                msg = block.call(:tag_message)
+              end
+            end
+
+            cp "tagged with name : #{tag} and message : #{msg}"
+            st, res = @ws.create_tag(tag, msg)
+            if st
+              block.call(:tagging_success, res) if block
+            else
+              block.call(:tagging_failed, res) if block
+            end
+
+            [st, res]
+
+          else
+
+            block.call(:no_tagging_required) if block
+            [true, "No tagging required"]
+          end
+
+        end
+
+        def push(remote = nil, branch= nil, &block)
+         
+          remoteConf = @ws.remote_config
+          if is_empty?(remoteConf)
+            if block
+              remote = block.call(:no_remote_repos_defined)
+            end
+          else
+            if is_empty?(remote)
+              if block
+                remote = block.call(:select_remote, remoteConf)
+              else
+                remote = remoteConf.keys.first
+              end
+            end
+          end
+
+          raise VcsActionError, "Push repository remote cannot be empty" if is_empty?(remote)
+
+          if remote != :skip
+
+            branch = @ws.current_branch if is_empty?(branch)
+
+
+            if is_local_ahead_of_remote?("#{remote}/#{branch}", branch)
+
+              cp "pushing to #{remote}/#{branch}"
+              st, res = @ws.push_changes_with_tags(remote, branch)
+
+              if st
+                block.call(:push_successful, res) if block
+              else
+                block.call(:push_failed, res) if block
+              end
+
+              [st, res]
+
+            else
+              block.call(:no_changes_to_push, { remote: remote, branch: branch }) if block
+            end
+          end
+
+        end
+
+        def add_to_staging(*files)
+          @ws.add_to_staging(*files) 
+        end
+
+        def ignore(*files)
+          @ws.ignore(*files) 
+        end
+
+        def remove_from_staging(*files)
+          @ws.remove_from_staging(*files) 
+        end
+
+
+        private
+        def method_missing(mtd, *args, &block)
+          if @ws.respond_to?(mtd)
+            @ws.send(mtd, *args, &block)
+          else
+            if not @engine.nil? and @engine.respond_to?(mtd)
+              @engine.send(mtd, *args, &block)
+            else
+              super
+            end
+          end
+        end
+
+        def cp(msg)
+          Gem.cul(@ui, msg)
+        end
+        def ce(msg)
+          Gem.cue(@ui, msg)
+        end
+
+
+
+      end # class VcsAction
+
+    end # module Action
+
+  end # module Gem
+
+end # module Release

data/lib/release/gem/vcs_cli_action.rb

@@ -0,0 +1,228 @@
+
+
+require 'tty/prompt'
+require_relative 'vcs_action'
+
+module Release
+  module Gem
+    module Cli
+      class VcsAction
+        def initialize(root, opts = {  })
+          opts = {} if opts.nil?
+          opts[:ui] = TTY::Prompt.new
+          @inst = Action::VcsAction.new(root,opts)
+          @prmt = TTY::Prompt.new
+        end
+
+        def exec(&block)
+          instance_eval(&block) if block
+        end
+
+        def commit(*args, &block)
+          res = @inst.commit do |ops, *args|
+            
+            preset = false
+            if block
+              res = block.call(ops, *args)
+              if res.nil?
+                preset = true
+              else
+                res
+              end
+            else
+              preset = true
+            end
+
+            if preset
+
+              case ops
+              when :select_files_to_commit
+                mfiles = args.first
+                @prmt.puts "\n Files already added to staging : ".yellow
+                mfiles[:staged].each do |k,v|
+                  v.each do |vv|
+                    @prmt.puts " * #{vv}"
+                  end
+                end
+
+                @prmt.puts ""
+
+                sel = @prmt.multi_select "\n Following are files that could be added to version control : ".yellow do |m|
+
+                  [:modified, :new, :deleted].each do |cat|
+                    mfiles[cat].each do |k,v|
+                      v.each do |vv|
+                        m.choice vv, vv.path
+                      end
+                    end
+
+                  end
+
+                  m.choice "Skip", :skip if mfiles[:counter] == 0
+                  m.choice "Done", :done
+                  m.choice "Abort", :abort
+                end
+
+                if sel.include?(:abort)
+                  raise Release::Gem::Abort, "User aborted"
+                elsif sel.include?(:skip)
+                  :skip 
+                else
+                  res = :done if sel.include?(:done)
+                  s = sel.clone
+                  s.delete_if { |e| e == :done }
+                  if not_empty?(s)
+                    st, cres = add_to_staging(*s) if not_empty?(s)
+                    if st
+                      @prmt.puts "\n Files added successfully".green
+                    else
+                      @prmt.puts "\n Files failed to be added. Message was : #{cres}".red
+                    end
+                  end
+
+                  res
+
+                end
+
+              when :commit_message
+                msg = ""
+                loop do
+                  msg = @prmt.ask("\n Commit message : ".yellow, required: true)
+                  confirm = @prmt.yes?(" Commit message : #{msg}\n Proceed? No to provide a new commit message ".yellow)
+                  if confirm
+                    break
+                  end
+                end
+
+                msg
+
+              when :staged_elements_of_commit
+
+                elements = args.first
+                @prmt.puts "\n Following files/directories shall be committed in this session : ".yellow
+                elements.each do |k,v|
+                  v.each do |vv|
+                    @prmt.puts " * #{vv}"
+                  end
+                end
+
+              when :commit_successful
+                @prmt.puts "\n Changes committed".green
+
+              when :commit_failed
+                @prmt.puts "\n Changes failed to be committed. Error was : #{args.first}"
+
+              end
+            end
+          end # commit
+
+        end # Commit
+
+        def tag(*args, &block)
+        
+          @inst.tag(*args) do |ops, *args|
+
+            preset = false
+            if block
+              res = block.call(ops, *args)
+              if res.nil?
+                preset = true
+              else
+                res
+              end
+            else
+              preset = true
+            end
+
+            if preset
+
+              case ops
+              when :tag_message
+                @prmt.ask("\n Please provide message for the tag : ".yellow, value: "Auto tagging by gem-release gem during releasing version #{@selVer}", required: true)
+
+              when :tagging_success
+                @prmt.puts "\n Tagging of source code is successful.".green
+
+              when :tagging_failed
+                @prmt.puts "\n Tagging of source code failed. Error was : #{args.first}".red
+
+              when :no_tagging_required
+                @prmt.puts "\n No tagging required. Source head is the tagged item ".green
+
+              end
+            end # preset ?
+
+          end
+
+        end # tag
+
+        def push(*args, &block)
+
+          @inst.push do |ops, *args|
+            preset = false
+            if block
+              res = block.call(ops, *args)
+              if res.nil?
+                preset = true
+              else
+                res
+              end
+            else
+              preset = true
+            end
+
+            if preset
+
+              case ops
+              when :select_remote
+                val = args.first
+                sel = @prmt.select("\n Please select one of the remote config below : ") do |m|
+                  val.each do |k,v|
+                    m.choice k, k
+                  end
+                  m.choice "Skip pushing source code", :skip
+                  m.choice "Abort", :abort
+                end
+                raise Release::Gem::Abort, "User aborted" if sel == :abort
+
+                sel
+
+              when :no_remote_repos_defined
+                add = @prmt.yes?("\n No remote configuration defined. Add one now?")
+                if add
+                  name = @prmt.ask("\n Name of the repository : ", value: "origin", required: true)
+                  url = @prmt.ask("\n URL of the repository : ", required: true)
+
+                  st, res = add_remote(name, url)
+                  if st
+                    @prmt.puts "\n Remote configuration added successfully".green
+                    name
+                  else
+                    raise Release::Gem::Abort, "Failed to add remote configuration. Error was : #{res}"
+                  end
+                end
+
+              when :push_successful
+                @prmt.puts "\n Push success!".green
+
+              when :push_failed
+                @prmt.puts "\nPush failed. Error was : #{args.first}".red
+
+              when :no_changes_to_push
+                val = args.first
+                @prmt.puts "\n Local is in sync with remote (#{val[:remote]}/#{val[:branch]}). Push is not required. "
+              end
+            end
+
+          end
+
+        end # push
+
+        def method_missing(mtd, *args, &block)
+          @inst.send(mtd, *args, &block)
+        end
+
+      end
+    end
+  end
+end

data/lib/release/gem/version.rb

@@ -2,6 +2,6 @@
 
 module Release
   module Gem
-    VERSION = "0.1.0"
+    VERSION = "0.1.1"
   end
 end

data/tasks/standard.rake

@@ -0,0 +1,50 @@
+
+
+require_relative '../lib/release/gem'
+require 'tty/prompt'
+require 'colorize'
+
+namespace :gem do
+  desc "Release GEM standard workflow (gem-release gem)"
+  task :release do
+    # check for local flow
+    custom = Dir.glob(File.join(Dir.getwd, "*.relflow"))
+    if custom.length > 0
+      
+      pmt = TTY::Prompt.new
+     
+      begin
+        if custom.length > 1
+          sel = pmt.select("\n There are more than 1 release flow (*.relflow files) detected. Please select one for this session : ".yellow) do |m|
+            custom.each do |f|
+              m.choice f, f
+            end
+          end
+
+          require sel
+
+        else
+  
+          #require custom.first
+          load custom.first
+
+        end
+      rescue TTY::Reader::InputInterrupt => ex
+        pmt.puts "\n Aborted"
+      end
+    else
+      stdFlow = File.join(File.dirname(__FILE__),"..","templates","standard_cli_flow")
+      require stdFlow
+    end
+  end
+
+  desc "Copy the standard flow to project local so modification of the flow is possible"
+  task :customize_flow do
+    stdFlow = File.join(File.dirname(__FILE__),"..","templates","standard_cli_flow.rb")
+    dest = File.join(Dir.getwd, "custom_flow.relflow")
+    FileUtils.cp stdFlow, dest 
+    puts "\n Standard flow copied to #{dest}\n".green
+  end
+
+end
+

data/templates/standard_cli_flow.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+require 'release/gem'
+
+puts "\n Standard GEM CLI release flow version #{Release::Gem::VERSION}\n".yellow
+
+begin
+
+  Release::Gem.engine(:gem, root: Dir.getwd) do
+
+    # step 1 : run test
+    run_test(:rspec) 
+
+    gem_cli_action do
+
+      # step 2 : check dependency
+      release_dependencies
+
+      # step 3 : build the gem
+      st, ver = build
+      if st
+        # step 4, push the gem to rubygems
+        push(version: ver)
+        install(version: ver)
+      end
+
+    end # gem_cli_action
+
+    vcs_cli_action do
+      @selVer = value(:selected_version)
+
+      # step 6 : commit vcs
+      commit
+
+      # step 7 : tag the source code
+      tag( tag: @selVer )      
+
+      # step 8 : Push the source code
+      push
+
+    end # vcs_action block
+
+  end # Release::Gem::Engine block
+
+  puts "\n *** GEM standard release flow done!\n".green
+
+rescue Release::Gem::Abort => ex
+  STDERR.puts "\n -- Aborted by user. Message was : #{ex.message}\n".red
+rescue TTY::Reader::InputInterrupt => ex
+rescue Exception => ex
+  STDERR.puts "\n -- Error thrown. Message was : #{ex.message}".red
+end
+
+
+
+