drg 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 64ab93e66f0e85ab52aad6415ff9742dc974eff3
-  data.tar.gz: cd44e409518042394da5dd01f18833cb51b37c2b
+  metadata.gz: 79972e1a98ed795a5b79bd82df3776f21503cb0a
+  data.tar.gz: 6fd465489ef30e2dde409df44d8d7b8d29065e94
 SHA512:
-  metadata.gz: 34adbd98f8df9b92863b0b4349895e9241853070c24f99c333f309cbea81a3fd130b49712f73c513073aa521ac59c9f1cca02e4ae60a14bf37cafe215498bf27
-  data.tar.gz: bd191ee0cba818a2be8e1074bac1e512bed7a42b266542953f66d83e9b5f88aeab9b1d7b5681a9e649fe5574d7ef35cb761c59b8b58ef48f51bb0729339aa526
+  metadata.gz: e600c88738d8de1a28b89e4ba88b6cfb9329b3caa1363ed7901dc36eaef19f1682c8f4f05abfdef93a743ac43eb8b7cd3a63237bbde8070d98413aa1fa723a35
+  data.tar.gz: 0b50c62122cd9f959f5dc0fd0589feffeea2e9c552c98d927a25d9a8b718a5a54dbd96a6ab0a8499715e5517ad5e00e3102b26616f10787851215875fc082b0b

data/README.md

@@ -1,6 +1,12 @@
 # DRG
 
-A Ruby utility to help automate common tasks! Currently includes stuff like enhanced dependency management using Bundler and RSpec scaffolding.
+A Ruby utility to help automate common tasks! Currently includes enhanced dependency management using Bundler. You
+can pin Gem versions to the current or the next available level (major, minor, or patch). Can also automatically
+update your gems to the latest available version.
+
+## Requirements
+
+* Bundler 1.10+
 
 ## Installation
 
@@ -15,23 +21,28 @@ gem 'drg'
 ```bash
 rake drg:update
 rake drg:pin
-rake drg:pin:minor
 rake drg:pin:major
+rake drg:pin:minor
+rake drg:pin:patch
+rake drg:pin:latest_patch
+rake drg:pin:latest_minor
 rake drg:unpin
 ```
 
 ### drg:update
 
-DRG can update your outdated gems, one-by-one, to the latest version. It'll update the gem and then run your tests.
-If your tests pass, then the new version will be written to your Gemfile (similar to Gemnasium).
+DRG can update your outdated gems! It does this by checking for outdated gems, and then updating them one at time to the latest
+version. It then run your tests (with `rake`) and if your tests pass, the new version will be written to your Gemfile!
 
 ```bash
 rake drg:update
 ```
 
-### pin
+Easy!
+
+### drg:pin
 
-DRG really wants to help you manage your project's gems. But DRG doesn't want to replace Bundler. Instead we want to build on
+DRG really wants to help you manage your project's gems. But DRG doesn't want to replace Bundler. Instead, we want to build on
 it. Pinning ignores gems that are fetched from somewhere other than rubygems. For example, gems listed with `:git`, `:github`,
 or `:path` will be ignored. You can "pin" all your versions to the current version listed in the Gemfile.lock:
 
@@ -39,13 +50,13 @@ or `:path` will be ignored. You can "pin" all your versions to the current versi
 rake drg:pin
 ```
 
-Which will change gems list in your Gemfile to their full version. So if you have a gemfile that looks like:
+Will update a Gemfile to their full version:
 
 ```ruby
 gem 'rails'
 gem 'byebug', require: false
 gem 'therubyracer', '~> 0.12', platforms: :ruby
-gem 'drg'
+gem 'drg' # need this
 ```
 
 it'll get changed to
@@ -54,18 +65,18 @@ it'll get changed to
 gem 'rails', '4.2.3'
 gem 'byebug', '5.0.0', require: false
 gem 'therubyracer', '0.12.2', platforms: :ruby
-gem 'drg', '0.4.1'
+gem 'drg', '0.4.1' # need this
 ```
 
-### pin:minor
+### drg:pin:minor
 
-Although, you may want to pin gems with their _minor_ version (which allows updating patches). Run:
+Want to pin gems at their _minor_ version?
 
 ```bash
 rake drg:pin:minor
 ```
 
