release-gem 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed5f60168ae7d89802f6c0f5a18ff62bb055a66aef8ba9af2c87c6f10ecba99a
-  data.tar.gz: dd3c409579297a14c397fb3e874a7da49856544b05a687727e4ae4f74f1be6e7
+  metadata.gz: ee50e97b208bc323892b6e5ed4af3812fd19cf1955241884d6700c94b03cdb24
+  data.tar.gz: 23b84aa1dea610e1e60bcced74fb15af3ae070e2f74f72b27427e9967e555ced
 SHA512:
-  metadata.gz: 40e7a44d4694335fed765e3d96caffbbfd1d1b1a130f2ea9b8eec35268394b0d2eb4427c112b9e8fd369b05de9505f9c8d0765616bf4fc197733644b2bcd3db0
-  data.tar.gz: cd3679b3878d822c8f4b1768f4ceafaa6fa7274030f928660ccdef78a438dd509f92d6234b93a3cfcdc8d537acce188e5e5b6517bfa69e27e7c94e453f8cb04d
+  metadata.gz: 2538c22c29d80482cdbb781e45b0570f3bd837075aea1fcb5833a242b494cf8e0aeb3383caaaf7e1d675486193b2406fb89dd316a424afc3e64c4bcb15cd84de
+  data.tar.gz: 61dd98175626747dbf74e800aa60842061029bf783695d4e28a0e21124d154fc2ae2e318afd19cebd8a4272695fcc2b6d8ca87ace8f3a9e0c50a61b17c904f0f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    release-gem (0.1.8)
+    release-gem (0.1.10)
       colorize
       git_cli
       gvcs

data/lib/release/gem/vcs_action.rb

@@ -42,11 +42,10 @@ module Release
           instance_eval(&block) if block
         end
 
-        def overview_changes(&block)
-
-          res = :done
+        def add(&block)
+          
           if block
-
+            
             loop do
 
               stgDir, stgFiles = @ws.staged_files
@@ -63,83 +62,217 @@ module Release
               delFiles.delete_if { |f| stgFiles.include?(f) }
               delDir.delete_if { |f| stgDir.include?(f) }
 
-              # block should call vcs for remove, ignore and diff
-              res = block.call(:select_files_to_manage, { modified: { files: modFiles, dirs: modDir }, new: { files: newFiles, dirs: newDir }, deleted: { files: delFiles, dirs: delDir }, staged: { files: stgFiles, dirs: stgDir }, vcs: self } )
+              res = block.call(:select_files_to_add, { modified: { files: modFiles, dirs: modDir }, new: { files: newFiles, dirs: newDir }, deleted: { files: delFiles, dirs: delDir }, staged: { files: stgFiles, dirs: stgDir }, vcs: self } )
 
-              break if not res.is_a?(GitCli::Delta::VCSItem) and res == :done
+              doneTriggered = false
+              sel = res.clone
+              if sel.include?(:done)
+                sel.delete_if { |e| e == :done }
+                doneTriggered = true
+              end
+
+              if not_empty?(sel)
+                st, rres = @ws.add_to_staging(*sel)
+                if st
+                  block.call(:files_added_successfully, { count: sel.length, output: rres })
+                else
+                  block.call(:files_failed_to_be_added, { output: rres } )
+                end
+              else
+                block.call(:no_files_given)
+              end
+
+              break if doneTriggered
 
             end
 
           end
 
-          res
-          
         end
 
-        # 
-        # Special operation since the gem build will only include files from
-        # git ls-files
-        #
-        def commit_new_files(msg = nil, &block)
-
-          res = :value
+        def diff(&block)
+          
           if block
-
+            
             loop do
 
               stgDir, stgFiles = @ws.staged_files
-              newDir, newFiles = @ws.new_files
+              modDir, modFiles = @ws.modified_files
+
+              modFiles.delete_if { |f| stgFiles.include?(f) }
+              modDir.delete_if { |f| stgDir.include?(f) }
+              
+              res = block.call(:select_files_to_diff, { modified: { files: modFiles, dirs: modDir },  staged: { files: stgFiles, dirs: stgDir }, vcs: self } )
 
