pessimizer 1.0.0

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+before_install: gem install bundler
+rvm:
+  - 2.2.3
+  - 2.2.0
+  - 2.1.5
+  - 2.0.0
+  - 1.9.3
+  - 1.9.2
+  - jruby-1.7.10
+  - jruby-1.7.19

data/CHANGELOG

@@ -0,0 +1,43 @@
+=== Pessimize 0.4.0
+* Specify version of codeclimate-test-reporter to avert a breaking change (introduced in 1.0.0)
+* Fix documentation link for pessimistic operator (issue #19)
+* Support comments in the Gemfile tokenization (issue #15)
+
+=== Pessimize 0.3.0
+
+Features:
+ * Increased compatibility with Gemfile syntax, which should support
+ practically all Gemfiles.
+ * Some minor refactoring for clarity (ongoing, as always)
+
+Bug fixes:
+ * Fix issue with certain valid ruby expressions not being parsed correctly,
+ e.g. new lines in "gem" definitions
+
+=== Pessimize 0.2.0
+
+Features:
+ * Use token parsing instead of interpreting the Gemfile, which allows the Gemfile formatting to be retained (issue #5)
+
+=== Pessimize 0.1.0
+
+Features:
+ * Introduce proper command line interface, with help and various options
+ * Change default behaviour to constrain versions on the minor number, instead of patch (issue #8)
+ * Add command line option to change version level constraint (issue #8)
+ * Use Bundler's Gemfile.lock parser, instead of a custom parser (issue #7)
+ * Add license to gemspec (issue #6)
+
+=== Pessimize 0.0.3
+
+Bug fixes:
+ * Fix bug with multiple arguments to `group` not being recognised (issue #1)
+ * Fix missing newlines between statements in Gemfile (issue #2)
+
+Features:
+ * Better error messages when evaluating a Gemfile with errors (thanks @deepak, #3)
+
+=== Pessimize 0.0.2
+
+Features:
+ * Was born (we don't talk about v0.0.1)

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec 

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jon Cairns
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,90 @@
+# Pessimize
+
+[![Gem Version](https://badge.fury.io/rb/pessimize.png)](http://badge.fury.io/rb/pessimize)
+[![Build Status](https://travis-ci.org/joonty/pessimize.png?branch=master)](https://travis-ci.org/joonty/pessimize)
+[![Code Climate](https://codeclimate.com/github/joonty/pessimize/badges/gpa.svg)](https://codeclimate.com/github/joonty/pessimize)
+[![Test Coverage](https://codeclimate.com/github/joonty/pessimize/badges/coverage.svg)](https://codeclimate.com/github/joonty/pessimize/coverage)
+
+### Who is this for?
+Anyone who works with a Gemfile, i.e. a project that uses [bundler][1].
+
+### What does it do?
+Pessimize adds version numbers with the pessimistic constraint operator (`~>`, a.k.a. "spermy" operator) to all gems in your `Gemfile`.
+
+### Why?
+You should be using `~> x.x` to limit the version numbers of your gems, otherwise `bundle update` could potentially break your application. Read the section on "why bundle update can be dangerous" for a more detailed description, or take a look at the [rubygems explanation][2].
+
+### But why a gem?
+
+*I.e. why not just do it by hand?*
+
+When you start building an application that uses bundler, you aren't yet sure which versions of gems will work together, so you probably won't specify the precise versions. You would normally only do this when the application and it's dependencies are in a fairly stable state. However, if you have more than a few gems, it's very tedious to collect the version numbers for each gem and add the pessimistic constraint operator to each line in the `Gemfile`.
+
+Pessimize works out the version of each gem from `Gemfile.lock` then generates a new `Gemfile` with the added version constraints. But don't worry: it backs up the existing Gemfile before running, so you can get the original back if it goes wrong. (If it does go wrong, please submit an issue.)
+
+## Installation
+
+You don't need to add it to your Gemfile - it's best kept as a system-wide gem. All you need to do is install it from the command line:
+
+    $ gem install pessimize
+
+This installs the command line tool `pessimize`.
+
+## Usage
+
+Change to a directory that contains a `Gemfile` and execute:
+
+    $ pessimize
+
+This backs up the existing `Gemfile` and creates a new one with everything neatly organised and versioned.
+
+And that's it!
+
+### Options
+
+The executable has various options, which you can read with the `--help` argument:
+
+```bash
+Usage: pessimize [options]
+
+Add the pessimistic constraint operator to all gems in your Gemfile, restricting the maximum update
+version.
+
+Run this in a directory containing a Gemfile to apply the version constraint operator to all gems, at
+their current version. By default, it will restrict updates to the minor version number, but this can be
+changed to patch level updates.
+
+Options:
+  --version-constraint, -c <s>:   Version constraint ('minor' or 'patch') (default: minor)
+     --backup, --no-backup, -b:   Backup existing Gemfile and Gemfile.lock (default: true)
+                 --version, -v:   Print version and exit
+                    --help, -h:   Show this message
+```
+
+By default, the versions will be constrained to the minor version number (e.g. "~> 3.2"). If you supply the option `--version-constraint patch` then it will only allow updates on the patch version number (e.g. "~> 3.2.5").
+
+Also, by default, the Gemfile and Gemfile.lock are copied as a form of backup. To skip this backup (for instance, if you're confident that your Gemfile is committed into version control) then add the `--no-backup` option.
+
+## Known issues
+
+Recent issues with certain Gemfile syntax edge cases have been fixed, so there are currently no known issues. If you do find pessimize doing something strange, or not correctly picking up information in your Gemfile, it would be greatly appreciated if you submit an issue.
+
+## Why `bundle update` can be dangerous
+
+If you add gems to your Gemfile without specifying a version, bundler will attempt to get the latest stable version for that gem. When you first run `bundle install`, bundler will get and install the latest versions, then create a `Gemfile.lock` which specifies the versions used.
+
+This is fine until someone runs `bundle update`. In this case, bundler will try to update each gem to the maximum possible version. If no constraints have been applied, that means that **major** versions can potentially be incremented. Gems have interdependencies with other gems, and if those gems haven't specified the version constraints then breakages could occur.
+
+The pessimistic constraint operator will only allow the final number of the version string to increase. You can use this to only allow patch or minor level upgrades. This means that when you run `bundle update`, there's a limit on how far gems will update.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+[1]: http://gembundler.com
+[2]: http://guides.rubygems.org/patterns/#declaring-dependencies
+[3]: https://github.com/joonty/pessimize/issues/5

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/gem_tasks"
+
+task :default => :spec

data/bin/pessimize

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'pessimize'
+require 'pessimize/shell'
+
+Pessimize::Shell.new.run

data/lib/pessimize/file_manager.rb

@@ -0,0 +1,39 @@
+module Pessimize
+  class FileManager
+    def gemfile
+      'Gemfile'
+    end
+
+    def gemfile_lock
+      'Gemfile.lock'
+    end
+
+    def gemfile?
+      File.exist? gemfile
+    end
+
+    def gemfile_contents
+      File.read gemfile
+    end
+
+    def gemfile_lock?
+      File.exist? gemfile_lock
+    end
+
+    def backup_gemfile!
+      backup_file! gemfile
+    end
+
+    def backup_gemfile_lock!
+      backup_file! gemfile_lock
+    end
+
+  private
+    def backup_file!(file)
+      cmd = "cp #{file} #{file}.backup"
+      puts " + #{cmd}"
+      `#{cmd}`
+      $?.exitstatus == 0
+    end
+  end
+end

data/lib/pessimize/gem.rb

@@ -0,0 +1,63 @@
+module Pessimize
+  class Gem
+    attr_reader :name, :original_tokens
+    attr_accessor :version
+
+    def initialize(gem_tokens)
+      self.original_tokens = gem_tokens
+      parse_name
+      parse_version
+    end
+
+    def tokens
+      compiled_tokens = original_tokens.dup
+      if version_index
+        compiled_tokens[version_index][2] = version
+      elsif version
+        compiled_tokens[after_name_index..0] = version_tokens
+      end
+      compiled_tokens
+    end
+
+    def to_s
+      tokens.inject("") { |a, t| a << t[2] }
+    end
+
+  protected
+    attr_writer :name, :original_tokens
+    attr_accessor :version_index,
+      :token_before_version,
+      :after_name_index
+
+    def version_tokens
+      [
+        [[], :on_comma, ","],
+        [[], :on_sp, " "],
+        [[], :on_tstring_beg, "\""],
+        [[], :on_tstring_content, version],
+        [[], :on_tstring_end, "\""]
+      ]
+    end
+
+    def parse_name
+      name_index = original_tokens.index { |t| t[1] == :on_tstring_content }
+      self.name = original_tokens[name_index][2]
+      self.after_name_index = name_index + 2
+    end
+
+    def parse_version
+      token_before_version = original_tokens.index { |t| t[1] == :on_comma }
+      if token_before_version
+        remaining_tokens = original_tokens[(token_before_version + 1)..-1]
+        while [:on_sp, :on_tstring_beg, :on_ignored_nl].include? remaining_tokens.first[1]
+          remaining_tokens.shift
+          token_before_version += 1
+        end
+        if remaining_tokens.first[1] == :on_tstring_content
+          self.version_index = token_before_version + 1
+          self.version = remaining_tokens.first[2]
+        end
+      end
+    end
+  end
+end

data/lib/pessimize/gemfile.rb

@@ -0,0 +1,73 @@
+require 'ripper'
+require 'pessimize/gem'
+
+module Pessimize
+  class Gemfile
+    attr_reader :gems
+
+    def initialize(contents)
+      self.tokens        = Ripper.lex(contents)
+      self.gems          = []
+      self.gem_token_map = []
+
+      parse_gems_from_tokens!
+    end
+
+    def to_s
+      TokenCompiler.new(tokens).compile_to_string(gems, gem_token_map)
+    end
+
+  protected
+    attr_writer :gems
+    attr_accessor :gem_token_map, :tokens
+
+    def parse_gems_from_tokens!
+      enum = tokens.each_with_index
+
+      loop do
+        (tok, i) = enum.next
+
+        if tok[1] == :on_ident && tok[2] == "gem"
+          gem_toks = []
+          until all_gem_tokens_collected?(tok[0], enum.peek[0])
+            (tok, j) = enum.next
+            gem_toks << tok
+          end
+
+          self.gems << Pessimize::Gem.new(gem_toks)
+          self.gem_token_map << [i + 1, j]
+        end
+      end
+    rescue StopIteration
+    end
+
+    def all_gem_tokens_collected?(current_token, next_token)
+      [:on_nl, :on_comment].include?(next_token[1])
+    end
+
+    class TokenCompiler
+      def initialize(tokens)
+        self.tokens = tokens.dup
+        self.offset = 0
+      end
+
+      def compile_to_string(gems, gem_token_map)
+        gem_token_map.zip(gems).each do |(token_start, token_end), gem|
+          insert_gem_into_tokens! gem, token_start, token_end
+        end
+
+        tokens.reduce("") { |a, e|
+          a + e[2]
+        }
+      end
+
+    protected
+      attr_accessor :tokens, :offset
+
+      def insert_gem_into_tokens!(gem, token_start, token_end)
+        self.tokens[(offset + token_start)..(offset + token_end)] = gem.tokens
+        self.offset += gem.tokens.length - (token_end - token_start + 1)
+      end
+    end
+  end
+end

data/lib/pessimize/gemfile_lock_version_parser.rb

@@ -0,0 +1,26 @@
+require 'bundler'
+
+module Pessimize
+  class GemfileLockVersionParser
+    attr_reader :versions
+
+    def initialize
+      self.versions = {}
+    end
+
+    def call(gemfile_lock_file)
+      parser = Bundler::LockfileParser.new(gemfile_lock_file.read)
+      self.versions = collect_names_and_versions(parser.specs)
+      self
+    end
+
+  protected
+    attr_writer   :versions
+
+    def collect_names_and_versions(specs)
+      Hash[specs.
+            reject { |s| s.source.is_a?(Bundler::Source::Git) }.
+            collect { |s| [s.name, s.version.to_s] }]
+    end
+  end
+end

data/lib/pessimize/pessimizer.rb

@@ -0,0 +1,43 @@
+require 'pessimize/gemfile'
+require 'pessimize/gemfile_lock_version_parser'
+require 'pessimize/version_mapper'
+
+module Pessimize
+  class Pessimizer
+    def initialize(file_manager, options)
+      self.file_manager = file_manager
+      self.options = options
+      self.lock_parser = GemfileLockVersionParser.new
+    end
+
+    def run
+      collect_gems_and_versions
+      update_gem_versions
+      write_new_gemfile
+      puts "~> written #{gemfile.gems.length} gems to Gemfile, constrained to #{options[:version_constraint]} version updates\n\n"
+    end
+
+  protected
+    attr_accessor :gemfile, :lock_parser, :file_manager, :options
+
+    def sep(num = 1)
+      "\n" * num
+    end
+
+    def collect_gems_and_versions
+      self.gemfile = Gemfile.new(file_manager.gemfile_contents)
+      lock_parser.call File.open(file_manager.gemfile_lock)
+    end
+
+    def update_gem_versions
+      VersionMapper.new.call(gemfile.gems, lock_parser.versions, options[:version_constraint])
+    end
+
+    def write_new_gemfile
+      File.delete(file_manager.gemfile)
+      File.open(file_manager.gemfile, 'w') do |f|
+        f.write gemfile.to_s
+      end
+    end
+  end
+end

data/lib/pessimize/shell.rb

@@ -0,0 +1,79 @@
+require 'pessimize/file_manager'
+require 'pessimize/pessimizer'
+require 'optimist'
+
+module Pessimize
+  class Shell
+    def initialize
+      self.file_manager = FileManager.new
+    end
+
+    def run
+      options = cli_options
+      check_options! options
+      verify_files!(options[:backup])
+      Pessimizer.new(file_manager, options).run
+    end
+
+  protected
+    attr_accessor :file_manager
+
+    def sep(num = 1)
+      "\n" * num
+    end
+
+    def cli_options
+      Optimist::options do
+        version "pessimize #{VERSION} (c) #{Time.now.year} Jon Cairns"
+        banner <<-EOS
+Usage: pessimize [options]
+
+Add the pessimistic constraint operator to all gems in your Gemfile, restricting the maximum update version.
+
+Run this in a directory containing a Gemfile to apply the version constraint operator to all gems, at their current version. By default, it will restrict updates to the minor version number, but this can be changed to patch level updates.
+
+Options:
+        EOS
+
+        opt :version_constraint, "Version constraint ('minor' or 'patch')", default: 'minor', type: :string, short: 'c'
+        opt :backup, "Backup existing Gemfile and Gemfile.lock", default: true, type: :boolean, short: 'b'
+      end
+    end
+
+    def check_options!(options)
+      constraints = %w(minor patch)
+      unless constraints.include? options[:version_constraint]
+        Optimist::die :version_constraint, "must be one of #{constraints.join("|")}"
+      end
+    end
+
+    def verify_files!(backup)
+      file_manager.gemfile? or exit_with 1, <<-ERR.strip
+        error: no Gemfile exists in the current directory, exiting
+      ERR
+
+      file_manager.gemfile_lock? or exit_with 2, <<-ERR.strip
+        error: no Gemfile.lock exists in the current directory, exiting
+          Please run `bundle install` before running pessimize
+      ERR
+
+      if backup
+        puts "Backing up Gemfile and Gemfile.lock"
+
+        file_manager.backup_gemfile! or exit_with 3, <<-ERR.strip
+          error: failed to backup existing Gemfile, exiting
+        ERR
+
+        file_manager.backup_gemfile_lock! or exit_with 4, <<-ERR.strip
+          error: failed to backup existing Gemfile.lock, exiting
+        ERR
+        puts ""
+      end
+    end
+
+    def exit_with(status, message)
+      $stderr.write message
+      exit status
+    end
+  end
+end

data/lib/pessimize/version.rb

@@ -0,0 +1,3 @@
+module Pessimize
+  VERSION = "1.0.0"
+end

data/lib/pessimize/version_mapper.rb

@@ -0,0 +1,13 @@
+module Pessimize
+  class VersionMapper
+    def call(gems, versions, version_constraint)
+      gems.each do |gem|
+        if versions.has_key? gem.name
+          version_parts = versions[gem.name].split('.')
+          version = version_constraint == 'minor' ? version_parts.first(2).join('.') : version_parts.join('.')
+          gem.version = "~> #{version}"
+        end
+      end
+    end
+  end
+end

data/lib/pessimize.rb

@@ -0,0 +1,3 @@
+require "pessimize/version"
+
+module Pessimize; end

data/pessimizer.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pessimize/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "pessimizer"
+  gem.version       = Pessimize::VERSION
+  gem.authors       = ["Jon Cairns", "Federico Iachetti"]
+  gem.email         = ["jon@joncairns.com", "iachetti.federico@gmail.com"]
+  gem.description   = %q{Add the pessimistic constraint operator to all gems in your Gemfile, restricting the maximum update version.
+
+This is for people who work with projects that use bundler, such as rails projects. The pessimistic constraint operator (~>) allows you to specify the maximum version that a gem can be updated, and reduces potential breakages when running `bundle update`. Pessimize automatically retrieves the current versions of your gems, then adds them to your Gemfile (so you don't have to do it by hand).}
+  gem.summary       = %q{Add the pessimistic constraint operator to all gems in your Gemfile, restricting the maximum update version.}
+  gem.homepage      = "https://github.com/iachettifederico/pessimizer"
+
+  gem.add_dependency 'bundler'
+  gem.add_dependency 'optimist'
+  gem.add_development_dependency 'rspec', '~> 3.12.0'
+  gem.add_development_dependency 'rspec-its', '~> 1.3.0'
+  gem.add_development_dependency 'rake', '~> 10.0.3'
+  gem.add_development_dependency 'codeclimate-test-reporter', '~> 0.6.0'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^spec/})
+  gem.require_paths = ["lib"]
+  gem.license       = 'MIT'
+end

data/spec/data/Gemfile.lock.example

@@ -0,0 +1,26 @@
+PATH
+  remote: .
+  specs:
+    pessimize (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.4)
+    rake (10.0.4)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  pessimize!
+  rake (~> 10.0.3)
+  rspec (~> 2.13.0)