-Which will update your Gemfile from
+Will update a Gemfile
 
 ```ruby
 gem 'rails', '4.2.3'
@@ -77,9 +88,29 @@ to
 gem 'rails', '~> 4.2'
 ```
 
+### drg:pin:patch
+
+Want to pin gems at their _patch_ version?
+
+```bash
+rake drg:pin:minor
+```
+
+Will update a Gemfile
+
+```ruby
+gem 'rails', '4.2.3'
+```
+
+to 
+
+```ruby
+gem 'rails', '~> 4.2.3'
+```
+
 This can be combined with `bundle update` to quickly update all gems to the latest patch or minor level.
 
-### pin:major
+### drg:pin:major
 
 There is also a
 

data/drg.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
   # spec.add_dependency 'ruby2ruby', '>= 2.2.0', '< 3.0.0'
   spec.add_dependency 'bundler', '~> 1.10'
   spec.add_dependency 'duck_puncher', '1.0.0'
+  spec.add_dependency 'highline', '~> 1.7'
 
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '>= 3.2', '< 4'

data/lib/drg/tasks/gemfile.rb

@@ -12,8 +12,8 @@ module DRG
       # @param [GemfileLine] gem
       # @param [String] version to update the gem line with
       def update(gem, version)
+        saved_lines << lines.clone!
         lines[gem] = gem.update version
-        write
       end
 
       def remove_version(gem)

data/lib/drg/tasks/log.rb

@@ -0,0 +1,11 @@
+module DRG
+  module Tasks
+    module Log
+      module_function
+
+      def log(msg = nil)
+        say %Q(  * <%= color('#{msg}', :green) %>)
+      end
+    end
+  end
+end

data/lib/drg/tasks/pinner.rb

@@ -1,9 +1,12 @@
 module DRG
   module Tasks
     class Pinner
+      include Log
+
       attr_reader :gemfile, :type
 
-      def initialize(type = :patch)
+      # @param [Symbol] type of pin to perform. Available options are [:full, :major, :minor, :patch]
+      def initialize(type = :full)
         @type = type
         @gemfile = Gemfile.new
       end
@@ -14,6 +17,7 @@ module DRG
           gem = gemfile.find_by_name spec.name
           next unless gem
           gemfile.update gem, public_send(type, spec.version.to_s)
+          gemfile.write
         end
         log %Q(Done)
       end
@@ -27,17 +31,12 @@ module DRG
         log %Q(Done)
       end
 
-      def patch(version)
-        version
-      end
+      #
+      # Types
+      #
 
-      def minor(version)
-        v = version[/(\d+\.\d+)/, 1]
-        if v == '0.0'
-          version
-        else
-          "~> #{v}"
-        end
+      def full(version)
+        version
       end
 
       def major(version)
@@ -49,10 +48,17 @@ module DRG
         end
       end
 
-      private
+      def minor(version)
+        v = version[/(\d+\.\d+)/, 1]
+        if v == '0.0'
+          version
+        else
+          "~> #{v}"
+        end
+      end
 