-              if is_empty?(newFiles)
-                res = :skip
-                break
+              doneTriggered = false
+              sel = res.clone
+              if sel.include?(:done)
+                sel.delete_if { |e| e == :done }
+                doneTriggered = true
               end
 
-              newFiles.delete_if { |f| stgFiles.include?(f) }
-              newDir.delete_if { |f| stgDir.include?(f) }
+              if not_empty?(sel)
+                sel.each do |s|
+                  st, rres = @ws.diff_file(s)
+                  if st
+                    block.call(:diff_file_result, { file: s, output: rres })
+                  else
+                    block.call(:diff_file_error, { file: s, output: rres } )
+                  end
+                end
+              else
+                block.call(:no_files_given)
+              end
 
-              res = block.call(:select_files_to_commit, { new: { files: newFiles, dirs: newDir }, staged: { files: stgFiles, dirs: stgDir }, vcs: self } )
+              break if doneTriggered
 
-              break if res == :skip or res == :done
+            end
+
+          end
+
+        end
+
+        def ignore(*files, &block)
+          
+          if block
+            
+            loop do
+
+              newDir, newFiles = @ws.new_files
+
+              res = block.call(:select_files_to_ignore, { files: newFiles, dirs: newDir } )
+
+              doneTriggered = false
+              sel = res.clone
+              if sel.include?(:done)
+                sel.delete_if { |e| e == :done }
+                doneTriggered = true
+              end
+
+              if not_empty?(sel)
+                st, rres = @ws.ignore(*sel)
+                if st
+                  block.call(:files_ignored_successfully, { count: sel.length, output: rres })
+                else
+                  block.call(:files_failed_to_be_ignored, { output: rres } )
+                end
+              else
+                block.call(:no_files_given)
+              end
+
+              break if doneTriggered
 
             end
 
-            if res == :done
+          else
+
+            @ws.ignore(*files) if not_empty?(files)
+
+          end
+
+        end
+
+        def remove_from_staging(*files, &block)
+          
+          if block
+            
+            loop do
 
               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)
+              res = block.call(:select_files_to_remove, { files: stgFiles, dirs: stgDir } )
 
-              cp "Commit with user message : #{msg}"
-              st, res = @ws.commit(msg)
-              if st
-                block.call(:commit_successful, res) if block
+              doneTriggered = false
+              sel = res.clone
+              if sel.include?(:done)
+                sel.delete_if { |e| e == :done }
+                doneTriggered = true
+              end
+
+              if not_empty?(sel)
+                st, rres = @ws.remove_from_staging(*sel)
+                if st
+                  block.call(:files_removed_successfully, { count: sel.length, output: rres })
+                else
+                  block.call(:files_removed_to_be_ignored, { output: rres } )
+                end
               else
-                block.call(:commit_failed, res) if block
+                block.call(:no_files_given)
               end
-              [st, res]
+
+              break if doneTriggered
 
             end
 
+          else
 
-          elsif not_empty?(msg)
+            @ws.removed_from_staging(*files) if not_empty?(files)
 
-            newDir, newFiles = @ws.new_files
-            add_to_staging(*newFiles)
+          end
+
+        end
+
+        def delete_file(*files, &block)
+          
+          if block
+            
+            loop do
+
+              stgDir, stgFiles = @ws.staged_files
+              modDir, modFiles = @ws.modified_files
+              newDir, newFiles = @ws.new_files
+
+              modFiles.delete_if { |f| stgFiles.include?(f) }
+              modDir.delete_if { |f| stgDir.include?(f) }
+              
+              newFiles.delete_if { |f| stgFiles.include?(f) }
+              newDir.delete_if { |f| stgDir.include?(f) }
+
+              res = block.call(:select_files_to_delete, { modified: { files: modFiles, dirs: modDir }, new: { files: newFiles, dirs: newDir }, staged: { files: stgFiles, dirs: stgDir } } )
+
+              doneTriggered = false
+              sel = res.clone
+              if sel.include?(:done)
+                sel.delete_if { |e| e == :done }
+                doneTriggered = true
+              end
+
+              if not_empty?(sel)
+                staged = []
+                nonTrack = []
+                sel.each do |s|
+                  if s.is_a?(GitCli::Delta::NewFile)
+                    confirm = block.call(:confirm_nontrack_delete, s.path)
+                    if confirm
+                      FileUtils.rm(s.path)
+                      block.call(:nontrack_file_deleted, s.path)
+                    end
+                  elsif s.is_a?(GitCli::Delta::ModifiedFile)
+                    # not staged
+                    confirm = block.call(:confirm_vcs_delete, s.path)
+                    puts "vcs confirm : #{confirm}"
+                    if confirm
+                      @ws.remove_from_vcs(s.path)
+                      block.call(:vcs_file_deleted, s.path)
+                    end
+                  elsif s.is_a?(GitCli::Delta::StagedFile)
+                    confirm = block.call(:confirm_staged_delete, s.path)
+                    if confirm
+                      @ws.remove_from_staging(s.path)
+                      block.call(:staged_file_deleted, s.path)
+                    end
+                  end
+                end
+
+              else
+                block.call(:no_files_given)
+              end
+
+              break if doneTriggered
 
