pessimize 0.0.2

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+log

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+before_install: gem install bundler
+rvm:
+  - 2.0.0
+  - 1.9.3
+  - 1.9.2
+  - jruby-1.7.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pessimize.gemspec
+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,57 @@
+# Pessimize
+
+[![Build Status](https://travis-ci.org/joonty/pessimize.png?branch=master)](https://travis-ci.org/joonty/pessimize)
+
+### 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.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][1].
+
+### 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!
+
+## 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 level upgrades, or minor (if you're feeling dangerous). 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://docs.rubygems.org/read/chapter/16#page74

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+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/declaration.rb

@@ -0,0 +1,17 @@
+module Pessimize
+  class Declaration
+    attr_reader :name, :args
+
+    def initialize(name, *args)
+      @name = name
+      @args = args
+    end
+
+    def to_code
+      s = ""
+      s << "#{name} "
+      s << args.map(&:inspect).join(", ")
+      s
+    end
+  end
+end

data/lib/pessimize/dsl.rb

@@ -0,0 +1,36 @@
+module Pessimize
+  class DSL
+    def initialize(collector)
+      @collector = collector
+      @current_group = nil
+    end
+
+    def parse(definition)
+      instance_eval definition
+    end
+
+    def method_missing(name, *args)
+      collector.add_declaration(name.to_s, *args)
+    end
+
+  protected
+    attr_reader :collector
+    attr_accessor :current_group
+
+    def gem(*args)
+      if current_group
+        collector.add_grouped_gem(current_group, *args)
+      else
+        collector.add_gem(*args)
+      end
+    end
+
+    def group(name)
+      if block_given?
+        self.current_group = name
+        yield
+        self.current_group = nil
+      end
+    end
+  end
+end

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.exists? gemfile
+    end
+
+    def gemfile_contents
+      File.read gemfile
+    end
+
+    def gemfile_lock?
+      File.exists? 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
+      system cmd
+      $?.exitstatus == 0
+    end
+  end
+end

data/lib/pessimize/gem.rb

@@ -0,0 +1,25 @@
+module Pessimize
+  class Gem
+    attr_reader :name, :version, :options
+    attr_writer :version
+
+    def initialize(*args)
+      @name = args.shift
+      while arg = args.shift
+        if arg.is_a? Hash
+          @options = arg
+        else
+          @version = arg
+        end
+      end
+    end
+
+    def to_code
+      s = ""
+      s << %Q{gem "#{name}"}
+      s << %Q{, "#{version}"} if version
+      s << %Q{, #{options.inspect}} if options
+      s
+    end
+  end
+end

data/lib/pessimize/gem_collection.rb

@@ -0,0 +1,34 @@
+require_relative 'gem'
+require_relative 'declaration'
+
+module Pessimize
+  class GemCollection
+    attr_reader :gems, :declarations
+
+    def initialize
+      @gems = Hash.new do |hash, missing|
+        hash[missing] = []
+      end
+      @declarations = []
+    end
+
+    def add_gem(*args)
+      add_grouped_gem(:global, *args)
+    end
+
+    def add_grouped_gem(group, *args)
+      self.gems[group] << Gem.new(*args)
+    end
+
+    def add_declaration(name, *args)
+      self.declarations << Declaration.new(name, *args)
+    end
+
+    def all
+      gems.values.flatten
+    end
+
+  protected
+    attr_writer :gems, :declarations
+  end
+end

data/lib/pessimize/gemfile_lock_version_parser.rb

@@ -0,0 +1,35 @@
+module Pessimize
+  class GemfileLockVersionParser
+    attr_reader :versions
+
+    def initialize
+      self.versions = {}
+      self.parse_enabled = false
+    end
+
+    def call(gemfile_lock_file)
+      gemfile_lock_file.each_line do |line|
+        if line.start_with? 'GEM'
+          self.parse_enabled = true
+        end
+        if parse_enabled
+          parse_line(line)
+        end
+      end
+    end
+
+  protected
+    attr_writer :versions
+    attr_accessor :parse_enabled
+
+    def parse_line(line)
+      if line =~ /^\s{4}[a-z0-9]/i
+        line.strip!
+        matches = /([^(]+)\([^0-9]*([^)]+)/.match(line)
+        if matches
+          self.versions[matches[1].strip] = matches[2]
+        end
+      end
+    end
+  end
+end

data/lib/pessimize/pessimizer.rb

@@ -0,0 +1,69 @@
+require 'pessimize/dsl'
+require 'pessimize/gem_collection'
+require 'pessimize/gemfile_lock_version_parser'
+
+module Pessimize
+  class Pessimizer
+    def initialize(file_manager)
+      self.file_manager = file_manager
+      self.collection = GemCollection.new
+      self.dsl = DSL.new collection
+      self.lock_parser = GemfileLockVersionParser.new
+    end
+
+    def run
+      collect_gems_and_versions
+      update_gem_versions
+      write_new_gemfile
+    end
+
+  protected
+    attr_accessor :collection, :dsl, :lock_parser, :file_manager
+
+    def sep(num = 1)
+      "\n" * num
+    end
+
+    def collect_gems_and_versions
+      dsl.parse file_manager.gemfile_contents
+      puts "Collected #{collection.all.length} gems from #{file_manager.gemfile}"
+      lock_parser.call File.open(file_manager.gemfile_lock)
+    end
+
+    def update_gem_versions
+      puts "Updating gem versions with pessimistic operator (~>)"
+      collection.all.each do |gem|
+        if lock_parser.versions.has_key? gem.name
+          gem.version = "~> #{lock_parser.versions[gem.name]}"
+        end
+      end
+    end
+
+    def write_new_gemfile
+      File.delete(file_manager.gemfile)
+      File.open(file_manager.gemfile, 'w') do |f|
+        collection.declarations.each do |dec|
+          f.write(dec.to_code)
+        end
+        f.write sep(2)
+        gem_groups = collection.gems
+        global_gems = gem_groups[:global]
+        gem_groups.delete :global
+        gem_groups.each do |group, gems|
+          f.write("group :#{group} do#{sep}")
+          gems.each do |gem|
+            f.write("  " + gem.to_code + sep)
+          end
+          f.write("end" + sep(2))
+        end
+        if global_gems
+          global_gems.each do |gem|
+            f.write(gem.to_code + sep)
+          end
+        end
+      end
+      puts "Written new Gemfile"
+    end
+
+  end
+end

data/lib/pessimize/shell.rb

@@ -0,0 +1,49 @@
+require 'pessimize/file_manager'
+require 'pessimize/pessimizer'
+
+module Pessimize
+  class Shell
+    def initialize
+      self.file_manager = FileManager.new
+    end
+
+    def run
+      verify_files
+      Pessimizer.new(file_manager).run
+    end
+
+  protected
+    attr_accessor :file_manager
+
+    def sep(num = 1)
+      "\n" * num
+    end
+
+    def verify_files
+      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
+
+      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
+
+    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 = "0.0.2"
+end

data/lib/pessimize/version_mapper.rb

@@ -0,0 +1,11 @@
+module Pessimize
+  class VersionMapper
+    def call(gems, versions)
+      gems.each do |gem|
+        if versions.has_key? gem.name
+          gem.version = "~> #{versions[gem.name]}"
+        end
+      end
+    end
+  end
+end

data/lib/pessimize.rb

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

data/pessimize.gemspec

@@ -0,0 +1,24 @@
+# -*- 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          = "pessimize"
+  gem.version       = Pessimize::VERSION
+  gem.authors       = ["Jon Cairns"]
+  gem.email         = ["jon@joncairns.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/joonty/pessimize"
+
+  gem.add_development_dependency 'rspec', '~> 2.13.0'
+  gem.add_development_dependency 'rake', '~> 10.0.3'
+
+  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"]
+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)