-      def log(msg = nil)
-        puts %Q(  * #{msg})
+      def patch(version)
+        "~> #{version}"
       end
     end
   end

data/lib/drg/tasks/progressive_pinner.rb

@@ -0,0 +1,107 @@
+module DRG
+  module Tasks
+    class ProgessivePinner
+      include Log
+
+      attr_reader :gemfile, :type, :updated_gems
+      attr_writer :versions
+
+      # @param [Symbol] type of pin to perform. Available options are [:major, :minor, :patch]
+      def initialize(type = :patch)
+        @type = type
+        @gemfile = Gemfile.new
+        @versions = {}
+        @updated_gems = Set.new
+      end
+
+      def perform(gem_name = nil)
+        if gem_name
+          update ::Bundler.locked_gems.specs.find { |spec| spec.name == gem_name }
+        else
+          update_all
+        end
+        gemfile.write if gemfile.saved_lines.any?
+        log %Q(Done.#{' You may want run `bundle update`' if updated_gems.any?})
+      end
+
+      def update_all
+        log %Q(No gem specified)
+        Updater.new.perform method(:update_handler)
+      end
+
+      def update_handler(gem)
+        update ::Bundler.locked_gems.specs.find { |spec| spec.name == gem.name }
+      end
+
+      def update(spec)
+        gem = gemfile.find_by_name spec.name
+        if gem
+          log %Q[Searching for latest #{type} version of "#{spec.name}" (currently #{spec.version.to_s}) ...]
+          latest_version = public_send("latest_#{type}_version", spec.name, spec.version)
+          if latest_version
+            if ask("  * Do you want to update to version #{latest_version} (y/n)?").to_s.downcase == 'y'
+              gemfile.update gem, latest_version
+              updated_gems << gem.name
+            end
+          else
+            log %Q(No newer #{type} versions found)
+          end
+        end
+      end
+
+      # @param [String] name of the gem
+      # @param [String] current_version of the gem
+      def latest_minor_version(name, current_version)
+        new_versions(name, current_version).select { |version|
+          segments = version.scan(/\d+/)
+          major_version = segments[0].to_i
+          minor_version = segments[1].to_i
+          minor_version > current_version.segments[1] && major_version == current_version.segments[0]
+        }.first
+      end
+
+      # @param [String] name of the gem
+      # @param [String] current_version of the gem
+      def latest_patch_version(name, current_version)
+        new_versions(name, current_version).select { |version|
+          segments = version.scan(/\d+/)
+          patch_version = segments[-1].to_i
+          minor_version = segments[1].to_i
+          patch_version > current_version.segments[-1] && minor_version == current_version.segments[1]
+        }.first
+      end
+
+      # @param [String] name of the gem
+      # @param [String] current_version of the gem
+      def new_versions(name, current_version)
+        versions(name).select { |version| higher?(version.scan(/\d+/), current_version.segments) }
+      end
+
+      # @param [String] name of the gem
+      # @return [Array] a list of available versions (e.g. ['1.2.0', '1.1.0'])
+      def versions(name)
+        @versions[name] ||= `gem query -radn ^#{name}$`.scan(/([\d.]+),/).flatten.uniq
+      end
+
+      def higher?(list, other_list)
+        return true if list[0].to_i > other_list[0].to_i
+        return true if list[1].to_i > other_list[1].to_i
+        return true if list[2].to_i > other_list[2].to_i
+        false
+      end
+
+      # @todo delete if not used
+      #
+      # @param [String] name of the gem
+      # @param [String] current_version of the gem
+      # def next_patch_version(name, current_version)
+      #   new_versions(name, current_version).select { |version|
+      #     puts segments = version.scan(/\d+/)
+      #     patch_version = segments.last.to_i
+      #     minor_version = segments[-2].to_i
+      #     patch_version > current_version.segments[-1] && minor_version <= current_version.segments[-2]
+      #   }.last
+      # end
+    end
+  end
+end

data/lib/drg/tasks/updater.rb

@@ -1,6 +1,8 @@
 module DRG
   module Tasks
     class Updater
+      include Log
+
       attr_reader :gemfile, :failures, :bundler
 
       def initialize
@@ -12,10 +14,9 @@ module DRG
 
       # Updates the projects outdated gems listed in the Gemfile
       #
-      # @todo Incrementally update the gem using +versions+
       # @todo Cleanup old gems when finished
       # @note `bundle outdated` returns lines that look like 'slop (newest 4.2.0, installed 3.6.0) in group "default"'
-      def perform
+      def perform(handler = method(:try_update))
         log 'Searching for outdated gems ....'
         outdated = `bundle outdated`.scan(/\s\*\s(.+)\s/).flatten
         gems = outdated.map do |item|
@@ -28,7 +29,7 @@ module DRG
           gem
         end.compact
         if gems.any?
-          gems.each &method(:try_update)
+          gems.each &handler
         else
           log 'All gems up to date!'
         end
@@ -44,6 +45,7 @@ module DRG
           if system('rake')
             log(%Q[Tests passed! Updating Gemfile entry for "#{gem.name}" to #{gem.latest_version}])
             gemfile.update(gem.entry, gem.latest_version)
+            gemfile.write
           else
             failures << gem.name
           end
@@ -51,34 +53,14 @@ module DRG
           fail StandardError, %Q[Failed to update "#{gem.name}"]
         end
       rescue Bundler::GemNotFound, Bundler::InstallError, Bundler::VersionConflict => e
+        # @todo retry it later
         log %Q[Failed to find a compatible of "#{gem.name}" (#{gem.latest_version}): #{e.class} #{e.message}]
         gemfile.rollback
         failures << gem.name
-          # @todo retry it later
       rescue => e
         puts "#{e.class}: #{e.message} #{e.backtrace}"
         gemfile.rollback
       end
-
-      # @note not used
-      # @param [String] name of the gem
-      # @param [String] current_version of the gem
-      def new_versions(name, current_version)
-        versions(name).select { |version| version > current_version }
-      end
-
-      # @note not used
-      # @param [String] name of the gem
-      # @return [Array] a list of available versions (e.g. ['1.2.0', '1.1.0'])
-      def versions(name)
-        @versions[name] ||= `gem query -radn ^#{name}$`.scan(/([\d.]+),/).flatten
-      end
-
-      private
-
-      def log(msg = nil)
-        puts %Q(  * #{msg})
-      end
     end
   end
 end

data/lib/drg/version.rb

@@ -1,3 +1,3 @@
 module DRG
-  VERSION = '0.5.1'.freeze
+  VERSION = '0.6.0'.freeze
 end

data/lib/drg.rb

@@ -4,21 +4,24 @@ require 'bundler'
 require 'bundler/cli'
 require 'drg/version'
 require 'duck_puncher'
+require 'highline/import'
 
 # defines #clone!
 DuckPuncher.load! :Object
 
 module DRG
-  autoload :FileReader, 'drg/file_reader'
-  autoload :Scanner, 'drg/scanner'
-  autoload :Judge, 'drg/judge'
-  autoload :FileContext, 'drg/file_context'
+  # autoload :FileReader, 'drg/file_reader'
+  # autoload :Scanner, 'drg/scanner'
+  # autoload :Judge, 'drg/judge'
+  # autoload :FileContext, 'drg/file_context'
 
   module Tasks
     autoload :Updater, 'drg/tasks/updater'
     autoload :Pinner, 'drg/tasks/pinner'
+    autoload :ProgessivePinner, 'drg/tasks/progressive_pinner'
     autoload :Gemfile, 'drg/tasks/gemfile'
     autoload :GemfileLine, 'drg/tasks/gemfile_line'
+    autoload :Log, 'drg/tasks/log'
   end
 end
 

data/lib/tasks/drg.rake

@@ -21,11 +21,25 @@ namespace :drg do
     task :major do
       DRG::Tasks::Pinner.new(:major).perform
     end
+
+    desc 'Adds the fuzzy match operator to the patch version of your gems (e.g. rails, "~> 4.2.3")'
+    task :patch do
+      DRG::Tasks::Pinner.new(:patch).perform
+    end
+
+    desc 'Pins all gems [or the requested gem] to the latest available patch version'
+    task :latest_minor, [:gem_name] do |_, options|
+      DRG::Tasks::ProgessivePinner.new(:minor).perform(options[:gem_name])
+    end
+
+    desc 'Pins all gems [or the requested gem] to the latest available minor version'
+    task :latest_patch, [:gem_name] do |_, options|
+      DRG::Tasks::ProgessivePinner.new(:patch).perform(options[:gem_name])
+    end
   end
 
   desc 'Updates your gems in the Gemfile to the latest compatible version'
   task :update do
-    # sh 'cd /Users/ryanbuckley/apps/dontspreadit && which ruby'
     DRG::Tasks::Updater.new.perform
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: drg
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Ryan Buckley
@@ -38,6 +38,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -97,7 +111,9 @@ files:
 - lib/drg/scanner.rb
 - lib/drg/tasks/gemfile.rb
 - lib/drg/tasks/gemfile_line.rb
+- lib/drg/tasks/log.rb
 - lib/drg/tasks/pinner.rb
+- lib/drg/tasks/progressive_pinner.rb
 - lib/drg/tasks/updater.rb
 - lib/drg/version.rb
 - lib/tasks/drg.rake