-            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
-
         end
 
         def commit(msg = nil, &block)
@@ -220,16 +353,16 @@ module Release
 
             if is_empty?(msg)
               if block
-                msg = block.call(:tag_message)
+                msg = block.call(:tag_message, { tag: tag })
               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
+              block.call(:tagging_success, { tag: tag, output: res }) if block
             else
-              block.call(:tagging_failed, res) if block
+              block.call(:tagging_failed, { tag: tag, output: res }) if block
             end
 
             [st, res]
@@ -314,14 +447,6 @@ module Release
 
         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)

data/lib/release/gem/vcs_cli_action.rb

@@ -20,8 +20,49 @@ module Release
           instance_eval(&block) if block
         end
 
-        def overview_changes(*args, &block)
-          @inst.overview_changes do |ops, *args|
+        def manage_workspace(*args, &block)
+         
+          loop do
+
+            ops = @prmt.select(pmsg("\n Please select a VCS workspace operation : ")) do |m|
+
+              m.choice "Add", :add
+              m.choice "Ignore", :ignore
+              m.choice "Diff", :diff
+              m.choice "Remove staged file", :remove_staged
+              m.choice "Delete file", :del
+              m.choice "Commit", :commit
+              m.choice "Done", :done
+              m.choice "Abort", :abort
+
+            end
+
+            case ops
+            when :abort
+              raise Release::Gem::Abort, "User aborted"
+            when :add
+              add
+            when :diff
+              diff
+            when :ignore
+              ignore
+            when :remove_staged
+              remove_staged
+            when :del
+              delete_file
+            when :commit
+              commit
+              break
+            when :done
+              break
+            end
+
+          end
+
+        end
+
+        def add(*input, &block)
+          @inst.add do |ops, *args|
             preset = false
             if block
               res = block.call(ops, *args)
@@ -36,71 +77,120 @@ module Release
 
             if preset
               case ops
-              when :select_files_to_manage
-                mfiles = args.first
+              when :select_files_to_add
 
-                sel = @prmt.select pmsg("\n Following are files that could be managed : ") do |m|
+                mfiles = args.first
+                @prmt.puts pmsg("\n Files already added to staging : ")
+                mfiles[:staged].each do |k,v|
+                  v.each do |vv|
+                    @prmt.puts " * #{vv}"
+                  end
+                end
 
-                  [:staged, :modified, :new, :deleted].each do |cat|
-                    mfiles[cat].each do |k,v|
-                      v.each do |vv|
-                        m.choice vv, vv
-                      end
+                @prmt.puts ""
+                res = []
+                [:modified, :new, :deleted].each do |cat|
+                  mfiles[cat].each do |k,v|
+                    v.each do |vv|
+                      res << vv 
                     end
+                  end
+                end
+
+                sel = @prmt.multi_select pmsg("\n Following are files that could be added to version control : ") do |m|
 
+                  res.sort.each do |f|
+                    m.choice f, f.path
                   end
 
                   m.choice "Done", :done
+                  m.choice "Abort", :abort
+                end
 
+                if sel.include?(:abort)
+                  raise Release::Gem::Abort, "User aborted"
+                else
+                  sel
                 end
 
-                if sel.is_a?(GitCli::Delta::VCSItem)
+              when :files_added_successfully
+                v = args.first
+                @prmt.puts "\n #{v[:count]} file(s) added successfully.\n#{v[:output]}"
 
-                  selOps = @prmt.select pmsg("\n What do you want to do with file '#{sel.path}'?") do |m|
+              when :files_failed_to_be_added
+                v = args.first
+                @prmt.puts "\n File(s) failed to be added. Error was : \n#{v[:output]}"
 
-                    m.choice "Diff", :diff  if not (sel.is_a?(GitCli::Delta::NewFile) or sel.is_a?(GitCli::Delta::NewDir)) 
-                    m.choice "Ignore", :ignore
-                    m.choice "Remove from staging", :remove_from_staging if sel.is_a?(GitCli::Delta::StagedFile)
-                    m.choice "Delete", :delete if (sel.is_a?(GitCli::Delta::NewFile) or sel.is_a?(GitCli::Delta::NewDir)) 
-                    m.choice "Done", :done
-                  end
+              end
 
-                  case selOps
-                  when :diff
-                    st, res = @inst.diff_file(sel.path)
-                    puts res
-                    STDIN.getc
-                  when :ignore
-                    confirm = @prmt.yes?(pmsg("\n Add file '#{sel.path}' to gitignore file?"))
-                    if confirm
-                      @inst.ignore(sel.path)
-                    end
-                  when :remove_from_staging
-                    confirm = @prmt.yes?(pmsg("\n Remove file '#{sel.path}' from staging?"))
-                    if confirm
-                      @inst.remove_from_staging(sel.path)
-                    end
-                  when :delete
-                    skip = @prmt.no?(pmsg("\n Delete the file '#{sel.path}' from file system? NOTE THIS CANNOT BE UNDONE! "))
-                    if not skip
-                      FileUtils.rm(sel.path)
+            end
+
+          end # block of add()
+        end
+
+        def diff(*input, &block)
+          @inst.diff 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_diff
+
+                mfiles = args.first
+                res = []
+                [:modified, :staged].each do |cat|
+                  mfiles[cat].each do |k,v|
+                    v.each do |vv|
+                      res << vv 
                     end
-                  when :done
                   end
+                end
+
+                sel = @prmt.multi_select pmsg("\n Select files for diff operation : ") do |m|
 
+                  res.sort.each do |f|
+                    m.choice f, f.path
+                  end
+
+                  m.choice "Done", :done
+                  m.choice "Abort", :abort
                 end
 
-                sel
+                if sel.include?(:abort)
+                  raise Release::Gem::Abort, "User aborted"
+                else
+                  sel
+                end
+
+              when :diff_file_result
+                v = args.first
+                @prmt.puts "Diff result for file '#{v[:file]}'"
+                puts v[:output].light_blue
+                STDIN.gets
+
+              when :diff_file_error
+                v = args.first
+                @prmt.puts "\n Failed to diff file '#{v[:file]}'. Error was : \n#{v[:output]}"
 
               end
+
             end
 
-          end
-        end # overview_changes
+          end # block of add()
+        end
 
-        def commit_new_files(*args, &block)
-          res = @inst.commit_new_files do |ops, *args|
-            
+        def ignore(*input, &block)
+          @inst.ignore do |ops, *args|
             preset = false
             if block
               res = block.call(ops, *args)
@@ -114,87 +204,172 @@ module Release
             end
 
             if preset
-
               case ops
-              when :select_files_to_commit
+              when :select_files_to_ignore
+
                 mfiles = args.first
-                @prmt.puts pmsg("\n Files already added to staging : ")
-                mfiles[:staged].each do |k,v|
-                  v.each do |vv|
-                    @prmt.puts " * #{vv}"
+                sel = @prmt.multi_select pmsg("\n Following are files that could be ignored : ") do |m|
+
+                  mfiles[:files].sort.each do |v|
+                    m.choice v, v.path
                   end
+
+
+                  m.choice "Done", :done
+                  m.choice "Abort", :abort
                 end
 
-                @prmt.puts ""
+                if sel.include?(:abort)
+                  raise Release::Gem::Abort, "User aborted"
+                else
+                  sel
+                end
 
-                sel = @prmt.multi_select pmsg("\n Following are new files that could be added to version control.\n Don't worry if you found not all changed files are here. There will be another commit session after the build : ") do |m|
+              when :files_ignored_successfully
+                v = args.first
+                @prmt.puts "\n #{v[:count]} file(s) ignored successfully.\n#{v[:output]}"
 
-                  mfiles[:new].each do |k,v|
-                    v.each do |vv|
-                      m.choice vv, vv.path
-                    end
+              when :files_failed_to_be_ignored
+                v = args.first
+                @prmt.puts "\n File(s) failed to be ignored. Error was : \n#{v[:output]}"
+
+              end
+
+            end
+
+          end # block of add()
+        end
+
+        def remove_staged(*input, &block)
+          @inst.remove_from_staging 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_remove
+
+                mfiles = args.first
+
+                sel = @prmt.multi_select pmsg("\n Following are files that could be removed from staging : ") do |m|
+
+                  mfiles[:files].sort.each do |v|
+                    m.choice v, v.path
                   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 pmsg("\n Files added successfully", :green)
-                    else
-                      @prmt.puts pmsg("\n Files failed to be added. Message was : #{cres}", :red)
+                  sel
+                end
+
+              when :files_removed_successfully
+                v = args.first
+                @prmt.puts "\n #{v[:count]} file(s) removed successfully.\n#{v[:output]}"
+
+              when :files_removed_to_be_ignored
+                v = args.first
+                @prmt.puts "\n File(s) failed to be removed. Error was : \n#{v[:output]}"
+
+              end
+
+            end
+
+          end # block
+        end
+
+        def delete_file(*args, &block)
+          res = @inst.delete_file 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_delete
+                mfiles = args.first
+
+                files = []
+                [:new, :staged, :modified].each do |cat|
+                  mfiles[cat].each do |k,v|
+                    v.each do |vv|
+                      files << vv
+                      #m.choice vv, vv
                     end
                   end
 
-                  res
-
                 end
 
-              when :commit_message
-                msg = ""
-                loop do
-                  msg = @prmt.ask(pmsg("\n Commit message : "), required: true)
-                  confirm = @prmt.yes?(pmsg(" Commit message : #{msg}\n Proceed? No to provide a new commit message "))
-                  if confirm
-                    break
+
+                sel = @prmt.multi_select pmsg("\n Following are files that could be deleted : ") do |m|
+                  files.sort do |f|
+                    m.choice f, f
                   end
+                  m.choice "Done", :done
+                  m.choice "Abort", :abort
                 end
 
-                msg
-
-              when :staged_elements_of_commit
 
-                elements = args.first
-                @prmt.puts pmsg("\n Following new files/directories shall be committed in this session : ")
-                elements.each do |k,v|
-                  v.each do |vv|
-                    @prmt.puts " * #{vv}"
-                  end
+                if sel.include?(:abort)
+                  raise Release::Gem::Abort, "User aborted"
+                else
+                  sel
                 end
 
-              when :commit_successful
-                @prmt.puts pmsg("\n Changes committed",:green)
-                @prmt.puts args.first
+              when :confirm_nontrack_delete
+                v = args.first
+                @prmt.yes?(pmsg("\n Delete non-tracked file '#{v}'? "))
 
-              when :commit_failed
-                @prmt.puts pmsg("\n Changes failed to be committed. Error was : #{args.first}")
+              when :nontrack_file_deleted
+                v = args.first
+                @prmt.puts pmsg("\n Non tracked file '#{v}' deleted ")
+
+              when :confirm_vcs_delete
+                v = args.first
+                not @prmt.no?(pmsg("\n Delete version-controlled file '#{v}'?\n After delete the file will no longer keeping track of changes. "))
+
+              when :vcs_file_deleted
+                v = args.first
+                @prmt.puts pmsg("\n Version-controlled file '#{v}' deleted ")
+
+              when :confirm_staged_delete
+                v = args.first
+                @prmt.yes?(pmsg("\n Delete staged file '#{v}'?\n After delete the file shall be removed from staging. The file will still exist physically "))
+
+              when :staged_file_deleted
+                v = args.first
+                @prmt.puts pmsg("\n Staged file '#{v}' deleted ")
 
               end
             end
-          end # commit_new_files block
+          end # delete_file block
+
+        end # delete_file
 
-        end # commit_new_files
 
 
         def commit(*args, &block)
@@ -226,15 +401,22 @@ module Release
 
                 @prmt.puts ""
 
-                sel = @prmt.multi_select pmsg("\n Following are files that could be added to version control : ") do |m|
-
-                  [:modified, :new, :deleted].each do |cat|
-                    mfiles[cat].each do |k,v|
-                      v.each do |vv|
-                        m.choice vv, vv.path
-                      end
+                files = []
+                [:modified, :new, :deleted].each do |cat|
+                  mfiles[cat].each do |k,v|
+                    v.each do |vv|
+                      files << vv
+                      #m.choice vv, vv.path
                     end
+                  end
+
+                end
 
+
+                sel = @prmt.multi_select pmsg("\n Following are files that could be added to version control : ") do |m|
+                  
+                  files.sort.each do |f|
+                    m.choice f, f.path
                   end
 
                   m.choice "Skip", :skip #if mfiles[:counter] == 0
@@ -318,14 +500,17 @@ module Release
 
               case ops
               when :tag_message
-                @prmt.ask(pmsg("\n Please provide message for the tag : "), value: "Auto tagging by gem-release gem during releasing version #{@selVer}", required: true)
+                v = args.first
+                @prmt.ask(pmsg("\n Please provide message for the tag : "), value: "Auto tagging by gem-release gem during releasing version #{v[:tag]}", required: true)
 
               when :tagging_success
-                @prmt.puts pmsg("\n Tagging of source code is successful.", :green)
-                @prmt.puts args.first
+                v = args.first
+                @prmt.puts pmsg("\n Tagging of source code with tag '#{v[:tag]}' is successful.", :green)
+                @prmt.puts v[:output]
 
               when :tagging_failed
-                @prmt.puts pmsg("\n Tagging of source code failed. Error was : #{args.first}", :red)
+                v = args.first
+                @prmt.puts pmsg("\n Tagging of source code with tag '#{v[:tag]}' failed. Error was : #{v[:output]}", :red)
 
               when :no_tagging_required
                 @prmt.puts pmsg("\n No tagging required. Source head is the tagged item ", :green)

data/lib/release/gem/version.rb

@@ -2,6 +2,6 @@
 
 module Release
   module Gem
-    VERSION = "0.1.8"
+    VERSION = "0.1.10"
   end
 end

data/templates/standard_cli_flow.rb

@@ -10,15 +10,11 @@ Release::Gem.engine(:gem, root: Dir.getwd) do
     # step 1 : run test
     run_test(:rspec) 
 
-    # to allow user to get a view on what's changed
-    # and allow user to ignore or remove file from staging
-    vcs_cli_overview_changes
-
     # Reason to put it here is because gem build shall
     # only consider files already inside git system via
     # git ls-files command. Anything new that is not yet
     # check in will not be packup by the gem build process
-    vcs_cli_commit
+    vcs_cli_manage_workspace
 
     # step 2 : check dependency
     gem_cli_release_dependencies 
@@ -34,17 +30,13 @@ Release::Gem.engine(:gem, root: Dir.getwd) do
       gem_cli_install(version: ver)
     end
 
-    puts "version : #{ver}"
-
-    @selVer = value(:selected_version)
-
     vcs_add_to_staging_if_commit_before("Gemfile.lock")
     vcs_add_to_staging(value(:version_file_path))
 
-    vcs_commit("Commit after gem version #{@selVer} built")
+    vcs_commit("Commit after gem version #{ver} built")
 
     # step 7 : tag the source code
-    vcs_cli_tag( tag: @selVer )      
+    vcs_cli_tag( tag: ver )      
 
     # step 8 : Push the source code
     vcs_cli_push

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: release-gem
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.10
 platform: ruby
 authors:
 - Chris